[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
01/02: gnu: lisp-xyz : Sort packages.
|
From: |
guix-commits |
|
Subject: |
01/02: gnu: lisp-xyz : Sort packages. |
|
Date: |
Sat, 25 May 2024 15:47:18 -0400 (EDT) |
glv pushed a commit to branch master
in repository guix.
commit 51966d1bae8d9c2d0e8cd4a9dfbc8b7cf7af18d9
Author: Guillaume Le Vaillant <glv@posteo.net>
AuthorDate: Sat May 25 11:48:09 2024 +0200
gnu: lisp-xyz : Sort packages.
The sbcl-* packages are sorted in alphabetical order, but the cl-* and ecl-*
variants are kept just below the main sbcl package.
* gnu/packages/lisp-xyz.scm: Sort packages.
Change-Id: I95d7151923284bd3d8da57af8ad3a160370941f0
---
gnu/packages/lisp-xyz.scm | 45982 ++++++++++++++++++++++----------------------
1 file changed, 22990 insertions(+), 22992 deletions(-)
diff --git a/gnu/packages/lisp-xyz.scm b/gnu/packages/lisp-xyz.scm
index 7d9dc45f55..3199d954ad 100644
--- a/gnu/packages/lisp-xyz.scm
+++ b/gnu/packages/lisp-xyz.scm
@@ -64,6 +64,8 @@
;;; Common Lisp compilers and tooling go to lisp.scm.
;;; Common Lisp applications should go to the most appropriate file,
;;; e.g. StumpWM is in wm.scm.
+;;; Common Lisp libraries related to code testing facilities go
+;;; to lisp-check.scm.
(define-module (gnu packages lisp-xyz)
#:use-module (gnu packages)
@@ -135,7642 +137,6814 @@
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-19))
-(define-public sbcl-alexandria-plus
- (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5")
- (revision "0"))
+(define-public sbcl-3b-bmfont
+ (let ((commit "332c2262705f161627fc18add0310451a42799af")
+ (revision "3"))
(package
- (name "sbcl-alexandria-plus")
- ;; Version is stated in the ASD file.
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-3b-bmfont")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Symbolics/alexandria-plus";)
+ (url "https://github.com/3b/3b-bmfont/";)
(commit commit)))
- (file-name (git-file-name "cl-alexandria-plus" version))
+ (file-name (git-file-name "cl-3b-bmfont" version))
(sha256
- (base32 "1w9r19610h599303gqlx2x5n8mmdynss2gyl7xilg5h6v8z3hkfl"))))
+ (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-systems '("alexandria+")))
- (native-inputs
- (list sbcl-parachute))
+ `(#:asd-systems '("3b-bmfont"
+ "3b-bmfont/common"
+ "3b-bmfont/json"
+ "3b-bmfont/text"
+ "3b-bmfont/xml")))
(inputs
- (list sbcl-alexandria))
- (home-page "https://symbolics.github.io/alexandria-plus/";)
- (synopsis "Conservative set of extensions to Alexandria utilities")
+ (list sbcl-alexandria
+ sbcl-cxml
+ sbcl-flexi-streams
+ sbcl-jsown
+ sbcl-parse-number
+ sbcl-split-sequence))
+ (home-page "https://github.com/3b/3b-bmfont/";)
+ (synopsis "Read/write bmfont metadata files")
(description
- "@code{cl-alexandria-plus} is a conservative set of extensions to
-@code{cl-alexandria} utilities.")
- (license license:ms-pl))))
+ "This is a Common Lisp library which provides functionality to
+read/write Bit Map Font (BMF) into text, JSON and XML.")
+ (license license:expat))))
-(define-public cl-alexandria-plus
- (sbcl-package->cl-source-package sbcl-alexandria-plus))
+(define-public ecl-3b-bmfont
+ (sbcl-package->ecl-package sbcl-3b-bmfont))
-(define-public ecl-alexandria-plus
- (sbcl-package->ecl-package sbcl-alexandria-plus))
+(define-public cl-3b-bmfont
+ (sbcl-package->cl-source-package sbcl-3b-bmfont))
-(define-public sbcl-alexandria
- (let ((commit "009b7e532071d9777bdbd63b82d776555da95916")
- (revision "0"))
+(define sbcl-3b-bmfont/shinmera
+ (let ((commit "58e529d24b7799d56b4b3f9c8a953b585d42c7d2")
+ (revision "1"))
+ (package (inherit sbcl-3b-bmfont)
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/3b-bmfont/";)
+ (commit commit)))
+ (file-name (git-file-name "3b-bmfont2" version))
+ (sha256
+ (base32
"17zby669b64rhxhk2szamzdgvispimh6ici05xa6x2vz4rvk71jq")))))))
+
+(define-public sbcl-3bmd
+ (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5")
+ (revision "4"))
(package
- (name "sbcl-alexandria")
- (version (git-version "1.4" revision commit))
+ (name "sbcl-3bmd")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/alexandria/alexandria.git";)
+ (url "https://github.com/3b/3bmd";)
(commit commit)))
- (file-name (git-file-name "cl-alexandria" version))
(sha256
- (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9"))))
+ (base32 "12xqih1gnwsn1baqm7bq3kxss73phn06gvd0v1h1vwsjd1xgpq3g"))
+ (file-name (git-file-name "cl-3bmd" version))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems
+ '("3bmd"
+ "3bmd-ext-definition-lists"
+ "3bmd-ext-math"
+ "3bmd-ext-tables"
+ "3bmd-ext-wiki-links"
+ "3bmd-youtube"
+ "3bmd-ext-code-blocks")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-python3-path
+ (lambda _
+ (substitute* "code-blocks.lisp"
+ (("python3") (which "python3"))))))))
(native-inputs
- (list sbcl-rt))
- (synopsis "Collection of portable utilities for Common Lisp")
+ (list sbcl-fiasco))
+ (inputs
+ (list python
+ python-pygments
+ sbcl-alexandria
+ sbcl-colorize
+ sbcl-split-sequence
+ sbcl-esrap))
+ (home-page "https://github.com/3b/3bmd";)
+ (synopsis "Markdown processor in Command Lisp using esrap parser")
(description
- "Alexandria is a collection of portable utilities. It does not contain
-conceptual extensions to Common Lisp. It is conservative in scope, and
-portable between implementations.")
- (home-page "https://common-lisp.net/project/alexandria/";)
- (license license:public-domain))))
-
-(define-public cl-alexandria
- (sbcl-package->cl-source-package sbcl-alexandria))
-
-(define-public ecl-alexandria
- (sbcl-package->ecl-package sbcl-alexandria))
-
-(define-public sbcl-reader
- (package
- (name "sbcl-reader")
- (version "0.10.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/digikar99/reader";)
- (commit (string-append "v" version))))
- (sha256
- (base32 "0pbv6w0d8d4qmfkdsz2rk21bp1las9r7pyvpmd95qjz7kpxrirl7"))
- (file-name (git-file-name "cl-reader" version))))
- (build-system asdf-build-system/sbcl)
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "reader.lisp"
- (("echo")
- (search-input-file inputs "/bin/echo"))))))))
- (inputs
- (list coreutils ; Needed for call to echo.
- sbcl-alexandria
- sbcl-fiveam ; Tests are written directly in the source files.
- sbcl-hash-set
- sbcl-iterate
- sbcl-split-sequence
- sbcl-trivial-types))
- (synopsis "Reader macros for common objects and data structures")
- (description "This package provides a utility library intended
-at providing configurable reader macros for common tasks such as
-accessors, hash-tables, sets, uiop:run-program, arrays and a few others.")
- (home-page "https://github.com/digikar99/reader/";)
- (license license:expat)))
+ "This is a Common Lisp Markdown to HTML converter, using @command{esrap}
+for parsing, and grammar based on @command{peg-markdown}.")
+ (license license:expat))))
-(define-public cl-reader
- (sbcl-package->cl-source-package sbcl-reader))
+(define-public cl-3bmd
+ (sbcl-package->cl-source-package sbcl-3bmd))
-(define-public ecl-reader
- (package
- (inherit (sbcl-package->ecl-package sbcl-reader))
- (arguments
- ;; TODO: Tests fail on call to coreutils echo for ecl.
- `(#:tests? #f))))
+(define-public ecl-3bmd
+ (sbcl-package->ecl-package sbcl-3bmd))
-(define-public sbcl-st-json
- (let ((commit "4a0025bcc5b6921454822f1b9f38f697b4eeaf43")
- (revision "0"))
+(define-public sbcl-3bz
+ (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad")
+ (revision "1"))
(package
- (name "sbcl-st-json")
+ (name "sbcl-3bz")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marijnh/ST-JSON";)
+ (url "https://github.com/3b/3bz";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "06qrhr5iw73k96lai2x9w52l6gnmlxy7fsr0r35gz6nz1f71x7gx"))))
+ (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://marijnhaverbeke.nl/st-json/";)
- (synopsis "JSON for Common Lisp")
+ (inputs
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cffi
+ sbcl-mmap
+ sbcl-nibbles
+ sbcl-trivial-features))
+ (home-page "https://github.com/3b/3bz";)
+ (synopsis "Deflate decompression for Common Lisp")
(description
- "ST-JSON (@code{ST} because it originated at Streamtech) is a Common
Lisp
- library for encoding and decoding JSON values (as specified on json.org).
-
-This library does mostly the same thing as CL-JSON, but is simpler and more
-precise about types (distinguishing boolean false, the empty array, and the
-empty object).")
- (license license:zlib))))
+ "3bz is an implementation of Deflate decompression (RFC 1951) optionally
+with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
+foreign pointers (for use with mmap and similar, etc), and from CL octet
+vectors and streams.")
+ (license license:expat))))
-(define-public cl-st-json
- (sbcl-package->cl-source-package sbcl-st-json))
+(define-public cl-3bz
+ (sbcl-package->cl-source-package sbcl-3bz))
-(define-public ecl-st-json
- (sbcl-package->ecl-package sbcl-st-json))
+(define-public ecl-3bz
+ (sbcl-package->ecl-package sbcl-3bz))
-(define-public sbcl-stdutils
- (let ((commit "4a4e5a4036b815318282da5dee2a22825369137b")
+(define-public sbcl-3d-math
+ (let ((commit "3831b1706d225def95a7301ef48b393b563f0114")
(revision "0"))
(package
- (name "sbcl-stdutils")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-3d-math")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eslick/cl-stdutils";)
+ (url "https://github.com/Shinmera/3d-math";)
(commit commit)))
- (file-name (git-file-name "cl-stdutils" version))
+ (file-name (git-file-name "cl-3d-math" version))
(sha256
- (base32 "16vxxphqdq8264x0aanm36x9r6d3ci1gjf4vf46mwl59gcff4wcj"))))
+ (base32 "052vzx5j7bag9dxvl0j0wrm244js1djldyn31rwxgkq7965rmi5r"))))
(build-system asdf-build-system/sbcl)
- (arguments '(#:tests? #f)) ; There are no tests.
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-cl-fad
- sbcl-cl-ppcre))
- (home-page "https://github.com/eslick/cl-stdutils/";)
- (synopsis "Grab bag of Common Lisp utility functions")
+ (list sbcl-documentation-utils
+ sbcl-type-templates))
+ (home-page "https://shinmera.github.io/3d-math/";)
+ (synopsis "Linear algebra for 2D and 3D computations")
(description
- "This package provides a grab bag of miscellaneous Common Lisp
-utilities.")
- (license license:bsd-3))))
-
-(define-public cl-stdutils
- (sbcl-package->cl-source-package sbcl-stdutils))
+ "The @code{3d-math} library implements types, operators, and algorithms
+commonly used in math for 2D and 3D graphics. It supersedes and combines the
+prior libraries @code{3d-vectors}, @code{3d-matrices}, @code{3d-quaternions},
+and @code{3d-transforms}. The new API is largely but not entirely backwards
+compatible, and adds new functionality.")
+ (license license:zlib))))
-(define-public ecl-stdutils
- (sbcl-package->ecl-package sbcl-stdutils))
+(define-public cl-3d-math
+ (sbcl-package->cl-source-package sbcl-3d-math))
-(define-public sbcl-langutils
- (let ((commit "38beec7a82eeb35b0bfb0824a41d13ed94fc648b")
- (revision "0"))
+(define-public ecl-3d-math
+ (sbcl-package->ecl-package sbcl-3d-math))
+
+(define-public sbcl-3d-matrices
+ (let ((commit "b4f5a58299f8437fad2d77f0879c374e3430f4b5")
+ (revision "2"))
(package
- (name "sbcl-langutils")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-3d-matrices")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eslick/cl-langutils";)
+ (url "https://github.com/Shinmera/3d-matrices";)
(commit commit)))
- (file-name (git-file-name "cl-langutils" version))
+ (file-name (git-file-name "cl-3d-matrices" version))
(sha256
- (base32 "15y9x5wkg3fqndc04w2sc650fnwimxp4gjgpv9xvvdm9x4v433x6"))))
+ (base32 "1s8b4zlmqwyplghs73riz1khf0c5sk64w6b12jd599091d5nr6sr"))))
(build-system asdf-build-system/sbcl)
- (arguments '(#:tests? #f)) ; There are no tests.
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-stdutils
- sbcl-s-xml-rpc))
- (home-page "https://langutils.common-lisp.dev/";)
- (synopsis "Common Lisp natural language processing toolkit")
+ (list sbcl-3d-vectors sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/3d-matrices/";)
+ (synopsis "Utility library implementing 2x2, 3x3, 4x4 and NxM matrices")
(description
- "This package provides a hierarchy of major functions and auxiliary
-functions related to the structured analysis and processing of open
-text.")
- (license license:bsd-3))))
+ "@code{3D-MATRICES} is a library implementing common matrix operations,
+mainly intended as the counterpiece to @code{3d-vectors} and thus being aimed
at
+operations in 3D space.")
+ (license license:zlib))))
-(define-public cl-langutils
- (sbcl-package->cl-source-package sbcl-langutils))
+(define-public cl-3d-matrices
+ (sbcl-package->cl-source-package sbcl-3d-matrices))
-(define-public ecl-langutils
- (sbcl-package->ecl-package sbcl-langutils))
+(define-public ecl-3d-matrices
+ (sbcl-package->ecl-package sbcl-3d-matrices))
-(define-public sbcl-hash-set
- (let ((commit "6feb20de457f14e24a83815be1097aa02cca5986")
+(define-public sbcl-3d-quaternions
+ (let ((commit "b79c15cca8d9c409216a6cee8ec9e182dcdec9e2")
(revision "0"))
(package
- (name "sbcl-hash-set")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-3d-quaternions")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/samebchase/hash-set";)
+ (url "https://github.com/Shinmera/3d-quaternions";)
(commit commit)))
- (file-name (git-file-name "cl-hash-set" version))
+ (file-name (git-file-name "cl-3d-quaternions" version))
(sha256
- (base32 "0a966y9yfarhmki4wwzg371ziaygnp13yc6r13w9zz327fkhz8na"))))
+ (base32 "1mrq6yhb90mhvxdkg3fx58ci5yj5xlixbbzf1q6p76wyq40qjv76"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (inputs (list sbcl-alexandria))
- (home-page "https://github.com/samebchase/hash-set/";)
- (synopsis "Implementation of a hash-set")
- (description "This package provides an implementation of the
-hash-set data structure. It has constant time lookup, insertion and
-deletion.")
- (license license:unlicense))))
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-3d-matrices sbcl-3d-vectors sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/3d-quaternions/";)
+ (synopsis "Quaternion and dual-quaternion functionality in Common Lisp")
+ (description
+ "This is a library for quaternions. It contains most of the quaternion
+operations one would usually expect out of such a library and offers them both
+in non-modifying and modifying versions where applicable. It also tries to be
+efficient where plausible. Each quaternion is made up of @code{float}s, which
+by default are @code{single-float}s, as they do not require value boxing on
+most modern systems and compilers.")
+ (license license:zlib))))
-(define-public cl-hash-set
- (sbcl-package->cl-source-package sbcl-hash-set))
+(define-public cl-3d-quaternions
+ (sbcl-package->cl-source-package sbcl-3d-quaternions))
-(define-public ecl-hash-set
- (sbcl-package->ecl-package sbcl-hash-set))
+;; TODO: Build failure:
+;; https://github.com/Shinmera/3d-quaternions/issues/2
+;;
+;; (define-public ecl-3d-quaternions
+;; (sbcl-package->ecl-package sbcl-3d-quaternions))
-(define-public sbcl-duologue
- (let ((commit "ea1ada244a81da65f85b548823c9a6d7c9c145e1")
+(define-public sbcl-3d-spaces
+ (let ((commit "a93f4915affcf65617366297ad8bd2ec77bae702")
(revision "0"))
(package
- (name "sbcl-duologue")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-3d-spaces")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/duologue";)
+ (url "https://github.com/Shirakumo/3d-spaces";)
(commit commit)))
- (file-name (git-file-name "cl-duologue" version))
+ (file-name (git-file-name "cl-3d-spaces" version))
(sha256
- (base32 "1yg7f27im9h0m6jihcay1p7alfhzm9hafwm5dw5hsyacy8f2cwk2"))))
+ (base32 "1m5cg5zy1731dcgkm1p4m53z1zsp387xligxh32pdrnrhc2lzhmf"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-stefil))
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-chronicity
- sbcl-cl-ansi-text
- sbcl-cl-fad
- sbcl-clavier
- sbcl-drakma))
- (home-page "https://github.com/mmontone/duologue/";)
- (synopsis "High level user interaction library")
+ (list sbcl-3d-math
+ sbcl-documentation-utils
+ sbcl-for
+ sbcl-trivial-extensible-sequences))
+ (home-page "https://shirakumo.github.io/3d-spaces/";)
+ (synopsis "Implementations of various spatial query structures")
(description
- "Duologue is high-level interaction library for Common Lisp. It
features
-coloured printing via @code{cl-ansi-text} and readline completion.")
- (license (list license:expat
- ;; https://github.com/mmontone/duologue/issues/9
- license:gpl3+)))))
-
-(define-public cl-duologue
- (sbcl-package->cl-source-package sbcl-duologue))
-
-(define-public ecl-duologue
- (sbcl-package->ecl-package sbcl-duologue))
-
-(define-public sbcl-alea
- (package
- (name "sbcl-alea")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/eXodiquas/alea";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-alea" version))
- (sha256
- (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (synopsis "Dice rolling library")
- (description
- "This package provides a Common Lisp library for dice rolling and working
-with dice-roll statistics.")
- (home-page "https://github.com/eXodiquas/alea";)
- (license license:expat)))
+ "The 3D-Spaces library implements a number of spatial query data
+structures; structures that can answer spatial range queries for optimized
+lookup, particularly suited for games.")
+ (license license:zlib))))
-(define-public cl-alea
- (sbcl-package->cl-source-package sbcl-alea))
+(define-public cl-3d-spaces
+ (sbcl-package->cl-source-package sbcl-3d-spaces))
-(define-public ecl-alea
- (sbcl-package->ecl-package sbcl-alea))
+(define-public ecl-3d-spaces
+ (sbcl-package->ecl-package sbcl-3d-spaces))
-(define-public sbcl-cf
- (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e")
- (revision "2"))
+(define-public sbcl-3d-transforms
+ (let ((commit "1d44509387d0747cd0351e95a533eca609058632")
+ (revision "0"))
(package
- (name "sbcl-cf")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-3d-transforms")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/cl-cf";)
+ (url "https://github.com/Shinmera/3d-transforms";)
(commit commit)))
- (file-name (git-file-name "cl-cf" version))
+ (file-name (git-file-name "cl-3d-transforms" version))
(sha256
- (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig"))))
+ (base32 "03pmv7dh1j6kl16ch6lnvxzjrld4jbr3jx8slzkiipgzdxg74pcx"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (synopsis "Continued fractions library")
- (description "CF is a Common Lisp library for doing computations using
-continued fractions.")
- (home-page "https://codeberg.org/glv/cl-cf";)
- (license license:gpl3+))))
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-3d-matrices
+ sbcl-3d-quaternions
+ sbcl-3d-vectors
+ sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/3d-transforms/";)
+ (synopsis
+ "Common structure to encapsulate spatial transformations in Common
Lisp")
+ (description
+ "This is a library that uses the other 3d-* math libraries to present an
+encapsulation for a spatial transformation. It offers convenience functions
for
+operating on such transformations and for converting between them and the
+alternative 4x4 matrix representation.")
+ (license license:zlib))))
-(define-public cl-cf
- (sbcl-package->cl-source-package sbcl-cf))
+(define-public cl-3d-transforms
+ (sbcl-package->cl-source-package sbcl-3d-transforms))
-(define-public ecl-cf
- (sbcl-package->ecl-package sbcl-cf))
+;; TODO: Build failure:
+;; https://github.com/Shinmera/3d-quaternions/issues/2
+;;
+;; (define-public ecl-3d-transforms
+;; (sbcl-package->ecl-package sbcl-3d-transforms))
-(define-public sbcl-bubble-operator-upwards
- (let ((commit "846275a318b960de81b62caecb1e31930f70aef6")
- (revision "0"))
+(define-public sbcl-3d-vectors
+ (let ((commit "257969402864ac3859d77b981abf0aa5373c4e78")
+ (revision "2"))
(package
- (name "sbcl-bubble-operator-upwards")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-3d-vectors")
+ (version (git-version "3.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Hexstream/bubble-operator-upwards";)
+ (url "https://github.com/Shinmera/3d-vectors";)
(commit commit)))
- (file-name (git-file-name "cl-bubble-operator-upwards" version))
+ (file-name (git-file-name "cl-3d-vectors" version))
(sha256
- (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi"))))
+ (base32 "0vmf7nycc49ydcy0dfs25cgs655kwjc6jcjvpwxw61jq4gl2fh7x"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-parachute))
- (home-page
"https://www.hexstreamsoft.com/libraries/bubble-operator-upwards/";)
- (synopsis "Function that bubbles an operator upwards in a form")
+ (inputs
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/3d-vectors/";)
+ (synopsis "Utility library implementing 2D, 3D, and 4D vectors")
(description
- "@code{bubble-operator-upwards} is a function that bubbles an operator
-upwards in a form, demultiplexing all alternative branches by way of
-cartesian product.")
- (license license:unlicense))))
+ "@code{3D-VECTORS} is a library for vector math in 3D space. It
contains
+most of the vector operations one would usually expect out of such a library
and
+offers them both in non-modifying and modifying versions where applicable.")
+ (license license:zlib))))
-(define-public cl-bubble-operator-upwards
- (sbcl-package->cl-source-package sbcl-bubble-operator-upwards))
+(define-public cl-3d-vectors
+ (sbcl-package->cl-source-package sbcl-3d-vectors))
-(define-public ecl-bubble-operator-upwards
- (sbcl-package->ecl-package sbcl-bubble-operator-upwards))
+(define-public ecl-3d-vectors
+ (sbcl-package->ecl-package sbcl-3d-vectors))
-(define-public sbcl-map-bind
- (let ((commit "532d55d93540c632e22b2cd264b5daa5f9d3d900")
- (revision "0"))
- (package
- (name "sbcl-map-bind")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/map-bind";)
- (commit commit)))
- (file-name (git-file-name "cl-map-bind" version))
- (sha256
- (base32 "0hfy65xyqc4zqfncn11pp3hjjkdz7m91cynnv91s3lgcl3kffva0"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (home-page "https://www.hexstreamsoft.com/libraries/map-bind/";)
- (synopsis "Macro favouring positional references over naming")
- (description
- "@code{MAP-BIND} is a macro that allows visual grouping of variables
with
-their corresponding values in calls to mapping operators when using an
-inline @code{LAMBDA}.")
- (license license:unlicense))))
-
-(define-public cl-map-bind
- (sbcl-package->cl-source-package sbcl-map-bind))
-
-(define-public ecl-cl-map-bind
- (sbcl-package->ecl-package sbcl-map-bind))
-
-(define-public sbcl-positional-lambda
- (let ((commit "a43a7bb4ef6faa277e6a7440ec9839711c4b9d28")
- (revision "0"))
- (package
- (name "sbcl-positional-lambda")
- (version (git-version "2.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/positional-lambda";)
- (commit commit)))
- (file-name (git-file-name "cl-positional-lambda" version))
- (sha256
- (base32 "1l27mw5ciqz7rnjq1lwslgk220i8iqcr39rs8b7hxkp1yqmah5zq"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-map-bind))
- (home-page "https://www.hexstreamsoft.com/libraries/positional-lambda/";)
- (synopsis "Macro favouring positional references over naming")
- (description
- "This package provides a concise, intuitive and flexible macro for
-trivial lambdas that eschews explicit naming of parameter variables in favor
-of positional references, with support for a used or ignored &rest parameter
-and automatic declaration of ignored parameters when logical @code{gaps}
-are left in the positional references. Further convenience features
-are provided.")
- (license license:unlicense))))
-
-(define-public cl-positional-lambda
- (sbcl-package->cl-source-package sbcl-positional-lambda))
-
-(define-public ecl-cl-positional-lambda
- (sbcl-package->ecl-package sbcl-positional-lambda))
-
-(define-public sbcl-bodge-utilities
- (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f")
- (revision "1"))
- (package
- (name "sbcl-bodge-utilities")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/borodust/bodge-utilities";)
- (commit commit)))
- (file-name (git-file-name "bodge-utilities" version))
- (sha256
- (base32 "1z1blj05q71vzh323qwyn9p3xs7v0mq2yhwfyzza5libp37wqm3c"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cffi
- sbcl-claw
- sbcl-dissect
- sbcl-local-time
- sbcl-log4cl
- sbcl-split-sequence
- sbcl-static-vectors
- sbcl-trivial-gray-streams))
- (home-page "https://github.com/borodust/bodge-utilities";)
- (synopsis "Common Lisp utilities library for CL-BODGE")
- (description
- "This Common Lisp library provides utilities for the @emph{Bodge} library
-collection.")
- (license license:expat))))
-
-(define-public ecl-bodge-utilities
- (sbcl-package->ecl-package sbcl-bodge-utilities))
-
-(define-public cl-bodge-utilities
- (sbcl-package->cl-source-package sbcl-bodge-utilities))
-
-(define-public sbcl-meta
- (let ((commit "74faea662139fbbfb9c99341aaed989f5b0e9da3")
+(define-public sbcl-40ants-doc
+ (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b")
(revision "0"))
(package
- (name "sbcl-meta")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-40ants-doc")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/frideau/meta";)
+ (url "https://github.com/40ants/doc";)
(commit commit)))
- (file-name (git-file-name "cl-meta" version))
(sha256
- (base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy"))))
+ (base32 "1v6gnhrk02vsixmprzk4wvvj7vh11vp5waxyih0qz2ih8d38r5pg"))
+ (file-name (git-file-name "cl-40ants-doc" version))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: Add remaining dependencies of 40ants-doc-full and
+ ;; 40ants-doc-test missing from Guix.
+ '(#:asd-systems '("40ants-doc"
+ ;;"40ants-doc-full"
+ )
+ #:tests? #f))
+ ;;(native-inputs
+ ;; (list sbcl-rove))
(inputs
- (list sbcl-named-readtables))
- (home-page "https://gitlab.common-lisp.net/frideau/meta";)
- (synopsis "Recursive-descent parser DSL for Common Lisp")
+ (list sbcl-named-readtables
+ sbcl-pythonic-string-reader
+ ;; For 40ants-doc-full:
+ ;;sbcl-3bmd
+ ;;sbcl-alexandria
+ ;;sbcl-babel
+ ;;sbcl-cl-cookie
+ ;;sbcl-cl-fad
+ ;;sbcl-cl-ppcre
+ ;;sbcl-common-doc ; Missing from Guix
+ ;;sbcl-common-html ; Missing from Guix
+ ;;sbcl-commondoc-markdown ; Missing from Guix
+ ;;sbcl-dexador
+ ;;sbcl-docs-builder ; Missing from Guix
+ ;;sbcl-fare-utils
+ ;;sbcl-jonathan
+ ;;sbcl-lass
+ ;;sbcl-local-time
+ ;;sbcl-log4cl
+ ;;sbcl-slime-swank
+ ;;sbcl-slynk
+ ;;sbcl-spinneret
+ ;;sbcl-stem ; Missing from Guix; also, license is unconfirmed
+ ;;sbcl-str
+ ;;sbcl-tmpdir ; Missing from Guix
+ ;;sbcl-trivial-extract ; Missing from Guix
+ ;;sbcl-xml-emitter
+ ))
+ (home-page "https://40ants.com/doc/";)
+ (synopsis "Exploratory programming environment and documentation
generator")
(description
- "This package provides a recursive-descent parser DSL for Common Lisp.
-It's intended as a simpler alternative to parser generators.")
- (license license:bsd-2))))
+ "@code{40ants-doc} provides a rudimentary explorable programming
+environment. The narrative primarily lives in so-called sections that mix
+Markdown docstrings with references to functions, variables, etc., all of
+which should probably have their own docstrings.
-(define-public cl-meta
- (sbcl-package->cl-source-package sbcl-meta))
+The primary focus is on making code easily explorable by using SLIME's
+@kbd{M-.} (@code{slime-edit-definition}). Generating documentation in
+Markdown or HTML format from sections and all the referenced items is also
+implemented.
-(define-public ecl-meta
- (sbcl-package->ecl-package sbcl-meta))
+With the simplistic tools provided, one may obtain results similar to literate
+programming, but documentation is generated from code, not the other way
+around, and there is no support for chunking. Code comes first, code must
+look pretty, documentation is code.
-(define-public sbcl-cl-smtp
- (let ((commit "ed47d326fad867ee11323fa3a0f307b5d40e8f2b")
- (revision "0"))
+@code{40ants-doc} is a fork of MGL-PAX with fewer dependencies (only
+@code{named-readtables} and @code{pythonic-string-reader}) for the core
+system, and additional features in the full system.")
+ (license license:expat))))
+
+(define-public cl-40ants-doc
+ (sbcl-package->cl-source-package sbcl-40ants-doc))
+
+(define-public ecl-40ants-doc
+ (sbcl-package->ecl-package sbcl-40ants-doc))
+
+(define-public sbcl-abstract-classes
+ (let ((commit "7fa74f1e057f9ba7c1ffecff14f049f979e45267")
+ (revision "1"))
(package
- (name "sbcl-cl-smtp")
- (version (git-version "20191031.1" revision commit))
+ (name "sbcl-abstract-classes")
+ (version (git-version "1.7.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp";)
+ (url "https://bitbucket.org/eeeickythump/cl-abstract-classes";)
(commit commit)))
- (file-name (git-file-name "cl-smtp" version))
+ (file-name (git-file-name "cl-abstract-classes" version))
(sha256
- (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0"))))
+ (base32 "06lby4i6xbbgs7kgb0f3fqybvyskyg6djhrf967lnysv7hn3zpg9"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl+ssl
- sbcl-cl-base64
- sbcl-flexi-streams
- sbcl-trivial-gray-streams
- sbcl-usocket))
- (home-page "https://gitlab.common-lisp.net/cl-smtp/cl-smtp";)
- (synopsis "Simple Common Lisp SMTP client")
- (description "This package provides a client for SMTP.")
- (license license:llgpl))))
+ `(("closer-mop" ,sbcl-closer-mop)))
+ (arguments
+ `(#:asd-systems '("abstract-classes" "singleton-classes")))
+ (home-page "https://bitbucket.org/eeeickythump/cl-abstract-classes";)
+ (synopsis "Abstract, final, and singleton metaclasses for CLOS")
+ (description
+ "This package provides Common Lisp extension to the MOP to allow
+abstract, final and singleton classes.")
+ (license license:public-domain))))
-(define-public cl-smtp
- (sbcl-package->cl-source-package sbcl-cl-smtp))
+(define-public ecl-abstract-classes
+ (sbcl-package->ecl-package sbcl-abstract-classes))
-(define-public ecl-cl-smtp
- (sbcl-package->ecl-package sbcl-cl-smtp))
+(define-public cl-abstract-classes
+ (sbcl-package->cl-source-package sbcl-abstract-classes))
-(define-public sbcl-clavier
- (let ((commit "9b1424eaad131e114a45b400784079124b5e2321")
+(define-public sbcl-access
+ (let ((commit "a4f87fc1007f5c9a0a2abfddc1c23a77e87096f8")
(revision "1"))
(package
- (name "sbcl-clavier")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-access")
+ (version (git-version "1.6.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/clavier";)
+ (url "https://github.com/AccelerationNet/access";)
(commit commit)))
- (file-name (git-file-name "cl-clavier" version))
+ (file-name (git-file-name "cl-access" version))
(sha256
- (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y"))))
+ (base32 "0zdjqhb9rvnlq6nzmsp7372gi91k1rq9bz510m6hcki7g3r01iv5"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-stefil))
+ (native-inputs
+ (list sbcl-lisp-unit2))
(inputs
(list sbcl-alexandria
- sbcl-chronicity
- sbcl-cl-fad
sbcl-cl-ppcre
- sbcl-closer-mop))
- (home-page "https://github.com/mmontone/clavier/";)
- (synopsis "General purpose validation library")
- (description "Clavier is a general purpose validation library for
-Common Lisp.")
- (license license:expat))))
+ sbcl-closer-mop
+ sbcl-iterate))
+ (synopsis
+ "Common lisp library to unify access to dictionary-like structures")
+ (description
+ "This is a Common lisp library to unify access to the most common
+dictionary-like data structures.")
+ (home-page "https://github.com/AccelerationNet/access";)
+ (license license:bsd-3))))
-(define-public cl-clavier
- (sbcl-package->cl-source-package sbcl-clavier))
+(define-public ecl-access
+ (sbcl-package->ecl-package sbcl-access))
-(define-public ecl-clavier
- (sbcl-package->ecl-package sbcl-clavier))
+(define-public cl-access
+ (sbcl-package->cl-source-package sbcl-access))
-(define-public sbcl-cl-inotify
- (let ((commit "66f29e01ec28355ebba8292411b4de90eebd76a3")
- (revision "0"))
+(define-public sbcl-acclimation
+ (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
(package
- (name "sbcl-cl-inotify")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-acclimation")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Ferada/cl-inotify";)
+ (url "https://github.com/robert-strandh/Acclimation";)
(commit commit)))
- (file-name (git-file-name "cl-inotify" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0d3bvp5lqnddzhk1w9yyli03njbkhc8d129a058g0j49kgd47c7v"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (inputs
- (list libfixposix
- sbcl-binary-types
- sbcl-cffi
- sbcl-osicat
- sbcl-trivial-utf-8))
- (synopsis "Common Lisp interface to the Linux inotify API")
- (description
- "@code{cl-inotify} uses @code{cl-cffi} to provide a Common Lisp
-interface to the Linux inotify API.")
- (home-page "https://github.com/Ferada/cl-inotify/";)
- (license license:bsd-2))))
+ (base32
+ "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/Acclimation";)
+ (synopsis "Internationalization library for Common Lisp")
+ (description "This project is meant to provide tools for
+internationalizing Common Lisp programs.
-(define-public cl-inotify
- (sbcl-package->cl-source-package sbcl-cl-inotify))
+One important aspect of internationalization is of course the language used in
+error messages, documentation strings, etc. But with this project we provide
+tools for all other aspects of internationalization as well, including dates,
+weight, temperature, names of physical quantitites, etc.")
+ (license license:bsd-2))))
-(define-public ecl-cl-inotify
- (sbcl-package->ecl-package sbcl-cl-inotify))
+(define-public cl-acclimation
+ (sbcl-package->cl-source-package sbcl-acclimation))
-(define-public sbcl-file-notify
- (let ((commit "f12dc2f2aae5fee13355cd93a8cae0c4c412b76d")
- (revision "0"))
+(define-public ecl-acclimation
+ (sbcl-package->ecl-package sbcl-acclimation))
+
+(define-public sbcl-acl-compat
+ ;; There does not seem to be proper releases.
+ (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5"))
(package
- (name "sbcl-file-notify")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-acl-compat")
+ (version (git-version "0.1.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/file-notify";)
+ (url "git://git.code.sf.net/p/portableaserve/git")
(commit commit)))
- (file-name (git-file-name "cl-file-notify" version))
+ (file-name (git-file-name "acl-compat" version))
(sha256
- (base32 "0788d98rqm1krl8nbfh8qshvyf6g336i9bqrdhkx06cfvbh0wcny"))))
+ (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'cd-acl-compat
+ (lambda _
+ (chdir "acl-compat")
+ #t)))))
(inputs
- (list sbcl-cffi
- sbcl-documentation-utils
- sbcl-trivial-features))
- (home-page "https://github.com/Shinmera/file-notify";)
- (synopsis "Get notifications for file accesses and changes")
+ `(("puri" ,sbcl-puri)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("ironclad" ,sbcl-ironclad)
+ ("cl-fad" ,sbcl-cl-fad)))
+ (home-page "https://sourceforge.net/projects/portableaserve/";)
+ (synopsis "AllegroServe, a web server written in Common Lisp")
(description
- "File-Notify is a Common Lisp library for getting notifications for file
-accesses and changes.")
- (license license:zlib))))
-
-(define-public cl-file-notify
- (sbcl-package->cl-source-package sbcl-file-notify))
+ "The server part of AllegroServe can be used either as a standalone web
+server or a module loaded into an application to provide a user interface to
+the application. AllegroServe's proxy ability allows it to run on the gateway
+machine between some internal network and the Internet. AllegroServe's client
+functions allow Lisp programs to explore the web.")
+ (license license:llgpl))))
-(define-public ecl-file-notify
- (sbcl-package->ecl-package sbcl-file-notify))
+(define-public cl-acl-compat
+ (sbcl-package->cl-source-package sbcl-acl-compat))
-(define-public sbcl-file-select
- (let ((commit "ef25f6d7c78ed9e0b62119979af8c4b5b0f8c774")
- (revision "1"))
- (package
- (name "sbcl-file-select")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/file-select";)
- (commit commit)))
- (file-name (git-file-name "file-select" version))
- (sha256
- (base32 "1qh32ymljw5c98zzbvjfq6jzwlzs4qxi8gh4gw8pixir6y1inxaa"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cffi
- sbcl-documentation-utils
- sbcl-float-features))
- (home-page "https://shinmera.github.io/file-select/";)
- (synopsis "Invoke the native file selection dialogs to open or save
files")
- (description
- "This library allows you to open native file dialogs to open and save
-files. This is useful if you have an application that's primarily text based
-and would like a more convenient file selection utility, or if you are working
-with a UI toolkit that does not offer a way to access the native file dialogs
-directly.")
- (license license:zlib))))
+(define-public sbcl-adopt
+ (package
+ (name "sbcl-adopt")
+ (version "1.2.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sjl/adopt";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-adopt" version))
+ (sha256
+ (base32 "16kzkai96qk7vmclp8wxc9aghhnisw8gg9s7hra68300bgj86wzr"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-1am))
+ (inputs (list sbcl-bobbin sbcl-split-sequence))
+ (home-page "https://hg.stevelosh.com/adopt";)
+ (synopsis "Common Lisp option parsing library")
+ (description
+ "@acronym{ADOPT, A Damn OPTion} is a simple UNIX-style option parser in
+Common Lisp, heavily influenced by Python's @code{optparse} and
+@code{argparse}.")
+ (license license:expat)))
-(define-public cl-file-select
- (sbcl-package->cl-source-package sbcl-file-select))
+(define-public cl-adopt
+ (sbcl-package->cl-source-package sbcl-adopt))
-(define-public ecl-file-select
- (sbcl-package->ecl-package sbcl-file-select))
+(define-public ecl-adopt
+ (sbcl-package->ecl-package sbcl-adopt))
-(define-public sbcl-bodge-queue
- (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a")
- (revision "0"))
+(define-public sbcl-agnostic-lizard
+ (let ((commit "fe1a1d7d80c8b56163754e0e5b3653fd750ad298")
+ (revision "2"))
(package
- (name "sbcl-bodge-queue")
+ (name "sbcl-agnostic-lizard")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/borodust/bodge-queue";)
+ (url "https://gitlab.common-lisp.net/mraskin/agnostic-lizard";)
(commit commit)))
- (file-name (git-file-name "bodge-queue" version))
+ (file-name (git-file-name "cl-agnostic-lizard" version))
(sha256
- (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr"))))
+ (base32 "0amzshh6v3mp24j0h2cinv4zvdlg4kih04md5biakwhnmcw4j4pr"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/borodust/bodge-queue";)
- (synopsis "Simple queue for Common Lisp")
- (description "This Common Lisp library provides a simple FIFO
-implementation with no external dependencies.")
- (license license:expat))))
+ (synopsis "Almost correct portable code walker for Common Lisp")
+ (description
+ "Agnostic Lizard is a portable implementation of a code walker and in
+particular of the macroexpand-all function (and macro) that makes a best
+effort to be correct while not expecting much beyond what the Common Lisp
+standard requires.
-(define-public cl-bodge-queue
- (sbcl-package->cl-source-package sbcl-bodge-queue))
+It aims to be implementation-agnostic and to climb the syntax trees.")
+ (home-page "https://gitlab.common-lisp.net/mraskin/agnostic-lizard";)
+ (license license:gpl3+))))
-(define-public ecl-bodge-queue
- (sbcl-package->ecl-package sbcl-bodge-queue))
+(define-public cl-agnostic-lizard
+ (sbcl-package->cl-source-package sbcl-agnostic-lizard))
-(define-public sbcl-list-named-class
- (let ((commit "2955791a7469131bcab42d800883f27993ee1d62")
- (revision "0"))
+(define-public ecl-agnostic-lizard
+ (sbcl-package->ecl-package sbcl-agnostic-lizard))
+
+(define-public sbcl-agutil
+ (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68"))
(package
- (name "sbcl-list-named-class")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-agutil")
+ (version (git-version "0.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/list-named-class";)
+ (url "https://github.com/alex-gutev/agutil/";)
(commit commit)))
- (file-name (git-file-name "cl-list-named-class" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1bdi9q9wvfj66jji3n9hpjrj9271ial2awsb0xw80bmy6wqbg8kq"))))
+ (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-1am))
(inputs
- (list sbcl-alexandria sbcl-closer-mop))
- (home-page "https://github.com/phoe/list-named-class/";)
- (synopsis "Name classes after lists of symbols")
- (description
- "This package makes it possible to name classes by lists of symbols
-instead of symbols.")
+ (list sbcl-alexandria sbcl-trivia))
+ (home-page "https://github.com/alex-gutev/agutil/";)
+ (synopsis "Collection of Common Lisp utilities")
+ (description "A collection of Common Lisp utility functions and macros
+mostly not found in other utility packages.")
(license license:expat))))
-(define-public cl-list-named-class
- (sbcl-package->cl-source-package sbcl-list-named-class))
+(define-public cl-agutil
+ (sbcl-package->cl-source-package sbcl-agutil))
-(define-public ecl-list-named-class
- (sbcl-package->ecl-package sbcl-list-named-class))
+(define-public ecl-agutil
+ (sbcl-package->ecl-package sbcl-agutil))
-(define-public sbcl-golden-utils
- (let ((commit "e43914ad2bdb0c8e1b1f10ef591aafc3c55b89e7")
- (revision "4"))
+(define-public sbcl-alea
+ (package
+ (name "sbcl-alea")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/eXodiquas/alea";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-alea" version))
+ (sha256
+ (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiveam))
+ (synopsis "Dice rolling library")
+ (description
+ "This package provides a Common Lisp library for dice rolling and working
+with dice-roll statistics.")
+ (home-page "https://github.com/eXodiquas/alea";)
+ (license license:expat)))
+
+(define-public cl-alea
+ (sbcl-package->cl-source-package sbcl-alea))
+
+(define-public ecl-alea
+ (sbcl-package->ecl-package sbcl-alea))
+
+(define-public sbcl-alexa
+ (package
+ (name "sbcl-alexa")
+ (version "2.1.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/quil-lang/alexa";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-alexa" version))
+ (sha256
+ (base32 "1y9jyz9gfmd02h492kf7v3mmpbhc0yfh4ka2rzd1vczq6fl8qgqv"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiasco))
+ (inputs (list sbcl-alexandria sbcl-cl-ppcre))
+ (synopsis "Lexical Analyzer Generator for Common Lisp")
+ (description
+ "ALEXA is a tool similar to lex or flex for generating lexical analyzers.
+Unlike tools like lex, however, ALEXA defines a domain-specific language
+within your Lisp program, so you don't need to invoke a separate tool.")
+ (home-page "https://github.com/quil-lang/alexa";)
+ (license license:bsd-3)))
+
+(define-public ecl-alexa
+ (sbcl-package->ecl-package sbcl-alexa))
+
+(define-public cl-alexa
+ (sbcl-package->cl-source-package sbcl-alexa))
+
+(define-public sbcl-alexandria
+ (let ((commit "009b7e532071d9777bdbd63b82d776555da95916")
+ (revision "0"))
(package
- (name "sbcl-golden-utils")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/lisp-mirror/golden-utils";)
+ (name "sbcl-alexandria")
+ (version (git-version "1.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://gitlab.common-lisp.net/alexandria/alexandria.git";)
(commit commit)))
- (file-name (git-file-name "cl-golden-utils" version))
+ (file-name (git-file-name "cl-alexandria" version))
(sha256
- (base32 "09vq29wjr3x7h3fshwxg8h1psy4p73yl61cjljarpqjhsgz7lmbp"))))
+ (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (synopsis "Common Lisp utility library")
+ (native-inputs
+ (list sbcl-rt))
+ (synopsis "Collection of portable utilities for Common Lisp")
(description
- "This is a Common Lisp library providing various utilities.")
- (license license:expat))))
+ "Alexandria is a collection of portable utilities. It does not contain
+conceptual extensions to Common Lisp. It is conservative in scope, and
+portable between implementations.")
+ (home-page "https://common-lisp.net/project/alexandria/";)
+ (license license:public-domain))))
-(define-public ecl-golden-utils
- (sbcl-package->ecl-package sbcl-golden-utils))
+(define-public cl-alexandria
+ (sbcl-package->cl-source-package sbcl-alexandria))
-(define-public cl-golden-utils
- (sbcl-package->cl-source-package sbcl-golden-utils))
+(define-public ecl-alexandria
+ (sbcl-package->ecl-package sbcl-alexandria))
-(define-public sbcl-asdf-finalizers
- (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
- (revision "1"))
+(define-public sbcl-alexandria-plus
+ (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5")
+ (revision "0"))
(package
- (name "sbcl-asdf-finalizers")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-alexandria-plus")
+ ;; Version is stated in the ASD file.
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers";)
+ (url "https://github.com/Symbolics/alexandria-plus";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-alexandria-plus" version))
(sha256
- (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v"))))
+ (base32 "1w9r19610h599303gqlx2x5n8mmdynss2gyl7xilg5h6v8z3hkfl"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("alexandria+")))
(native-inputs
- `(("fare-utils" ,sbcl-fare-utils)
- ("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
- (home-page "https://gitlab.common-lisp.net/asdf/asdf-finalizers";)
- (synopsis "Enforced calling of finalizers for Lisp code")
- (description "This library allows you to implement and enforce proper
-finalization of compile-time constructs while building Lisp source files.
-
-It produces two systems: asdf-finalizers and list-of.")
- (license license:expat))))
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://symbolics.github.io/alexandria-plus/";)
+ (synopsis "Conservative set of extensions to Alexandria utilities")
+ (description
+ "@code{cl-alexandria-plus} is a conservative set of extensions to
+@code{cl-alexandria} utilities.")
+ (license license:ms-pl))))
-(define-public ecl-asdf-finalizers
- (sbcl-package->ecl-package sbcl-asdf-finalizers))
+(define-public cl-alexandria-plus
+ (sbcl-package->cl-source-package sbcl-alexandria-plus))
-(define-public cl-asdf-finalizers
- (sbcl-package->cl-source-package sbcl-asdf-finalizers))
+(define-public ecl-alexandria-plus
+ (sbcl-package->ecl-package sbcl-alexandria-plus))
-(define-public sbcl-asdf-system-connections
- (let ((commit "9f085240febccccff99d9d3bb687fcaafffd3f5e")
- (revision "1"))
+(define-public sbcl-alloy
+ (let ((commit "628974de537affb5b44ad548347f67c16efffcfc")
+ (revision "3"))
(package
- (name "sbcl-asdf-system-connections")
- (version (git-version "0.8.4" revision commit))
+ (name "sbcl-alloy")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/gwkkwg/asdf-system-connections";)
+ (url "https://github.com/Shirakumo/alloy";)
(commit commit)))
- (file-name (git-file-name "cl-asdf-system-connections" version))
+ (file-name (git-file-name "cl-alloy" version))
(sha256
- (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y"))))
+ (base32 "0fx294qwxshgijss000pbjbnbwxqvxyw6p3mva36qljhbbkw2fxy"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/gwkkwg/asdf-system-connections";)
- (synopsis "Common Lisp ASDF system auto-loading extension")
+ (native-inputs
+ (list sbcl-alexandria sbcl-parachute))
+ (inputs
+ (list sbcl-array-utils sbcl-closer-mop sbcl-documentation-utils
+ sbcl-float-features sbcl-colored sbcl-stealth-mixin
+ sbcl-cl-opengl sbcl-font-discovery sbcl-uax-14 sbcl-sdf))
+ (arguments
+ ;; Dismiss alloy-svg, since it is not completed:
+ ;; https://github.com/Shirakumo/alloy/issues/24
+ '(#:asd-systems '("alloy"
+ "alloy-animation"
+ "alloy-opengl"
+ "alloy-opengl-msdf"
+ "alloy-opengl-png"
+ "alloy-simple"
+ "alloy-simple-presentations"
+ "alloy-windowing")))
+ (home-page "https://shirakumo.github.io/alloy/";)
+ (synopsis
+ "Common Lisp user interface protocol and toolkit implementation")
(description
- "This package provides a Common Lisp ASDF system auto-loading
-extension.")
- (license license:expat))))
+ "Alloy is a user interface toolkit. It is defined through a set of
+protocols that allow for a clear interface, as well as a standardised way to
+integrate Alloy into a target backend.")
+ (license license:zlib))))
-(define-public ecl-asdf-system-connections
- (sbcl-package->ecl-package sbcl-asdf-system-connections))
+(define-public cl-alloy
+ (sbcl-package->cl-source-package sbcl-alloy))
-(define-public cl-asdf-system-connections
- (sbcl-package->cl-source-package sbcl-asdf-system-connections))
+(define-public ecl-alloy
+ (sbcl-package->ecl-package sbcl-alloy))
-(define-public sbcl-net.didierverna.asdf-flv
+(define-public sbcl-amb
+ (let ((commit "884bef69a1ea02f3b9deae0341e1a038ff31b896")
+ (revision "0"))
+ (package
+ (name "sbcl-amb")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phoe/amb";)
+ (commit commit)))
+ (file-name (git-file-name "cl-amb" version))
+ (sha256
+ (base32 "1klh1aakklj1famrff0sccnwlv8238b1q446288aqnqgxxw6pf21"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria))
+ (native-inputs
+ (list sbcl-parachute))
+ (synopsis "Implementation of John McCarthy's ambiguous operator")
+ (description
+ "@code{cl-amb} provides an implementation of John McCarthy's ambiguous
+operator in portable Common Lisp.")
+ (home-page "https://github.com/phoe/amb/";)
+ (license license:expat))))
+
+(define-public cl-amb
+ (sbcl-package->cl-source-package sbcl-amb))
+
+(define-public ecl-amb
+ (sbcl-package->ecl-package sbcl-amb))
+
+(define-public sbcl-anaphora
(package
- (name "sbcl-net.didierverna.asdf-flv")
- (version "2.1")
+ (name "sbcl-anaphora")
+ (version "0.9.8")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/didierverna/asdf-flv";)
- (commit (string-append "version-" version))))
- (file-name (git-file-name "asdf-flv" version))
+ (url "https://github.com/tokenrove/anaphora";)
+ (commit version)))
(sha256
- (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
+ (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b"))
+ (file-name (git-file-name "cl-anaphora" version))))
(build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp ASDF extension to provide support for file-local
variables")
- (description "ASDF-FLV provides support for file-local variables through
-ASDF. A file-local variable behaves like @code{*PACKAGE*} and
-@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
-dynamic binding is created before processing the file, so that any
-modification to the variable becomes essentially file-local.
+ (native-inputs
+ (list sbcl-rt))
+ (synopsis "The anaphoric macro collection from Hell")
+ (description
+ "Anaphora is the anaphoric macro collection from Hell: it includes many
+new fiends in addition to old friends like @command{aif} and
+@command{awhen}.")
+ (home-page "https://github.com/tokenrove/anaphora";)
+ (license license:public-domain)))
-In order to make one or several variables file-local, use the macros
-@code{SET-FILE-LOCAL-VARIABLE(S)}.")
- (home-page
"https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv";)
- (license (license:non-copyleft
-
"https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html";
- "GNU All-Permissive License"))))
-
-(define-public cl-net.didierverna.asdf-flv
- (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
+(define-public cl-anaphora
+ (sbcl-package->cl-source-package sbcl-anaphora))
-(define-public ecl-net.didierverna.asdf-flv
- (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
+(define-public ecl-anaphora
+ (sbcl-package->ecl-package sbcl-anaphora))
-(define-public sbcl-command-line-arguments
- (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe")
+;;; Split the antik package in two to work around the circular dependency
+;;; between antik/antik and antik/gsll.
+(define-public sbcl-antik-base
+ (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
(revision "1"))
(package
- (name "sbcl-command-line-arguments")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-antik-base")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fare/command-line-arguments";)
+ (url "https://gitlab.common-lisp.net/antik/antik.git";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq"))))
+ (base32
+ "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/fare/command-line-arguments";)
- (synopsis "Trivial command-line argument parsing library for Common
Lisp")
- (description "This is a library to abstract away the parsing of
-Unix-style command-line arguments. Use it in conjunction with asdf:program-op
-or cl-launch for portable processing of command-line arguments.")
- (license license:expat))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("drakma" ,sbcl-drakma)
+ ("fare-utils" ,sbcl-fare-utils)
+ ("iterate" ,sbcl-iterate)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)))
+ (native-inputs
+ (list sbcl-lisp-unit))
+ (arguments
+ '(#:asd-systems '("antik-base"
+ "foreign-array")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("antik.asd"
+ "physical-dimension.asd"
+ "science-data.asd"))
+ #t)))))
+ (synopsis "Scientific and engineering computation in Common Lisp")
+ (description
+ "Antik provides a foundation for scientific and engineering
+computation in Common Lisp. It is designed not only to facilitate
+numerical computations, but to permit the use of numerical computation
+libraries and the interchange of data and procedures, whether
+foreign (non-Lisp) or Lisp libraries. It is named after the
+Antikythera mechanism, one of the oldest examples of a scientific
+computer known.")
+ (home-page "https://common-lisp.net/project/antik/";)
+ (license license:gpl3))))
-(define-public ecl-command-line-arguments
- (sbcl-package->ecl-package sbcl-command-line-arguments))
+(define-public cl-antik-base
+ (sbcl-package->cl-source-package sbcl-antik-base))
-(define-public cl-command-line-arguments
- (sbcl-package->cl-source-package sbcl-command-line-arguments))
+(define-public ecl-antik-base
+ (let ((pkg (sbcl-package->ecl-package sbcl-antik-base)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (add-after 'unpack 'fix-readtable
+ (lambda _
+ (substitute* "input-output/readtable.lisp"
+ (("#-ccl")
+ "#-(or ccl ecl)"))
+ #t)))))))))
-(define-public sbcl-adopt
+(define-public sbcl-antik
(package
- (name "sbcl-adopt")
- (version "1.2.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sjl/adopt";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-adopt" version))
- (sha256
- (base32 "16kzkai96qk7vmclp8wxc9aghhnisw8gg9s7hra68300bgj86wzr"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-1am))
- (inputs (list sbcl-bobbin sbcl-split-sequence))
- (home-page "https://hg.stevelosh.com/adopt";)
- (synopsis "Common Lisp option parsing library")
- (description
- "@acronym{ADOPT, A Damn OPTion} is a simple UNIX-style option parser in
-Common Lisp, heavily influenced by Python's @code{optparse} and
-@code{argparse}.")
- (license license:expat)))
-
-(define-public ecl-adopt
- (sbcl-package->ecl-package sbcl-adopt))
+ (inherit sbcl-antik-base)
+ (name "sbcl-antik")
+ (inputs
+ `(("antik-base" ,sbcl-antik-base)
+ ("gsll" ,sbcl-gsll)))
+ (arguments
+ '(#:asd-systems '("antik"
+ "science-data")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("antik-base.asd"
+ "foreign-array.asd"))
+ #t)))))))
-(define-public cl-adopt
- (sbcl-package->cl-source-package sbcl-adopt))
+(define-public cl-antik
+ (sbcl-package->cl-source-package sbcl-antik))
-(define-public sbcl-clingon
- (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d")
- (revision "0"))
+(define-public sbcl-april
+ (let ((commit "bdd74f168ec82f28fe4ab692f2c0af39441a5701")
+ (revision "3"))
(package
- (name "sbcl-clingon")
- (version (git-version "0.5.0" revision commit))
+ (name "sbcl-april")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dnaeon/clingon";)
+ (url "https://github.com/phantomics/april";)
(commit commit)))
- (file-name (git-file-name "cl-clingon" version))
+ (file-name (git-file-name "cl-april" version))
(sha256
- (base32 "11p9lplx0fc5ghx601i150vrd46zdbvw0hfrbrrrdqplxaqpywq5"))))
+ (base32 "0hvlp2286z1ksa7jr7r661kdr0lpfv25n5chl72jrzq5zz70lidx"))
+ (modules '((guix build utils)))
+ (snippet '(begin
+ ;; Remove bundled Apache-relicensed MaxPC.
+ (delete-file-recursively "maxpc-apache")
+ ;; Ensure references are to upstream MaxPC.
+ (substitute* "vex/vex.asd"
+ (("maxpc-apache") "maxpc"))))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-rove))
(inputs
- (list sbcl-bobbin
- sbcl-cl-reexport
- sbcl-split-sequence
- sbcl-with-user-abort))
- (home-page "https://github.com/dnaeon/clingon";)
- (synopsis "Command-line option parsing library for Common Lisp")
+ (list sbcl-alexandria
+ sbcl-array-operations
+ sbcl-cl-ppcre
+ sbcl-cl-unicode
+ sbcl-lparallel
+ sbcl-maxpc
+ sbcl-parse-number
+ sbcl-prove
+ sbcl-random-state
+ sbcl-serapeum
+ sbcl-simple-date-time
+ sbcl-symbol-munger
+ sbcl-trivia))
+ (home-page "https://github.com/phantomics/april";)
+ (synopsis "Array Programming Re-Imagined in Lisp")
(description
- "@code{clingon} is a command-line option parsing library for Common
-Lisp. Its features include:
-@itemize
-@item Support for subcommands
-@item Support for command aliases
-@item Support for short and long options
-@item Related options may be grouped into categories
-@item Short options may be collapsed into a single argument, as in
-@option{-xyz}
-@item Long options support the notations @option{--long-opt arg} and
-@option{--long-opt=arg}
-@item Automatic generation of help/usage information for commands and
-subcommands
-@item Out-of-the-box support for @option{--version} and @option{--help}
-@item Support for various kinds of options including string, integer,
-boolean, switch, enum, list, counter, filepath, etc.
-@item Subcommands can look up global options defined in parent commands
-@item Support for required options
-@item Options can be initialized via environment variables
-@item Single interface for creating options using @code{CLINGON:MAKE-OPTION}
-@item Generate documentation for your command-line application
-@item Support for @code{pre-hook} and @code{post-hook} actions for commands,
-which allow invoking functions before and after the respective handler of the
-command is executed
-@item Support for Bash and Zsh completions
-@item Extensibility, so if you don't find something you need you can extend it
-by developing a new option kind, or even a new mechanism for initializing
-options, e.g., by looking up an external key/value store
-@end itemize")
- (license license:bsd-2))))
+ "April compiles a subset of the APL programming language into
+Common Lisp. Leveraging Lisp's powerful macros and numeric processing
+faculties, it brings APL's expressive potential to bear for Lisp developers.
+Replace hundreds of lines of number-crunching code with a single line of
+APL.")
+ (license license:asl2.0))))
-(define-public cl-clingon
- (sbcl-package->cl-source-package sbcl-clingon))
+(define-public cl-april
+ (sbcl-package->cl-source-package sbcl-april))
-(define-public ecl-clingon
- (sbcl-package->ecl-package sbcl-clingon))
+(define-public ecl-april
+ (sbcl-package->ecl-package sbcl-april))
-(define-public sbcl-command-line-args
- (package
- (name "sbcl-command-line-args")
- (version "0.1.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://git.sr.ht/~whereiseveryone/command-line-args";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-command-line-args" version))
- (sha256
- (base32 "140xnz2v0v3hfg3dp2fhidw8ns6lxd3a5knm07wqdp48ksg119wy"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("whereiseveryone.command-line-args")))
- (inputs
- (list sbcl-alexandria
- sbcl-charje.documentation
- sbcl-cl-str
- sbcl-serapeum
- sbcl-trivia))
- (home-page "https://git.sr.ht/~whereiseveryone/command-line-args";)
- (synopsis "Automatically generate command line interfaces")
- (description "Command-Line-Args provides a main macro (@code{command})
-that wraps a @code{defun} form and creates a new function that parses the
-command line arguments. It has support for command-line options, positional,
-and variadic arguments. It also generates a basic help message. The
-interface is meant to be easy and non-intrusive.")
- (license license:agpl3+)))
+(define-public sbcl-archive
+ (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
+ (revision "1"))
+ (package
+ (name "sbcl-archive")
+ (version (git-version "0.9" revision commit))
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/archive";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cl-fad sbcl-trivial-gray-streams))
+ (synopsis "Common Lisp library for tar and cpio archives")
+ (description
+ "This is a Common Lisp library to read and write disk-based file
+archives such as those generated by the tar and cpio programs on Unix.")
+ (home-page "https://github.com/sharplispers/archive";)
+ (license license:bsd-3))))
-(define-public cl-command-line-args
- (sbcl-package->cl-source-package sbcl-command-line-args))
+(define-public cl-archive
+ (sbcl-package->cl-source-package sbcl-archive))
-(define-public ecl-command-line-args
- (sbcl-package->ecl-package sbcl-command-line-args))
+(define-public ecl-archive
+ (sbcl-package->ecl-package sbcl-archive))
-(define-public sbcl-cl-irc
- (let ((commit "963823537c7bfcda2edd4c44d172192da6722175")
- (revision "0"))
+(define-public sbcl-arnesi
+ (let ((commit "1e7dc4cb2cad8599113c7492c78f4925e839522e")
+ (revision "1"))
(package
- (name "sbcl-cl-irc")
- (version (git-version "0.9.2" revision commit))
+ (name "sbcl-arnesi")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://salsa.debian.org/common-lisp-team/cl-irc.git";)
+ (url "https://github.com/AccelerationNet/arnesi";)
(commit commit)))
- (file-name (git-file-name "cl-irc" version))
+ (file-name (git-file-name "arnesi" version))
(sha256
- (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w"))))
+ (base32 "0jgj2xgd1gq6rf8ia43lkmbrbxnp8rgs053br9azfa25ygk3ikbh"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; FIXME: (Sharlatan-20210523T190315+0100): Tests failed on
+ ;; special-lisp-var-rebount-in/cc
+ ;;
+ ;; ; processing (TEST SPECIAL-LISP-VAR-REBOUND-IN/CC ...)
+ ;; ; wrote .../sbcl/arnesi/t/call-cc-tmp5GEXGEG5.fasl
+ ;; ; compilation finished in 0:00:00.028
+ ;; Unhandled SIMPLE-ERROR in thread
+ ;; #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>:
+ ;; Sorry, No walker for the special operater DECLARE defined.
+ ;;
+ ;; Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>
+ ;; 0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SIMPLE-ERROR "Sorry,
+ ;; No walker for the special operater ~S defined."
+ ;; {1001FAF9D3}> #<unused argument> :QUIT T)
+ ;;
+ `(#:tests? #f))
(native-inputs
- (list sbcl-rt))
+ (list sbcl-fiveam))
(inputs
- `(("cl+ssl" ,sbcl-cl+ssl)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("split-sequence" ,sbcl-split-sequence)
- ("usocket" ,sbcl-usocket)))
- (arguments
- `(#:asd-test-systems '("cl-irc-test")))
- (synopsis "IRC client library for Common Lisp")
- (description "@code{cl-irc} is a Common Lisp IRC client library that
-features (partial) DCC, CTCP and all relevant commands from the IRC
-RFCs (RFC2810, RFC2811 and RFC2812).
-
-Features:
-@itemize
-@item implements all commands in the RFCs
-@item extra convenience commands such as op/deop, ban, ignore, etc.
-@item partial DCC SEND/CHAT support
-@item event driven model with hooks makes interfacing easy
-@item the user can keep multiple connections
-@item all CTCP commands
-@end itemize\n")
- (home-page "https://common-lisp.net/project/cl-irc/";)
- (license license:bsd-2))))
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("collectors" ,sbcl-collectors)
+ ("swank" ,sbcl-slime-swank)))
+ (home-page "https://github.com/AccelerationNet/arnesi";)
+ (synopsis "Common Lisp utility suite")
+ (description
+ "ARNESI is Common Lisp utilities library similar to ALEXANDRIA, ANAPHORA
+or GOLDEN-UTILS.")
+ (license license:bsd-3))))
-(define-public cl-irc
- (sbcl-package->cl-source-package sbcl-cl-irc))
+(define-public ecl-arnesi
+ (sbcl-package->ecl-package sbcl-arnesi))
-(define-public ecl-cl-irc
- (sbcl-package->ecl-package sbcl-cl-irc))
+(define-public cl-arnesi
+ (sbcl-package->cl-source-package sbcl-arnesi))
-(define-public sbcl-coleslaw
- (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40")
+(define-public sbcl-array-operations
+ (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b")
(revision "0"))
(package
- (name "sbcl-coleslaw")
- (version (git-version "0.9.7" revision commit))
+ (name "sbcl-array-operations")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/coleslaw-org/coleslaw";)
+ (url "https://github.com/bendudson/array-operations";)
(commit commit)))
- (file-name (git-file-name "cl-coleslaw" version))
+ (file-name (git-file-name "array-operations" version))
(sha256
- (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws"))))
+ (base32 "0ip49hhq32w80qsc7jmspyda5r2rsszvw0mk2r3341cld78sz9ya"))))
(build-system asdf-build-system/sbcl)
- (outputs '("out" "bin"))
- (arguments
- '(#:asd-systems '("coleslaw" "coleslaw-cli")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda _
- (substitute* "plugins/publish-gh-pages.sh"
- (("^rsync\\b") (which "rsync")))
- (substitute* '("plugins/rsync.lisp"
- "src/coleslaw.lisp")
- (("\\brun-program \"rsync\\b")
- (string-append "run-program \"" (which "rsync"))))))
- (add-after 'create-asdf-configuration 'build-program
- (lambda* (#:key outputs #:allow-other-keys)
- (build-program
- (string-append (assoc-ref outputs "bin") "/bin/coleslaw")
- outputs
- #:dependencies '("coleslaw-cli")
- #:entry-program '((apply (function coleslaw-cli::main)
- arguments))
- #:compress? #t))))))
(native-inputs
- (list sbcl-prove))
+ (list sbcl-alexandria sbcl-clunit2))
(inputs
- (list rsync
- sbcl-3bmd
- sbcl-alexandria
- sbcl-cl-fad
- sbcl-cl-ppcre
- sbcl-cl-unicode
- sbcl-clack
- sbcl-closer-mop
- sbcl-closure-template
- sbcl-inferior-shell
- sbcl-local-time
- sbcl-trivia))
- (home-page "https://github.com/coleslaw-org/coleslaw";)
- (synopsis "Static site generator")
+ (list sbcl-let-plus))
+ (synopsis "Simple array operations library for Common Lisp")
(description
- "Coleslaw is a static site generator written in Common Lisp.")
- (license license:bsd-2))))
+ "This library is a collection of functions and macros for manipulating
+Common Lisp arrays and performing numerical calculations with them.")
+ (home-page "https://github.com/bendudson/array-operations";)
+ (license license:expat))))
-(define-public cl-coleslaw
- (sbcl-package->cl-source-package sbcl-coleslaw))
+(define-public cl-array-operations
+ (sbcl-package->cl-source-package sbcl-array-operations))
-(define-public ecl-coleslaw
- (sbcl-package->ecl-package sbcl-coleslaw))
+(define-public ecl-array-operations
+ (sbcl-package->ecl-package sbcl-array-operations))
-(define-public sbcl-cl-all
- (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace")
+(define-public sbcl-array-utils
+ (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834")
(revision "0"))
(package
- (name "sbcl-cl-all")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-array-utils")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/cl-all";)
- (commit commit)))
- (file-name (git-file-name "cl-all" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/array-utils";)
+ (commit commit)))
+ (file-name (git-file-name "cl-array-utils" version))
(sha256
- (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp"))))
+ (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az"))))
(build-system asdf-build-system/sbcl)
- (outputs '("out" "bin"))
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'create-asdf-configuration 'build-program
- (lambda* (#:key outputs #:allow-other-keys)
- (build-program
- (string-append (assoc-ref outputs "bin") "/bin/cl-all")
- outputs
- #:entry-program '((cl-all:toplevel arguments))
- #:compress? #t))))))
- (home-page "https://github.com/Shinmera/cl-all";)
- (synopsis "Evaluate Common Lisp expressions in multiple implementations")
- (description "@samp{cl-all} is a library and script for evaluating Common
-Lisp expressions in multiple implementations.")
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-documentation-utils))
+ (synopsis "Tiny collection of array and vector utilities for Common
Lisp")
+ (description
+ "A miniature toolkit that contains some useful shifting/popping/pushing
+functions for arrays and vectors. Originally from Plump.")
+ (home-page "https://shinmera.github.io/array-utils/";)
(license license:zlib))))
-(define-public cl-all
- (sbcl-package->cl-source-package sbcl-cl-all))
+(define-public cl-array-utils
+ (sbcl-package->cl-source-package sbcl-array-utils))
-(define-public sbcl-tripod
- (let ((commit "b019a27cd7eb895870f84b0eb6c3edc5d7b05928")
- (revision "1"))
+(define-public ecl-array-utils
+ (sbcl-package->ecl-package sbcl-array-utils))
+
+(define-public sbcl-arrow-macros
+ ;; The latest upstream version tag is dated (pushed in 2020), use the latest
+ ;; commit instead.
+ (let ((commit "16bdfd31298182099c7d70df4598104e5a38b05e")
+ (revision "0"))
(package
- (name "sbcl-tripod")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-arrow-macros")
+ (version (git-version "0.2.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/aartaka/tripod";)
+ (url "https://github.com/hipeta/arrow-macros";)
(commit commit)))
- (file-name (git-file-name "cl-tripod" version))
+ (file-name (git-file-name "arrow-macros" version))
(sha256
- (base32 "0y8sns6njq9x7km58vpj7gx4cia9zkcpng3d38300xk0nnk2kz8w"))))
+ (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4"))))
(build-system asdf-build-system/sbcl)
- (outputs '("out" "bin"))
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'create-asdf-configuration 'build-program
- (lambda* (#:key outputs #:allow-other-keys)
- ;; FIXME: Using #$output:bin here prevents cl-tripod and
- ;; ecl-tripod from building, but using assoc-ref works.
- (build-program (string-append ;; #$output:bin
- (assoc-ref outputs "bin")
- "/bin/tripod")
- outputs
- #:entry-program '((tripod:entry-point))
- #:compress? #t))))))
- (inputs
- (list sbcl-alexandria
- sbcl-cl-gopher
- sbcl-cl-markdown
- sbcl-clss
- sbcl-hunchentoot
- sbcl-local-time
- sbcl-nactivitypub
- sbcl-njson
- sbcl-phos
- sbcl-plump
- sbcl-trivial-mimes))
- (home-page "https://aartaka.me/blog/tripod";)
- (synopsis "Common Lisp web server aiming to ease website hosting")
+ (native-inputs (list sbcl-fiveam))
+ (home-page "https://github.com/hipeta/arrow-macros/";)
+ (synopsis "Clojure-like arrow macros in Common Lisp")
(description
- "Tripod is a Common Lisp web server aiming to ease plain text, HTML,
-and Gopher website hosting.")
- (license license:bsd-2))))
+ "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and
diamond wands
+in swiss-arrows.")
+ (license license:expat))))
-(define-public cl-tripod
- ;; No "bin" output for the source package.
- (let ((pkg (sbcl-package->cl-source-package sbcl-tripod)))
- (package/inherit pkg
- (outputs '("out")))))
+(define-public cl-arrow-macros
+ (sbcl-package->cl-source-package sbcl-arrow-macros))
-(define-public ecl-tripod
- ;; FIXME: Making a standalone binary doesn't work with ECL.
- (let ((pkg (sbcl-package->ecl-package sbcl-tripod)))
- (package/inherit pkg
- (outputs '("out"))
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:phases phases)
- #~(modify-phases #$phases
- (delete 'build-program))))))))
+(define-public ecl-arrow-macros
+ (sbcl-package->ecl-package sbcl-arrow-macros))
-(define-public sbcl-trivial-timeout
- (let ((commit "e70d9b4f7caeab83ea6ac50d724470fe49561e66")
- (revision "2"))
+(define-public sbcl-arrows
+ (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
+ (revision "0"))
(package
- (name "sbcl-trivial-timeout")
- (version (git-version "0.1.5" revision commit))
+ (name "sbcl-arrows")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/trivial-timeout";)
+ (url "https://gitlab.com/Harleqin/arrows.git";)
(commit commit)))
- (file-name (git-file-name "trivial-timeout" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0s8z9aj6b3kv21yiyk13cjylzf5zlnw9v86vcff477m1gk9yddjs"))))
+ (base32
+ "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-lift))
- (home-page "https://github.com/hraban/trivial-timeout";)
- (synopsis "Timeout library for Common Lisp")
+ (list sbcl-hu.dwim.stefil))
+ (synopsis "Clojure-like arrow macros for Common Lisp")
(description
- "This library provides an OS and implementation independent access to
-timeouts.")
- (license license:expat))))
-
-(define-public ecl-trivial-timeout
- (sbcl-package->ecl-package sbcl-trivial-timeout))
-
-(define-public cl-trivial-timeout
- (sbcl-package->cl-source-package sbcl-trivial-timeout))
-
-(define-public sbcl-bordeaux-threads
- (package
- (name "sbcl-bordeaux-threads")
- (version "0.9.3")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sionescu/bordeaux-threads";)
- (commit (string-append "v" version))))
- (sha256
- (base32 "0pp3w5hsph47sqagr4j2pbg3ddb29jx93zg8kvxsp2c4flp0qz0f"))
- (file-name (git-file-name "cl-bordeaux-threads" version))))
- (inputs (list sbcl-alexandria
- sbcl-global-vars
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (native-inputs (list sbcl-fiveam))
- (build-system asdf-build-system/sbcl)
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'adjust-test-sleep
- (lambda _
- ;; 0.001 is too short for some slower machines.
- (substitute* '("test/tests-v1.lisp"
- "test/tests-v2.lisp")
- (("sleep 0\\.001") "sleep 0.002")))))))
- (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)))
+ "This library implements the @code{->} and @code{->>} macros from
+Clojure, as well as several expansions on the idea.")
+ (home-page "https://gitlab.com/Harleqin/arrows";)
+ (license license:public-domain))))
-(define-public cl-bordeaux-threads
- (sbcl-package->cl-source-package sbcl-bordeaux-threads))
+(define-public cl-arrows
+ (sbcl-package->cl-source-package sbcl-arrows))
-(define-public ecl-bordeaux-threads
- (sbcl-package->ecl-package sbcl-bordeaux-threads))
+(define-public ecl-arrows
+ (sbcl-package->ecl-package sbcl-arrows))
-(define-public sbcl-trivial-gray-streams
- (let ((revision "1")
- (commit "2b3823edbc78a450db4891fd2b566ca0316a7876"))
+(define-public sbcl-asdf-finalizers
+ (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
+ (revision "1"))
(package
- (name "sbcl-trivial-gray-streams")
- (version (git-version "2.0" revision commit))
+ (name "sbcl-asdf-finalizers")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/trivial-gray-streams/trivial-gray-streams";)
- (commit commit)))
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1hipqwwd5ylskybd173rvlsk7ds4w4nq1cmh9952ivm6dgh7pwzn"))
- (file-name (git-file-name "cl-trivial-gray-streams" version))))
+ (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Compatibility layer for Gray streams implementations")
- (description "Gray streams is an interface proposed for inclusion with
-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 "https://www.cliki.net/trivial-gray-streams";)
- (license license:x11))))
+ (native-inputs
+ `(("fare-utils" ,sbcl-fare-utils)
+ ("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)))
+ (home-page "https://gitlab.common-lisp.net/asdf/asdf-finalizers";)
+ (synopsis "Enforced calling of finalizers for Lisp code")
+ (description "This library allows you to implement and enforce proper
+finalization of compile-time constructs while building Lisp source files.
-(define-public cl-trivial-gray-streams
- (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
+It produces two systems: asdf-finalizers and list-of.")
+ (license license:expat))))
-(define-public ecl-trivial-gray-streams
- (sbcl-package->ecl-package sbcl-trivial-gray-streams))
+(define-public cl-asdf-finalizers
+ (sbcl-package->cl-source-package sbcl-asdf-finalizers))
-(define-public sbcl-flexi-streams
- (let ((commit "74a1027311371a57258eba1bc908e050f5702277")
+(define-public ecl-asdf-finalizers
+ (sbcl-package->ecl-package sbcl-asdf-finalizers))
+
+(define-public sbcl-asd-generator
+ (let ((commit "27f94971a7c68c4dcb51e3f6be4142743d0c44e8")
(revision "0"))
(package
- (name "sbcl-flexi-streams")
- (version (git-version "1.0.19" revision commit))
+ (name "sbcl-asd-generator")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phoe/asd-generator";)
+ (commit commit)))
+ (sha256
+ (base32 "0yiybl7b9x1f85v0drj0yw9821y3yfhya4n6gycnv5vvx6jp9by4"))
+ (file-name (git-file-name "cl-asd-generator" commit))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cl-fad
+ sbcl-iterate
+ sbcl-alexandria
+ sbcl-trivia))
+ (home-page "https://github.com/phoe/asd-generator";)
+ (synopsis "Automatic generator for .asd files")
+ (description
+ "This package provides an automatic generator for ASDF's .asd files.")
+ (license license:gpl3+))))
+
+(define-public cl-asd-generator
+ (sbcl-package->cl-source-package sbcl-asd-generator))
+
+(define-public ecl-asd-generator
+ (sbcl-package->ecl-package sbcl-asd-generator))
+
+(define-public sbcl-asdf-system-connections
+ (let ((commit "9f085240febccccff99d9d3bb687fcaafffd3f5e")
+ (revision "1"))
+ (package
+ (name "sbcl-asdf-system-connections")
+ (version (git-version "0.8.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/flexi-streams";)
+ (url "https://github.com/gwkkwg/asdf-system-connections";)
(commit commit)))
- (file-name (git-file-name "cl-flexi-streams" version))
+ (file-name (git-file-name "cl-asdf-system-connections" version))
(sha256
- (base32 "04azqvz11s8dngy49bjl19hrfn0ip1b7m0szm4hlppq364msil7b"))))
+ (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'make-git-checkout-writable
- (lambda _
- (for-each make-file-writable (find-files ".")))))))
- (inputs
- (list sbcl-trivial-gray-streams))
- (synopsis "Implementation of virtual bivalent streams for Common Lisp")
- (description "Flexi-streams is an implementation of \"virtual\" bivalent
-streams that can be layered atop real binary or bivalent streams and that can
-be used to read and write character data in various single- or multi-octet
-encodings which can be changed on the fly. It also supplies in-memory binary
-streams which are similar to string streams.")
- (home-page "http://weitz.de/flexi-streams/";)
- (license license:bsd-3))))
+ (home-page "https://github.com/gwkkwg/asdf-system-connections";)
+ (synopsis "Common Lisp ASDF system auto-loading extension")
+ (description
+ "This package provides a Common Lisp ASDF system auto-loading
+extension.")
+ (license license:expat))))
-(define-public cl-flexi-streams
- (sbcl-package->cl-source-package sbcl-flexi-streams))
+(define-public cl-asdf-system-connections
+ (sbcl-package->cl-source-package sbcl-asdf-system-connections))
-(define-public ecl-flexi-streams
- (sbcl-package->ecl-package sbcl-flexi-streams))
+(define-public ecl-asdf-system-connections
+ (sbcl-package->ecl-package sbcl-asdf-system-connections))
-(define-public sbcl-cl-abnf
- ;; There are no releases
- (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70")
- (revision "1"))
+(define-public sbcl-aserve
+ ;; There does not seem to be proper releases.
+ (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5")
+ (revision "2"))
(package
- (name "sbcl-cl-abnf")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/dimitri/cl-abnf";)
- (commit commit)))
- (file-name (git-file-name "cl-abnf" version))
- (sha256
- (base32 "0f09nsndxa90acm71zd4qdnp40v705a4sqm04mnv9x76h6dlggmz"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("esrap" ,sbcl-esrap)))
- (arguments
- `(#:asd-systems '("abnf")))
- (home-page "https://github.com/dimitri/cl-abnf";)
- (synopsis "ABNF parser generator for Common Lisp")
- (description "This Common Lisp library implements a parser generator for
-the ABNF grammar format as described in RFC2234. The generated parser is a
-regular expression scanner provided by the cl-ppcre lib, which means that we
-can't parse recursive grammar definition. One such definition is the ABNF
-definition as given by the RFC. Fortunately, as you have this lib, you most
-probably don't need to generate another parser to handle that particular ABNF
-grammar.")
- (license license:expat))))
-
-(define-public cl-abnf
- (sbcl-package->cl-source-package sbcl-cl-abnf))
+ (name "sbcl-aserve")
+ (version (git-version "1.2.50" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ ;; https://github.com/franzinc/aserve/ seems to be incompatible
+ ;; with SBCL, etc.
+ (url "git://git.code.sf.net/p/portableaserve/git")
+ (commit commit)))
+ (file-name (git-file-name "aserve" version))
+ (sha256
+ (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))
+ (patches (search-patches
+ ;; Add HTML5 elements to htmlgen.
+ ;; Adapted from https://github.com/franzinc/aserve/ commits:
+ ;; * e47bd763: "rfe12668: add HTML 5 elements to htmlgen"
+ ;; * 7371ce59: "fix bugs in rfe12668 implementation"
+ "sbcl-aserve-add-HTML-5-elements.patch"
+ "sbcl-aserve-fix-rfe12668.patch"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'cd-aserve
+ (lambda _
+ (chdir "aserve")
+ #t))
+ (add-after 'cd-aserve 'fix-asd
+ (lambda _
+ (substitute* "aserve.asd"
+ ((" :force t") ""))
+ #t))
+ (add-after 'cd-aserve 'fix-tests
+ (lambda _
+ (substitute* "test/t-aserve.cl"
+ (("\\(asdf:oos 'asdf:load-op :ptester\\)") ""))
+ #t)))))
+ (inputs
+ `(("acl-compat" ,sbcl-acl-compat)))
+ (home-page
+
"https://franz.com/support/documentation/current/doc/aserve/aserve.html";)
+ (synopsis "AllegroServe, a web server written in Common Lisp")
+ (description
+ "The server part of AllegroServe can be used either as a standalone web
+server or a module loaded into an application to provide a user interface to
+the application. AllegroServe's proxy ability allows it to run on the gateway
+machine between some internal network and the Internet. AllegroServe's client
+functions allow Lisp programs to explore the web.")
+ (license license:llgpl))))
-(define-public ecl-cl-abnf
- (sbcl-package->ecl-package sbcl-cl-abnf))
+(define-public cl-aserve
+ (sbcl-package->cl-source-package sbcl-aserve))
-(define-public sbcl-select
- (let ((commit "df7920fc451b6d15345040ce4a3ee1ea2818ab1a")
- (revision "0"))
+(define-public sbcl-assoc-utils
+ (let ((commit "74af16a3c0f10ad35e406167de02984744fc7854")
+ (revision "1"))
(package
- (name "sbcl-select")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-assoc-utils")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/select";)
+ (url "https://github.com/fukamachi/assoc-utils";)
(commit commit)))
- (file-name (git-file-name "cl-select" version))
+ (file-name (git-file-name "cl-assoc-utils" version))
(sha256
- (base32 "0bhpvfqp7n33pia4y62qi31bx86gjl2nxjy529rfawac57c9rxv3"))))
+ (base32 "1yac1v7zmdxj0p6rvwrrhyqvy7yjfhmqbchkwqhhr89gpjvvaick"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-let-plus))
+ (arguments
+ '(#:asd-systems '("assoc-utils-test" "assoc-utils")))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://lisp-stat.github.io/select/";)
- (synopsis "Library for taking slices from array-like objects")
+ (list sbcl-prove))
+ (home-page "https://github.com/fukamachi/assoc-utils";)
+ (synopsis "Utilities for manipulating association lists in Common Lisp")
(description
- "This is a library for selecting portions of sequences, arrays or
-data-frames.")
- (license license:ms-pl))))
-
-(define-public cl-select
- (sbcl-package->cl-source-package sbcl-select))
-
-(define-public ecl-select
- (sbcl-package->ecl-package sbcl-select))
-
-(define-public sbcl-cl-ppcre
- (package
- (name "sbcl-cl-ppcre")
- (version "2.1.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-ppcre";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-ppcre" version))
- (sha256
- (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-flexi-streams))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'disable-ppcre-unicode
- ;; cl-ppcre and cl-ppcre-unicode are put in different packages
- ;; to work around the circular dependency between edicl/cl-ppcre
- ;; and edicl/cl-unicode.
- (lambda _
- (delete-file "cl-ppcre-unicode.asd")
- #t)))))
- (synopsis "Portable regular expression library for Common Lisp")
- (description "CL-PPCRE is a portable regular expression library for Common
-Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
-compatible with ANSI-compliant Common Lisp implementations.")
- (home-page "http://weitz.de/cl-ppcre/";)
- (license license:bsd-2)))
+ "@code{assoc-utils} provides utilities for manipulating association
+lists in Common Lisp.")
+ (license license:public-domain))))
-(define-public cl-ppcre
- (sbcl-package->cl-source-package sbcl-cl-ppcre))
+(define-public cl-assoc-utils
+ (sbcl-package->cl-source-package sbcl-assoc-utils))
-(define-public ecl-cl-ppcre
- (sbcl-package->ecl-package sbcl-cl-ppcre))
+(define-public ecl-assoc-utils
+ (sbcl-package->ecl-package sbcl-assoc-utils))
-(define-public sbcl-one-more-re-nightmare
- (let ((commit "5b0b02e59f90964baf5737abd13300fa82f27667")
- (revision "1"))
+(define-public sbcl-atomichron
+ (let ((commit "5b3578bbad8c37ab559e56924d98c373efe11de5")
+ (revision "0"))
(package
- (name "sbcl-one-more-re-nightmare")
+ (name "sbcl-atomichron")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/telekons/one-more-re-nightmare";)
+ (url "https://github.com/no-defun-allowed/atomichron";)
(commit commit)))
- (file-name (git-file-name "cl-one-more-re-nightmare" version))
+ (file-name (git-file-name "cl-atomichron" version))
(sha256
- (base32 "0mwgjgnp8dsf2zn0290px5q89z93zs0v4dhvs3rcir4mpiw8rbsn"))))
+ (base32 "1fmmhb3pbv7j4d1cc02zv24bpd0kd2agfjjcj46w3gmv1bb0hva1"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-test-systems '("one-more-re-nightmare-tests")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "Tests/one-more-re-nightmare-tests.asd"
- ((":depends-on")
- (string-append
- ":perform (test-op (o c) (symbol-call
:one-more-re-nightmare-tests '#:run-tests))"
- "\n :depends-on"))))))))
- (native-inputs
- (list sbcl-lparallel sbcl-parachute))
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-dynamic-mixins
- sbcl-esrap
- sbcl-stealth-mixin
- sbcl-trivia
- sbcl-trivial-indent))
- (home-page "https://github.com/telekons/one-more-re-nightmare";)
- (synopsis "Regular expression compiler in Common Lisp")
- (description "@code{one-more-re-nightmare} is a regular expression engine
-that uses the technique presented in Regular-expression derivatives
-re-examined (Owens, Reppy and Turon, 2009;
-@url{doi:10.1017/S0956796808007090}) to interpret and compile regular
-expressions.")
+ (list sbcl-atomics sbcl-bordeaux-threads))
+ (home-page "https://github.com/no-defun-allowed/atomichron";)
+ (synopsis "Atomic metering library for Common Lisp")
+ (description
+ "@code{atomichron} is a Common Lisp library which implements a time
+meter which tracks how many times a form is evaluated, and how long evaluation
+takes. It uses atomic instructions so that meters will present correct
+results in the presence of multiple threads, while trying to minimize
+synchronization latency.")
(license license:bsd-2))))
-(define-public cl-one-more-re-nightmare
- (sbcl-package->cl-source-package sbcl-one-more-re-nightmare))
+(define-public cl-atomichron
+ (sbcl-package->cl-source-package sbcl-atomichron))
-(define-public ecl-one-more-re-nightmare
- (sbcl-package->ecl-package sbcl-one-more-re-nightmare))
+(define-public ecl-atomichron
+ (sbcl-package->ecl-package sbcl-atomichron))
-(define-public sbcl-parse
- (let ((commit "2351ee78acac065fcf10b8713d3f404e2e910786")
- (revision "1"))
+(define-public sbcl-atomics
+ ;; No release in years.
+ (let ((commit "b7477024894e322bff9c85e6d81e5e8d1d4eae59")
+ (revision "2"))
(package
- (name "sbcl-parse")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/massung/parse";)
- (commit commit)))
- (file-name (git-file-name "parse" version))
- (sha256
- (base32 "0l18yabyh7jizm5lgvra0jxi8s1cfwghidi6ix1pyixjkdbjlmvy"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/massung/parse";)
- (synopsis "Monadic parsing for Common Lisp")
- (description
- "PARSE is a simple token parsing library for Common Lisp.")
- (license license:asl2.0))))
-
-(define-public ecl-parse
- (sbcl-package->ecl-package sbcl-parse))
-
-(define-public cl-parse
- (sbcl-package->cl-source-package sbcl-parse))
-
-(define-public sbcl-re
- (let ((commit "cfbc1f482970221e80d445080a188fd5c755cd2c")
- (revision "1"))
- (package
- (name "sbcl-re")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/massung/re";)
- (commit commit)))
- (file-name (git-file-name "re" version))
- (sha256
- (base32 "1y2gq2sckspnq8118bix55p2j43dk9qn3p8a2rplp1ip2qxqbb1i"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-parse))
- (home-page "https://github.com/massung/re";)
- (synopsis "Lua-style Pattern Matching for Common Lisp")
- (description
- "RE is a small, portable, lightweight, and quick, regular
-expression library for Common Lisp. It is a non-recursive, backtracing VM.")
- (license license:asl2.0))))
-
-(define-public ecl-re
- (sbcl-package->ecl-package sbcl-re))
-
-(define-public cl-re
- (sbcl-package->cl-source-package sbcl-re))
-
-(define-public sbcl-boost-json
- (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47")
- (revision "0"))
- (package
- (name "sbcl-boost-json")
- (version (git-version "1.1" revision commit))
+ (name "sbcl-atomics")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-boost/json";)
+ (url "https://github.com/Shinmera/atomics";)
(commit commit)))
- (file-name (git-file-name "cl-boost-json" version))
+ (file-name (git-file-name "cl-atomics" version))
(sha256
- (base32 "12k0470899qsll2qixksxf2vrhjmskk3nzp1di9k04n1b29nrakd"))))
+ (base32 "1ah6fgvfva0axnhj4sp1qy6gjyw41fkhpnv998di0wbp6hls8j39"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- ;; See <https://github.com/cl-boost/json/pull/2>.
- (add-after 'unpack 'fix-decode-symbol
- (lambda _
- (substitute* '("decode.lisp" "encode.lisp")
- (("formfeed") "page")))))))
- (home-page "https://github.com/cl-boost/json";)
- (synopsis "JSON encoding and decoding for Common Lisp")
+ (inputs
+ (list sbcl-documentation-utils))
+ (native-inputs
+ (list sbcl-parachute))
+ (home-page "https://shinmera.github.io/atomics/";)
+ (synopsis "Common Lisp portability layer for atomic operations")
(description
- "BOOST-JSON is a simple JSON parsing library for Common Lisp.")
- (license license:asl2.0))))
+ "This is a library for access to atomic operation primitives such as
+compare-and-swap. It aims to be a rather thin layer over what the
+implementations offer.")
+ (license license:zlib))))
-(define-public cl-boost-json
- (sbcl-package->cl-source-package sbcl-boost-json))
+(define-public cl-atomics
+ (sbcl-package->cl-source-package sbcl-atomics))
-(define-public ecl-boost-json
- (sbcl-package->ecl-package sbcl-boost-json))
+(define-public ecl-atomics
+ (sbcl-package->ecl-package sbcl-atomics))
-(define-public sbcl-boost-parse
- (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50")
- (revision "0"))
+(define-public sbcl-authentic
+ (let ((commit "4e9194dda227b98f56dda1c2a2480efcc2d1f973")
+ (revision "2"))
(package
- (name "sbcl-boost-parse")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-authentic")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-boost/parse";)
+ (url "https://github.com/charje/cl-authentic";)
(commit commit)))
- (file-name (git-file-name "cl-boost-parse" version))
+ (file-name (git-file-name "cl-authentic" version))
(sha256
- (base32 "0djnp392n9wgpr9r2ycnwkglad5mn285yvr53jx3g7anm2p8r0vf"))))
+ (base32 "0ncsxrybnx0pjsndv3j8w4lphlpcsld8sxg3c5b46fb3a8nd4ssf"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/cl-boost/parse";)
- (synopsis "Monadic parsing for Common Lisp")
- (description
- "BOOST-PARSE is a simple token parsing library for Common Lisp.")
- (license license:asl2.0))))
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-clsql sbcl-ironclad))
+ (home-page "https://github.com/charje/cl-authentic";)
+ (synopsis "User/password management for Common Lisp applications")
+ (description "Authentic provides a light-weight and extendible
+solution to user/password management for Common Lisp applications. It has
+features such as safe password storage in a database, password reset, user
+confirmation tokens, and user authentication.")
+ (license license:llgpl))))
-(define-public cl-boost-parse
- (sbcl-package->cl-source-package sbcl-boost-parse))
+(define-public ecl-authentic
+ (sbcl-package->ecl-package sbcl-authentic))
-(define-public ecl-boost-parse
- (sbcl-package->ecl-package sbcl-boost-parse))
+(define-public cl-authentic
+ (sbcl-package->cl-source-package sbcl-authentic))
-(define-public sbcl-boost-re
- (let ((commit "d279fc58abf76d0c40aa6cde42e17a0591bc2c5d")
- (revision "0"))
+(define-public sbcl-babel
+ ;; No release since 2014.
+ (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9")
+ (revision "3"))
(package
- (name "sbcl-boost-re")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-babel")
+ (version (git-version "0.5.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-boost/re";)
+ (url "https://github.com/cl-babel/babel";)
(commit commit)))
- (file-name (git-file-name "cl-boost-re" version))
+ (file-name (git-file-name "cl-babel" version))
(sha256
- (base32 "1h9c2rdhw6m1pm67gqbj46y2vb1kc3i1c9y3l4qhgfz14dbk80a2"))))
+ (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-hu.dwim.stefil))
(inputs
- (list sbcl-boost-parse))
- (home-page "https://github.com/cl-boost/re";)
- (synopsis "Lua-style string pattern matching for Common Lisp")
- (description
- "BOOST-RE is a small, portable, lightweight, and quick, regular
-expression library for Common Lisp. It is a non-recursive, backtracking VM.")
- (license license:asl2.0))))
+ (list sbcl-alexandria sbcl-trivial-features))
+ (home-page "https://common-lisp.net/project/babel/";)
+ (synopsis "Charset encoding and decoding library")
+ (description "Babel is a charset encoding and decoding library, not
unlike
+GNU libiconv, but completely written in Common Lisp.")
+ (license (list license:bsd-2 license:expat)))))
-(define-public cl-boost-re
- (sbcl-package->cl-source-package sbcl-boost-re))
+(define-public cl-babel
+ (sbcl-package->cl-source-package sbcl-babel))
-(define-public ecl-boost-re
- (sbcl-package->ecl-package sbcl-boost-re))
+(define-public ecl-babel
+ (sbcl-package->ecl-package sbcl-babel))
-(define-public sbcl-boost-lexer
- (let ((commit "139ca9e9580f890698deec05061e495376b7735a")
- (revision "0"))
+(define-public sbcl-binary-types
+ (let ((commit "9ec42042a50403961c08179a892ae3de725b1d7a"))
(package
- (name "sbcl-boost-lexer")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-binary-types")
+ (version (git-version "1.2" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-boost/lexer";)
+ (url "https://github.com/frodef/binary-types/";)
(commit commit)))
- (file-name (git-file-name "cl-boost-lexer" version))
+ (file-name (git-file-name "binary-types" version))
(sha256
- (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4"))))
+ (base32 "0kp4xwblfxh7gmgqc38k9xzrqlcr0q1jm5167ma1pajdxd3182j8"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-boost-re))
- (home-page "https://github.com/cl-boost/lexer";)
- (synopsis "String tokenizing for Common Lisp")
+ (home-page "https://github.com/frodef/binary-types/";)
+ (synopsis "Read and write binary records for Common Lisp")
(description
- "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of
-BOOST-RE.")
- (license license:asl2.0))))
+ "Binary-types is a Common Lisp package for reading and writing binary
+files. Binary-types provides macros that are used to declare the mapping
+between Lisp objects and some binary (i.e. octet-based) representation.")
+ (license license:bsd-3))))
-(define-public cl-boost-lexer
- (sbcl-package->cl-source-package sbcl-boost-lexer))
+(define-public cl-binary-types
+ (sbcl-package->cl-source-package sbcl-binary-types))
-(define-public ecl-boost-lexer
- (sbcl-package->ecl-package sbcl-boost-lexer))
+(define-public ecl-binary-types
+ (sbcl-package->ecl-package sbcl-binary-types))
-(define-public sbcl-ubiquitous
- (let ((commit "35eb7bd9e1b3daee1705f6b41260775180cce8af")
+(define-public sbcl-binascii
+ (let ((commit "0fb0a9e5773148fd04d50efef08c1cc10f6fc487")
(revision "1"))
(package
- (name "sbcl-ubiquitous")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-binascii")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/ubiquitous";)
+ (url "https://github.com/sharplispers/binascii";)
(commit commit)))
- (file-name (git-file-name "ubiquitous" version))
+ (file-name (git-file-name "cl-binascii" version))
(sha256
- (base32 "1xlkaqmjcpkiv2xl2s2pvvrv976dlc846wm16s1lj62iy1315i49"))))
+ (base32 "000rcdl8qshr7n48zq9bzrc4lkjx4ylb3r3w9x9syhiwfla9j4b7"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Unbundle the RT test framework.
+ '(begin
+ (delete-file "tests/rt.lisp")
+ (substitute* "binascii.asd"
+ ((":depends-on \\(binascii\\)")
+ ":depends-on (binascii rt)")
+ (("\\(:file \"rt\"\\)")
+ "")
+ (("\\(:file \"tests\" :depends-on \\(\"rt\"\\)\\)")
+ "(:file \"tests\")"))))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- '(#:asd-systems '("ubiquitous"
- "ubiquitous-concurrent")))
- (home-page "https://shinmera.github.io/ubiquitous/";)
- (synopsis "Application configuration mechanism for Common Lisp")
+ (native-inputs
+ (list sbcl-rt))
+ (home-page "https://github.com/sharplispers/binascii";)
+ (synopsis "Common Lisp library of ASCII encoding schemes for binary
data")
(description
- "@code{UBIQUITOUS} is a very easy-to-use library for persistent
-configuration storage. It automatically takes care of finding a suitable place
-to save your data, and provides simple functions to access and modify the data
-within.")
- (license license:zlib))))
-
-(define-public ecl-ubiquitous
- (sbcl-package->ecl-package sbcl-ubiquitous))
+ "@code{binascii} is a Common Lisp library for converting binary data
+to ASCII text of some kind. Such conversions are common in email protocols
+(for encoding attachments to support old non-8-bit clean transports) or
+encoding binary data in HTTP and XML applications. @code{binascii} supports
+the encodings described in RFC 4648: base64, base32, base16, and variants.
+It also supports base85, used in Adobe's PostScript and PDF document formats,
+and a variant called ascii85, used by git for binary diff files.")
+ (license license:bsd-3))))
-(define-public cl-ubiquitous
- (sbcl-package->cl-source-package sbcl-ubiquitous))
+(define-public cl-binascii
+ (sbcl-package->cl-source-package sbcl-binascii))
-(define-public sbcl-uax-14
- (let ((commit "0432162525119c401d3d705bb9bcc9580a03914f")
- (revision "1"))
+(define-public sbcl-binding-arrows
+ ;; Fork of sbcl-arrows that does not have a new tag.
+ (let ((commit "46bcba8bb1ff27cd5caab3bda36f000d0489a4f2")
+ (revision "2"))
(package
- (name "sbcl-uax-14")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/uax-14";)
- (commit commit)))
- (file-name (git-file-name "uax-14" version))
- (sha256
- (base32 "1sb2s58k01yjaggaq8i7kbyfsh6mzyqbiz1vm59smxn9qqwd8apm"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute sbcl-cl-ppcre))
- (inputs
- (list sbcl-documentation-utils))
- (arguments
- `(#:asd-systems '("uax-14")))
- (home-page "https://shinmera.github.io/uax-14/";)
- (synopsis "Unicode Standard Annex #14 for standardised line breaking")
- (description
- "This is an implementation of the Unicode Standards Annex
-#14 (@url{http://www.unicode.org/reports/tr14/}) line breaking algorithm. It
-provides a fast and convenient way to determine line breaking opportunities in
-text.
-
-Note that this algorithm does not support break opportunities that require
-morphological analysis. In order to handle such cases, please consult a system
-that provides this kind of capability, such as a hyphenation algorithm.
-
-Also note that this system is completely unaware of layouting decisions. Any
-kind of layouting decisions, such as which breaks to pick, how to space
-between words, how to handle bidirectionality, and what to do in emergency
-situations when there are no breaks on an overfull line are left up to the
-user.")
- (license license:zlib))))
-
-(define-public ecl-uax-14
- (sbcl-package->ecl-package sbcl-uax-14))
-
-(define-public cl-uax-14
- (sbcl-package->cl-source-package sbcl-uax-14))
-
-(define-public sbcl-uax-15
- (package
- (name "sbcl-uax-15")
- (version "0.1.1")
- (source
- (origin
+ (name "sbcl-binding-arrows")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sabracrolleton/uax-15";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "uax-15" version))
+ (url "https://github.com/phoe/binding-arrows";)
+ (commit commit)))
+ (file-name (git-file-name "cl-binding-arrows" version))
(sha256
- (base32 "0p2ckw7mzxhwa9vbwj2q2dzayz9dl94d9yqd2ynp0pc5v8i0n2fr"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems
- '("uax-15")))
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("split-sequence" ,sbcl-split-sequence)))
- (home-page "https://github.com/sabracrolleton/uax-15";)
- (synopsis "Common Lisp implementation of unicode normalization functions")
- (description
- "This package provides supports for unicode normalization, RFC8264 and
-RFC7564.")
- (license license:expat)))
-
-(define-public cl-uax-15
- (sbcl-package->cl-source-package sbcl-uax-15))
-
-(define-public ecl-uax-15
- (sbcl-package->ecl-package sbcl-uax-15))
-
-(define-public sbcl-cl-unicode
- (package
- (name "sbcl-cl-unicode")
- (version "0.1.6")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-unicode";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-flexi-streams))
- (inputs
- (list 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)))
-
-(define-public ecl-cl-unicode
- (sbcl-package->ecl-package sbcl-cl-unicode))
-
-(define-public cl-unicode
- (sbcl-package->cl-source-package sbcl-cl-unicode))
+ (base32 "0kzybw5qlb49czh9v2lnxniz9jzqx306a6lnarfv59x48a7cch22"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-hu.dwim.stefil))
+ (home-page "https://github.com/phoe/binding-arrows";)
+ (synopsis "Threading macros based on binding anonymous variables")
+ (description
+ "This system implements binding threading macros -- a kind of threading
+macros with different semantics than classical, Clojure core threading macros
+or their extension, swiss-arrows. Two Common Lisp implementations of those are
+@code{arrows} and @code{arrow-macros}.
-(define-public sbcl-cl-ppcre-unicode
- (package (inherit sbcl-cl-ppcre)
- (name "sbcl-cl-ppcre-unicode")
- (inputs
- (list sbcl-cl-ppcre sbcl-cl-unicode))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'disable-ppcre
- ;; cl-ppcre and cl-ppcre-unicode are put in different packages
- ;; to work around the circular dependency between edicl/cl-ppcre
- ;; and edicl/cl-unicode.
- (lambda _
- (delete-file "cl-ppcre.asd")
- #t)))))))
+This system is a fork of @code{arrows} with changes in semantics that make it
+impossible to merge back upstream.")
+ (license license:expat))))
-(define-public cl-ppcre-unicode
- (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode))
+(define-public ecl-binding-arrows
+ (sbcl-package->ecl-package sbcl-binding-arrows))
-(define-public ecl-cl-ppcre-unicode
- (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
+(define-public cl-binding-arrows
+ (sbcl-package->cl-source-package sbcl-binding-arrows))
-(define-public sbcl-zpb-ttf
- (package
- (name "sbcl-zpb-ttf")
- (version "1.0.6")
- (source
- (origin
+(define-public sbcl-binpack
+ (let ((commit "e67f56bb697bdeac81e28e1cca4a5d117a9cf125")
+ (revision "1"))
+ (package
+ (name "sbcl-binpack")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/xach/zpb-ttf";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name "cl-zpb-ttf" version))
+ (url "https://github.com/lispgames/binpack";)
+ (commit commit)))
+ (file-name (git-file-name "binpack" version))
(sha256
- (base32 "043xga76jms7dipcwnyh8lkj3gx66cvrkwhc728hjaf7axarvcmv"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/xach/zpb-ttf";)
- (synopsis "TrueType font file access for Common Lisp")
- (description
- "ZPB-TTF is a TrueType font file parser that provides an interface for
-reading typographic metrics, glyph outlines, and other information from the
-file.")
- (license license:bsd-2)))
+ (base32 "1pcnsg60pqywd3k72m5pwimq01sm3jyvc1c3rbkij740r7grdxi1"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://github.com/lispgames/binpack";)
+ (synopsis "Common Lisp rectangle packer for sprite/texture atlases")
+ (description
+ "This library features a rectangle packer for sprite and texture
atlases.")
+ (license license:expat))))
-(define-public ecl-zpb-ttf
- (sbcl-package->ecl-package sbcl-zpb-ttf))
+(define-public cl-binpack
+ (sbcl-package->cl-source-package sbcl-binpack))
-(define-public cl-zpb-ttf
- (sbcl-package->cl-source-package sbcl-zpb-ttf))
+(define-public ecl-binpack
+ (sbcl-package->ecl-package sbcl-binpack))
-(define-public sbcl-zip
- ;; named branch is outdated
- (let ((commit "688b1545dd7a4fe355556768bb03f8bd9b847a87")
- (revision "1"))
+(define-public sbcl-bit-smasher
+ ;; No release.
+ (let ((commit "c2dcb3b5ec0e485484be681fe17c4e81e58790d9"))
(package
- (name "sbcl-zip")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-bit-smasher")
+ (version (git-version "1.0.2" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bluelisp/zip";)
+ (url "https://github.com/thephoeron/bit-smasher/";)
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0s08a6fq182fzsbfyvihqbdllq6gxcwkvphxnrd9wwz65dhg5y66"))
- (file-name (git-file-name "cl-zip" version))))
+ (base32 "0wjmwn06fjpw0rlpaksf3ab727p8fnzj58z7jajl3m0wqd4ii74w"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-babel
- sbcl-cl-fad
- sbcl-salza2
- sbcl-trivial-gray-streams))
- (synopsis "Zip library written in Common Lisp")
- (description "This package provide a Common Lisp library for .zip-file
-reading and writing.")
- (home-page "https://zip.common-lisp.dev";)
- (license (list license:bsd-2 license:llgpl)))))
+ `(("cl-base64" ,sbcl-cl-base64)
+ ("cl-base58" ,sbcl-cl-base58)))
+ (home-page "https://github.com/thephoeron/bit-smasher/";)
+ (synopsis "Handle bit vectors, bit vector arithmetic, and type
conversions")
+ (description
+ "Utility library for handling bit vectors, bit vector arithmetic, and
+universal integer type conversions between bit-vectors, byte-vectors, octals,
+decimals, and hexadecimal notation.")
+ (license license:expat))))
-(define-public ecl-zip
- (sbcl-package->ecl-package sbcl-zip))
+(define-public cl-bit-smasher
+ (sbcl-package->cl-source-package sbcl-bit-smasher))
-(define-public cl-zip
- (sbcl-package->cl-source-package sbcl-zip))
+(define-public ecl-bit-smasher
+ (sbcl-package->ecl-package sbcl-bit-smasher))
-(define-public sbcl-zippy
- (let ((commit "ed9bca591ded2ff27a9ac95d9a60827773a0e707")
+(define-public sbcl-bknr-datastore
+ (let ((commit "c98d44f47cc88d19ff91ca3eefbd9719a8ace022")
(revision "1"))
(package
- (name "sbcl-zippy")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-bknr-datastore")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/zippy/";)
+ (url "https://github.com/hanshuebner/bknr-datastore";)
(commit commit)))
+ (file-name (git-file-name "bknr-datastore" version))
(sha256
- (base32 "16cvyyf2nzd9r3fcy4w6d5wh8n3x833wldmrxmnzd3k2xrkhzfl9"))
- (file-name (git-file-name "zippy" version))))
+ (base32 "1vi3w65fnczqvswkm381n6liqfrzjrg40y698qvj7skj28dm5vrm"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-documentation-utils
- sbcl-file-attributes
- sbcl-pathname-utils
- sbcl-alexandria
- sbcl-nibbles
- sbcl-babel
- sbcl-3bz
- sbcl-salza2))
- (synopsis "Fast zip archive library")
- (description "Zippy is a library for the PKWARE Zip archive format. It
-can read and write zip files. It features:
-
-@itemize
-@item archive inspection without extraction;
-@item Zip64 support;
-@item split archive support;
-@item PKWARE decryption;
-@item fast deflate decompression thanks to 3bz;
-@item operates on streams and vectors;
-@item can compress stream->stream;
-@item extensible for other encryption and compression mechanisms.
-@end itemize\n")
- (home-page "https://shinmera.github.io/zippy/";)
- (license license:zlib))))
-
-(define-public ecl-zippy
- (sbcl-package->ecl-package sbcl-zippy))
-
-(define-public cl-zippy
- (sbcl-package->cl-source-package sbcl-zippy))
-
-(define-public sbcl-cl-vectors
- (package
- (name "sbcl-cl-vectors")
- (version "0.1.5")
- (source
- (origin
- (method url-fetch)
- (uri (string-append "http://projects.tuxee.net/cl-vectors/";
- "files/cl-vectors-" version ".tar.gz"))
- (sha256
- (base32
- "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("zpb-ttf" ,sbcl-zpb-ttf)))
- (arguments
- '(#:asd-systems '("cl-vectors"
- "cl-paths"
- "cl-paths-ttf"
- "cl-aa"
- "cl-aa-misc")))
- (home-page "http://projects.tuxee.net/cl-vectors/";)
- (synopsis "Create, transform and render anti-aliased vectorial paths")
- (description
- "This is a pure Common Lisp library to create, transform and render
-anti-aliased vectorial paths.")
- (license license:expat)))
+ (arguments
+ `(#:asd-systems
+ '("bknr.datastore"
+ "bknr.impex"
+ "bknr.indices"
+ "bknr.skip-list"
+ "bknr.utils"
+ "bknr.xml")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'enter-source-directory
+ (lambda _
+ (chdir "src")
+ #t)))))
+ (native-inputs
+ `(("cl-store" ,sbcl-cl-store)
+ ("fiveam" ,sbcl-fiveam)
+ ("unit-test" ,sbcl-unit-test)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("cl-interpol" ,sbcl-cl-interpol)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cxml" ,sbcl-cxml)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("md5" ,sbcl-md5)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)
+ ("yason" ,sbcl-yason)))
+ (home-page "https://github.com/hanshuebner/bknr-datastore";)
+ (synopsis "In-memory database for Common Lisp")
+ (description
+ "BKNR.DATASTORE is an in-memory CLOS based database with transactions
+for Common Lisp.")
+ (license license:bsd-0))))
-(define-public ecl-cl-vectors
- (sbcl-package->ecl-package sbcl-cl-vectors))
+(define-public cl-bknr-datastore
+ (sbcl-package->cl-source-package sbcl-bknr-datastore))
-(define-public cl-vectors
- (sbcl-package->cl-source-package sbcl-cl-vectors))
+;; NOTE: (Sharlatan-20210429T191426+0100):
+;; There is no port for ECL in upstream yet
+;; (define-public ecl-bknr-datastore
+;; (sbcl-package->ecl-package sbcl-bknr-datastore))
-(define-public sbcl-spatial-trees
- ;; There have been no releases.
- (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
+(define-public sbcl-blackbird
+ (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
(revision "1"))
(package
- (name "sbcl-spatial-trees")
- (version (git-version "0" revision commit))
+ (name "sbcl-blackbird")
+ (version (git-version "0.5.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/spatial-trees";)
+ (url "https://github.com/orthecreedence/blackbird";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
+ "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; We cannot build "spatial-trees-viz" here because it depends on
- ;; mcclim which depends on spatial-trees. FIXME: Break the circle.
- '(#:asd-systems '("spatial-trees" "spatial-trees.nns")))
(inputs
- (list sbcl-alexandria sbcl-optima sbcl-iterate))
+ (list sbcl-vom))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/rpav/spatial-trees";)
- (synopsis "Dynamic index data structures for spatially-extended data")
+ (list sbcl-cl-async sbcl-fiveam))
+ (synopsis "Promise implementation for Common Lisp")
(description
- "Spatial-trees is a set of dynamic index data structures for
-spatially-extended data.")
- (license license:bsd-3))))
+ "This is a standalone promise implementation for Common Lisp. It is
+the successor to the now-deprecated cl-async-future project.")
+ (home-page "https://orthecreedence.github.io/blackbird/";)
+ (license license:expat))))
-(define-public ecl-spatial-trees
- (sbcl-package->ecl-package sbcl-spatial-trees))
+(define-public cl-blackbird
+ (sbcl-package->cl-source-package sbcl-blackbird))
-(define-public cl-spatial-trees
- (sbcl-package->cl-source-package sbcl-spatial-trees))
+(define-public ecl-blackbird
+ (sbcl-package->ecl-package sbcl-blackbird))
-(define-public sbcl-flexichain
- ;; There are no releases.
- (let ((commit "9af644a6323f303a936a391b956babcbfe7b0c67")
- (revision "2"))
+(define-public sbcl-bobbin
+ (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce")
+ (revision "0"))
(package
- (name "sbcl-flexichain")
- (version (git-version "1.5.1" revision commit))
+ (name "sbcl-bobbin")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Flexichain";)
+ (url "https://github.com/sjl/bobbin";)
(commit commit)))
- (file-name (git-file-name "cl-flexichain" version))
+ (file-name (git-file-name "cl-bobbin" version))
(sha256
- (base32 "1ivkffnkc1iqmpl1p1rgyfbbgjmjcid4iszvdql1jjz324lq94g6"))))
+ (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-1am))
(inputs
- (list sbcl-trivial-garbage))
- (home-page "https://github.com/robert-strandh/Flexichain.git";)
- (synopsis "Dynamically add elements to or remove them from sequences")
+ (list sbcl-split-sequence))
+ (home-page "https://docs.stevelosh.com/bobbin/";)
+ (synopsis "Simple (word) wrapping utilities for strings")
(description
- "This package provides an implementation of the flexichain protocol,
-allowing client code to dynamically add elements to, and delete elements from
-a sequence (or chain) of such elements.")
- (license license:lgpl2.1+))))
+ "Bobbin is a simple word-wrapping library for strings in Common Lisp.
+It aims to be simple, work nicely for the majority of cases, and degrade
+gracefully for edge cases. It is not particularly concerned with speed — if
+you need very high-performance word wrapping, Bobbin is not for you.")
+ (license license:expat))))
-(define-public ecl-flexichain
- (sbcl-package->ecl-package sbcl-flexichain))
+(define-public cl-bobbin
+ (sbcl-package->cl-source-package sbcl-bobbin))
-(define-public cl-flexichain
- (sbcl-package->cl-source-package sbcl-flexichain))
+(define-public ecl-bobbin
+ (sbcl-package->ecl-package sbcl-bobbin))
-(define-public sbcl-cl-pdf
- (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213")
- (revision "3"))
+(define-public sbcl-bodge-blobs-support
+ (let ((commit "c5034ca5f4fc3a44dbadeba215a09afd59a404b0")
+ (revision "1"))
(package
- (name "sbcl-cl-pdf")
- (version (git-version "2.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mbattyani/cl-pdf";)
- (commit commit)))
- (file-name (git-file-name "cl-pdf" version))
- (sha256
- (base32 "0j7hbqv6yzrgx0inqinpw8h22728l53ccciw6iymzz4g92j9fzlq"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-iterate sbcl-zpb-ttf))
- (arguments
- `(#:asd-systems '("cl-pdf" "cl-pdf-parser")))
- (home-page "https://github.com/mbattyani/cl-pdf";)
- (synopsis "Common Lisp library for generating PDF files")
- (description
- "CL-PDF is a cross-platform Common Lisp library for generating PDF
-files.")
- (license license:bsd-2))))
+ (name "sbcl-bodge-blobs-support")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/borodust/bodge-blobs-support";)
+ (commit commit)))
+ (file-name (git-file-name "bodge-blobs-support" version))
+ (sha256
+ (base32 "02nd1x6y1akp1ymv1y4z9ympwbnpd1drwi4f86xbjszxqff6jyj8"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-trivial-features))
+ (inputs
+ (list sbcl-cffi sbcl-alexandria))
+ (home-page "https://github.com/borodust/bodge-blobs-support";)
+ (synopsis "Common Lisp utilities for blob packages")
+ (description
+ "This is a Common Lisp library for simplifying packaging and loading of
+compiled foreign library collection.")
+ (license license:unlicense))))
-(define-public ecl-cl-pdf
- (sbcl-package->ecl-package sbcl-cl-pdf))
+(define-public cl-bodge-blobs-support
+ (sbcl-package->cl-source-package sbcl-bodge-blobs-support))
-(define-public cl-pdf
- (sbcl-package->cl-source-package sbcl-cl-pdf))
+(define-public ecl-bodge-blobs-support
+ (sbcl-package->ecl-package sbcl-bodge-blobs-support))
-(define-public sbcl-clx
- (let ((commit "38400456d66823e417d1d27d339b09885e25eb59")
+(define-public sbcl-bodge-math
+ (let ((commit "9159b7faf88d440024c07110dbef2abddb20b9af")
(revision "1"))
(package
- (name "sbcl-clx")
- (version (git-version "0.7.5" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/sharplispers/clx";)
- (commit commit)))
- (sha256
- (base32 "1c05gjqh5lil2sgma0yap4mxd9y1cjkp933hyx1iaj14950nhfnl"))
- (file-name (git-file-name "cl-clx" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiasco xorg-server-for-tests))
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-before 'check 'prepare-test-environment
- (lambda _
- (system "Xvfb :1 &")
- (setenv "DISPLAY" ":1"))))))
- (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
-make it compile and run under SBCL, then a selection of patches were added
-from other CLXes around the net.")
- (license license:x11))))
+ (name "sbcl-bodge-math")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/borodust/bodge-math";)
+ (commit commit)))
+ (file-name (git-file-name "bodge-math" version))
+ (sha256
+ (base32 "0r3vnl9lywn4ksy34apcv6j825qp7l1naddawr14v4lwacndb80v"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-bodge-utilities sbcl-rtg-math))
+ (home-page "https://github.com/borodust/bodge-math";)
+ (synopsis "Common Lisp core math utilities of BODGE library collection")
+ (description
+ "This Common Lisp package contains the core math utilities of the
+@emph{Bodge} library collection.")
+ (license license:expat))))
-(define-public cl-clx
- (sbcl-package->cl-source-package sbcl-clx))
+(define-public ecl-bodge-math
+ (sbcl-package->ecl-package sbcl-bodge-math))
-(define-public ecl-clx
- (sbcl-package->ecl-package sbcl-clx))
+(define-public cl-bodge-math
+ (sbcl-package->cl-source-package sbcl-bodge-math))
-(define-public sbcl-cl-wayland
- (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae")
+(define-public sbcl-bodge-queue
+ (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a")
(revision "0"))
(package
- (name "sbcl-cl-wayland")
+ (name "sbcl-bodge-queue")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sdilts/cl-wayland";)
+ (url "https://github.com/borodust/bodge-queue";)
(commit commit)))
- (file-name (git-file-name "cl-wayland" version))
+ (file-name (git-file-name "bodge-queue" version))
(sha256
- (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf"))))
+ (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "wayland-server-core.lisp"
- (("libwayland-server.so")
- (search-input-file inputs
- "/lib/libwayland-server.so"))))))))
- (inputs
- (list sbcl-cffi
- sbcl-closer-mop
- wayland))
- (home-page "https://github.com/sdilts/cl-wayland";)
- (synopsis "Common Lisp FFI bindings for libwayland")
- (description
- "This package provides Common Lisp FFI bindings for libwayland,
-primarily for the mahogany window manager.")
- (license license:bsd-3))))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/borodust/bodge-queue";)
+ (synopsis "Simple queue for Common Lisp")
+ (description "This Common Lisp library provides a simple FIFO
+implementation with no external dependencies.")
+ (license license:expat))))
-(define-public cl-wayland
- (sbcl-package->cl-source-package sbcl-cl-wayland))
+(define-public cl-bodge-queue
+ (sbcl-package->cl-source-package sbcl-bodge-queue))
-(define-public ecl-cl-wayland
- (sbcl-package->ecl-package sbcl-cl-wayland))
+(define-public ecl-bodge-queue
+ (sbcl-package->ecl-package sbcl-bodge-queue))
-(define-public sbcl-clx-truetype
- (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
+(define-public sbcl-bodge-utilities
+ (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f")
(revision "1"))
(package
- (name "sbcl-clx-truetype")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/l04m33/clx-truetype";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- (substitute* "package.lisp"
- ((":export") ":export\n :+font-cache-filename+"))
- #t))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-clx
- sbcl-zpb-ttf
- sbcl-cl-vectors
- sbcl-cl-fad
- sbcl-cl-store
- sbcl-trivial-features))
- (home-page "https://github.com/l04m33/clx-truetype";)
- (synopsis "Antialiased TrueType font rendering using CLX and XRender")
- (description "CLX-TrueType is pure common lisp solution for
-antialiased TrueType font rendering using CLX and XRender extension.")
- (license license:expat))))
+ (name "sbcl-bodge-utilities")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/borodust/bodge-utilities";)
+ (commit commit)))
+ (file-name (git-file-name "bodge-utilities" version))
+ (sha256
+ (base32 "1z1blj05q71vzh323qwyn9p3xs7v0mq2yhwfyzza5libp37wqm3c"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-claw
+ sbcl-dissect
+ sbcl-local-time
+ sbcl-log4cl
+ sbcl-split-sequence
+ sbcl-static-vectors
+ sbcl-trivial-gray-streams))
+ (home-page "https://github.com/borodust/bodge-utilities";)
+ (synopsis "Common Lisp utilities library for CL-BODGE")
+ (description
+ "This Common Lisp library provides utilities for the @emph{Bodge} library
+collection.")
+ (license license:expat))))
-(define-public cl-clx-truetype
- (sbcl-package->cl-source-package sbcl-clx-truetype))
+(define-public cl-bodge-utilities
+ (sbcl-package->cl-source-package sbcl-bodge-utilities))
-(define-public ecl-clx-truetype
- (sbcl-package->ecl-package sbcl-clx-truetype))
+(define-public ecl-bodge-utilities
+ (sbcl-package->ecl-package sbcl-bodge-utilities))
-(define-public sbcl-slynk
- ;; Update together with emacs-sly.
- (let ((commit "9c43bf65b967e12cef1996f1af5f0671d8aecbf4")
- (revision "9"))
+(define-public sbcl-boost-json
+ (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47")
+ (revision "0"))
(package
- (name "sbcl-slynk")
- (version (git-version "1.0.43" revision commit))
+ (name "sbcl-boost-json")
+ (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/joaotavora/sly";)
- (commit commit)))
+ (uri (git-reference
+ (url "https://github.com/cl-boost/json";)
+ (commit commit)))
+ (file-name (git-file-name "cl-boost-json" version))
(sha256
- (base32 "15nyr02ykkws4q79jcmxcawddg8sgq9v5l8k7jv7gg3hnpzxjlb2"))
- (file-name (git-file-name "cl-slynk" version))))
+ (base32 "12k0470899qsll2qixksxf2vrhjmskk3nzp1di9k04n1b29nrakd"))))
(build-system asdf-build-system/sbcl)
- (outputs '("out" "image"))
(arguments
- `(#:phases
+ '(#:phases
(modify-phases %standard-phases
- (add-after 'create-asdf-configuration 'build-image
- (lambda* (#:key outputs #:allow-other-keys)
- (build-image (string-append
- (assoc-ref outputs "image")
- "/bin/slynk")
- outputs
- #:dependencies '("slynk"
- "slynk/arglists"
- "slynk/fancy-inspector"
- "slynk/package-fu"
- "slynk/mrepl"
- "slynk/trace-dialog"
- "slynk/profiler"
- "slynk/stickers"
- "slynk/indentation"
- "slynk/retro"))
- #t)))))
- (synopsis "Common Lisp IDE for Emacs")
- (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
-It also features a completely redesigned REPL based on Emacs's own
-full-featured @code{comint-mode}, live code annotations, and a consistent
interactive
-button interface. Everything can be copied to the REPL. One can create
-multiple inspectors with independent history.")
- (home-page "https://github.com/joaotavora/sly";)
- (license license:public-domain)
- (properties `((cl-source-variant . ,(delay cl-slynk)))))))
+ ;; See <https://github.com/cl-boost/json/pull/2>.
+ (add-after 'unpack 'fix-decode-symbol
+ (lambda _
+ (substitute* '("decode.lisp" "encode.lisp")
+ (("formfeed") "page")))))))
+ (home-page "https://github.com/cl-boost/json";)
+ (synopsis "JSON encoding and decoding for Common Lisp")
+ (description
+ "BOOST-JSON is a simple JSON parsing library for Common Lisp.")
+ (license license:asl2.0))))
-(define-public cl-slynk
- (sbcl-package->cl-source-package sbcl-slynk))
+(define-public cl-boost-json
+ (sbcl-package->cl-source-package sbcl-boost-json))
-(define-public ecl-slynk
- (let ((pkg (sbcl-package->ecl-package sbcl-slynk)))
- (package
- (inherit pkg)
- (outputs '("out"))
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:phases phases)
- `(modify-phases ,phases
- (delete 'build-image))))))))
+(define-public ecl-boost-json
+ (sbcl-package->ecl-package sbcl-boost-json))
-(define-public sbcl-parse-js
- (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
- (revision "1"))
+(define-public sbcl-boost-lexer
+ (let ((commit "139ca9e9580f890698deec05061e495376b7735a")
+ (revision "0"))
(package
- (name "sbcl-parse-js")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-boost-lexer")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://marijn.haverbeke.nl/git/parse-js";)
+ (url "https://github.com/cl-boost/lexer";)
(commit commit)))
- (file-name (git-file-name "cl-parse-js" version))
+ (file-name (git-file-name "cl-boost-lexer" version))
(sha256
- (base32
- "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
+ (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://marijnhaverbeke.nl/parse-js/";)
- (synopsis "Parse JavaScript")
- (description "Parse-js is a Common Lisp package for parsing
-JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
- (license license:zlib))))
-
-(define-public cl-parse-js
- (sbcl-package->cl-source-package sbcl-parse-js))
-
-(define-public ecl-parse-js
- (sbcl-package->ecl-package sbcl-parse-js))
-
-(define-public sbcl-parse-number
- (package
- (name "sbcl-parse-number")
- (version "1.7")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/parse-number/";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://www.cliki.net/PARSE-NUMBER";)
- (synopsis "Parse numbers")
- (description "@code{parse-number} is a library of functions for parsing
-strings into one of the standard Common Lisp number types without using the
-reader. @code{parse-number} accepts an arbitrary string and attempts to parse
-the string into one of the standard Common Lisp number types, if possible, or
-else @code{parse-number} signals an error of type @code{invalid-number}.")
- (license license:bsd-3)))
-
-(define-public cl-parse-number
- (sbcl-package->cl-source-package sbcl-parse-number))
-
-(define-public ecl-parse-number
- (sbcl-package->ecl-package sbcl-parse-number))
-
-(define-public sbcl-iterate
- (package
- (name "sbcl-iterate")
- (version "1.5.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/iterate/iterate.git";)
- (commit version)))
- (file-name (git-file-name "cl-iterate" version))
- (sha256
- (base32 "0l6l8fpgcpwpmi00jwmamxbspbqa8fil6dv11bf9gaxxbw41f8c2"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-rt))
- (home-page "https://common-lisp.net/project/iterate/";)
- (synopsis "Iteration construct for Common Lisp")
- (description "@code{iterate} is an iteration construct for Common Lisp.
-It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
-
-@itemize
-@item it is extensible,
-@item it helps editors like Emacs indent iterate forms by having a more
- lisp-like syntax, and
-@item it isn't part of the ANSI standard for Common Lisp.
-@end itemize\n")
- (license license:expat)))
-
-(define-public cl-iterate
- (sbcl-package->cl-source-package sbcl-iterate))
-
-(define-public ecl-iterate
- (sbcl-package->ecl-package sbcl-iterate))
-
-(define-public sbcl-charje.loop
- (package
- (name "sbcl-charje.loop")
- (version "0.0.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://git.sr.ht/~charje/loop";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-charje.loop" version))
- (sha256
- (base32
- "1x1hw5xmrx9xmfzga8y0yi6s27r7zc80rwl2z7l4d2h24ykscvd4"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-binding-arrows
- sbcl-parse-declarations))
- (home-page "https://git.sr.ht/~charje/loop";)
- (synopsis "Loop abstraction for Common Lisp that is consistent for
-different kinds of data")
- (description "Loop is a joy to use and has a consistent interface unlike
-other looping abstractions and ANSI list operations. You can define your own
-iterators and aggregators that integrate tightly into other operations. All
-operations are non-consing when possible.")
- (license license:agpl3+)))
+ (inputs
+ (list sbcl-boost-re))
+ (home-page "https://github.com/cl-boost/lexer";)
+ (synopsis "String tokenizing for Common Lisp")
+ (description
+ "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of
+BOOST-RE.")
+ (license license:asl2.0))))
-(define-public cl-charje.loop
- (sbcl-package->cl-source-package sbcl-charje.loop))
+(define-public cl-boost-lexer
+ (sbcl-package->cl-source-package sbcl-boost-lexer))
-(define-public ecl-charje.loop
- (sbcl-package->ecl-package sbcl-charje.loop))
+(define-public ecl-boost-lexer
+ (sbcl-package->ecl-package sbcl-boost-lexer))
-(define-public sbcl-cl-uglify-js
- ;; There have been many bug fixes since the 2010 release.
- (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
- (revision "1"))
+(define-public sbcl-boost-parse
+ (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50")
+ (revision "0"))
(package
- (name "sbcl-cl-uglify-js")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-boost-parse")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mishoo/cl-uglify-js";)
+ (url "https://github.com/cl-boost/parse";)
(commit commit)))
- (file-name (git-file-name "cl-uglify-js" version))
+ (file-name (git-file-name "cl-boost-parse" version))
(sha256
- (base32
- "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
+ (base32 "0djnp392n9wgpr9r2ycnwkglad5mn285yvr53jx3g7anm2p8r0vf"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-parse-js sbcl-cl-ppcre sbcl-cl-ppcre-unicode
- sbcl-parse-number sbcl-iterate))
- (home-page "https://github.com/mishoo/cl-uglify-js";)
- (synopsis "JavaScript compressor library for Common Lisp")
- (description "This is a Common Lisp version of UglifyJS, a JavaScript
-compressor. It works on data produced by @code{parse-js} to generate a
-@dfn{minified} version of the code. Currently it can:
-
-@itemize
-@item reduce variable names (usually to single letters)
-@item join consecutive @code{var} statements
-@item resolve simple binary expressions
-@item group most consecutive statements using the @code{sequence} operator
(comma)
-@item remove unnecessary blocks
-@item convert @code{IF} expressions in various ways that result in smaller code
-@item remove some unreachable code
-@end itemize\n")
- (license license:zlib))))
-
-(define-public cl-uglify-js
- (sbcl-package->cl-source-package sbcl-cl-uglify-js))
-
-(define-public ecl-cl-uglify-js
- (sbcl-package->ecl-package sbcl-cl-uglify-js))
+ (home-page "https://github.com/cl-boost/parse";)
+ (synopsis "Monadic parsing for Common Lisp")
+ (description
+ "BOOST-PARSE is a simple token parsing library for Common Lisp.")
+ (license license:asl2.0))))
-(define-public uglify-js
- (package
- (inherit sbcl-cl-uglify-js)
- (name "uglify-js")
- (build-system trivial-build-system)
- (arguments
- `(#:modules ((guix build utils))
- #:builder
- (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
- (script (string-append bin "uglify-js")))
- (use-modules (guix build utils))
- (mkdir-p bin)
- (with-output-to-file script
- (lambda _
- (format #t "#!~a/bin/sbcl --script
+(define-public cl-boost-parse
+ (sbcl-package->cl-source-package sbcl-boost-parse))
- (require :asdf)
- (asdf:initialize-source-registry
- #p\"~a/etc/common-lisp/source-registry.conf.d/\")
- (asdf:initialize-output-translations
- #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")"
- (assoc-ref %build-inputs "sbcl")
- (assoc-ref %build-inputs "sbcl-cl-uglify-js")
- (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
- ;; FIXME: cannot use progn here because otherwise it fails to
- ;; find cl-uglify-js.
- (for-each
- write
- '(;; Quiet, please!
- (let ((*standard-output* (make-broadcast-stream))
- (*error-output* (make-broadcast-stream)))
- (asdf:load-system :cl-uglify-js))
- (let ((file (cadr *posix-argv*)))
- (if file
- (format t "~a"
- (cl-uglify-js:ast-gen-code
- (cl-uglify-js:ast-mangle
- (cl-uglify-js:ast-squeeze
- (with-open-file (in file)
- (parse-js:parse-js in))))
- :beautify nil))
- (progn
- (format *error-output*
- "Please provide a JavaScript file.~%")
- (sb-ext:exit :code 1))))))))
- (chmod script #o755)
- #t)))
- (inputs
- (list sbcl sbcl-cl-uglify-js))
- (synopsis "JavaScript compressor")))
+(define-public ecl-boost-parse
+ (sbcl-package->ecl-package sbcl-boost-parse))
-(define-public sbcl-cl-strings
- (let ((revision "1")
- (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140"))
+(define-public sbcl-boost-re
+ (let ((commit "d279fc58abf76d0c40aa6cde42e17a0591bc2c5d")
+ (revision "0"))
(package
- (name "sbcl-cl-strings")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-boost-re")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/diogoalexandrefranco/cl-strings";)
+ (url "https://github.com/cl-boost/re";)
(commit commit)))
+ (file-name (git-file-name "cl-boost-re" version))
(sha256
- (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj"))
- (file-name (git-file-name "cl-strings" version))))
+ (base32 "1h9c2rdhw6m1pm67gqbj46y2vb1kc3i1c9y3l4qhgfz14dbk80a2"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Set of utilities to manipulate strings in Common Lisp")
+ (inputs
+ (list sbcl-boost-parse))
+ (home-page "https://github.com/cl-boost/re";)
+ (synopsis "Lua-style string pattern matching for Common Lisp")
(description
- "@command{cl-strings} is a small, portable, dependency-free set of
-utilities that make it even easier to manipulate text in Common Lisp. It has
-100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
- (home-page "https://github.com/diogoalexandrefranco/cl-strings";)
- (license license:expat))))
-
-(define-public cl-strings
- (sbcl-package->cl-source-package sbcl-cl-strings))
+ "BOOST-RE is a small, portable, lightweight, and quick, regular
+expression library for Common Lisp. It is a non-recursive, backtracking VM.")
+ (license license:asl2.0))))
-(define-public ecl-cl-strings
- (sbcl-package->ecl-package sbcl-cl-strings))
+(define-public cl-boost-re
+ (sbcl-package->cl-source-package sbcl-boost-re))
-(define-public sbcl-trivial-features
- (package
- (name "sbcl-trivial-features")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/trivial-features/trivial-features";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "trivial-features" version))
- (sha256
- (base32 "0jsqah1znzqilxnw5vannb083ayk0d7phkackqzwwqkyg5hpn6pq"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(;; FIXME: Tests disabled because of a circular dependency between
- ;; trivial-features and cffi.
- #:tests? #f))
- ;; (native-inputs
- ;; `(("cffi" ,sbcl-cffi)))
- (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.")
- (license license:expat)))
-
-(define-public cl-trivial-features
- (sbcl-package->cl-source-package sbcl-trivial-features))
-
-(define-public ecl-trivial-features
- (sbcl-package->ecl-package sbcl-trivial-features))
+(define-public ecl-boost-re
+ (sbcl-package->ecl-package sbcl-boost-re))
-(define-public sbcl-harmony
- (let ((commit "0b57483cc0341936c201b620f82a8542c606991f")
+(define-public sbcl-bordeaux-fft
+ (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
(revision "0"))
(package
- (name "sbcl-harmony")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-bordeaux-fft")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/harmony";)
+ (url "https://github.com/ahefner/bordeaux-fft";)
(commit commit)))
- (file-name (git-file-name "cl-harmony" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0pqmfi3yi3gi7b7dyayrb621hp60rn7hasq0cl0fis3vg0fp5dja"))))
+ (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-atomics
- sbcl-bordeaux-threads
- sbcl-cl-mixed
- sbcl-stealth-mixin
- sbcl-trivial-features))
- (home-page "https://shirakumo.github.io/harmony/";)
- (synopsis "Common Lisp sound server and sound processing library")
+ (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/";)
+ (synopsis "Fast Fourier Transform for Common Lisp")
(description
- "HARMONY is a library that provides you with audio processing tools as
-well as an audio server to play back music, sfx, and so forth. It is most
-suited for use in a game engine, but may feasibly also be used for more
-advanced things such as a DAW")
- (license license:zlib))))
+ "The Bordeaux-FFT library provides a reasonably efficient implementation
+of the Fast Fourier Transform and its inverse for complex-valued inputs, in
+portable Common Lisp.")
+ (license license:gpl2+))))
-(define-public ecl-harmony
- (sbcl-package->ecl-package sbcl-harmony))
+(define-public cl-bordeaux-fft
+ (sbcl-package->cl-source-package sbcl-bordeaux-fft))
-(define-public cl-harmony
- (sbcl-package->cl-source-package sbcl-harmony))
+(define-public ecl-bordeaux-fft
+ (sbcl-package->ecl-package sbcl-bordeaux-fft))
-(define-public sbcl-hu.dwim.asdf
- (let ((commit "67cdf84390e530af4303cc4bc815fdf2a5e48f59"))
- (package
- (name "sbcl-hu.dwim.asdf")
- (version "20200724")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.asdf";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0p81jalilkaqw832a12s35q0z6rrarxjasm1jy6h4fvyj9pf0zkx"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf";)
- (synopsis "Extensions to ASDF")
- (description "Various ASDF extensions such as attached test and
-documentation system, explicit development support, etc.")
- (license license:public-domain))))
+(define-public sbcl-bordeaux-threads
+ (package
+ (name "sbcl-bordeaux-threads")
+ (version "0.9.3")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sionescu/bordeaux-threads";)
+ (commit (string-append "v" version))))
+ (sha256
+ (base32 "0pp3w5hsph47sqagr4j2pbg3ddb29jx93zg8kvxsp2c4flp0qz0f"))
+ (file-name (git-file-name "cl-bordeaux-threads" version))))
+ (inputs (list sbcl-alexandria
+ sbcl-global-vars
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (native-inputs (list sbcl-fiveam))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'adjust-test-sleep
+ (lambda _
+ ;; 0.001 is too short for some slower machines.
+ (substitute* '("test/tests-v1.lisp"
+ "test/tests-v2.lisp")
+ (("sleep 0\\.001") "sleep 0.002")))))))
+ (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)))
-(define-public cl-hu.dwim.asdf
- (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
+(define-public cl-bordeaux-threads
+ (sbcl-package->cl-source-package sbcl-bordeaux-threads))
-(define-public ecl-hu.dwim.asdf
- (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
+(define-public ecl-bordeaux-threads
+ (sbcl-package->ecl-package sbcl-bordeaux-threads))
-(define-public sbcl-hu.dwim.graphviz
- (let ((commit "31522ca8b9a04d535b7cec20ef24d8bf3b26d52b")
- (revision "1"))
+(define-public sbcl-bst
+ (let ((commit "8545aed0d504df2829ad139566feeabe22305388")
+ (revision "0"))
(package
- (name "sbcl-hu.dwim.graphviz")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-bst")
+ (version (git-version "2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.graphviz";)
+ (url "https://codeberg.org/glv/bst";)
(commit commit)))
- (file-name (git-file-name "cl-hu.dwim.graphviz" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0cz5g7d6817ajypp876k9m65sxxlf42x4bg04ya73aqci5s1vjwy"))))
+ (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'patch-graphviz-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "source/package.lisp"
- (("libgvc.so")
- (search-input-file inputs "/lib/libgvc.so"))))))))
(native-inputs
- (list sbcl-hu.dwim.common sbcl-hu.dwim.stefil))
- (inputs
- (list graphviz sbcl-cffi sbcl-metabang-bind))
- (home-page "https://github.com/hu-dwim/hu.dwim.graphviz";)
- (synopsis "Graphviz layouting using CFFI bindings")
+ (list sbcl-alexandria sbcl-fiveam))
+ (synopsis "Binary search tree for Common Lisp")
(description
- "This package provides CFFI bindings to the Graphviz library in Common
-Lisp.")
- (license license:public-domain))))
+ "BST is a Common Lisp library for working with binary search trees that
+can contain any kind of values.")
+ (home-page "https://codeberg.org/glv/bst";)
+ (license license:gpl3))))
-(define-public cl-hu.dwim.graphviz
- (sbcl-package->cl-source-package sbcl-hu.dwim.graphviz))
+(define-public cl-bst
+ (sbcl-package->cl-source-package sbcl-bst))
-(define-public ecl-hu.dwim.graphviz
- (sbcl-package->ecl-package sbcl-hu.dwim.graphviz))
+(define-public ecl-bst
+ (sbcl-package->ecl-package sbcl-bst))
-(define-public sbcl-cl-dot
- (let ((commit "73dfbb6e015a28ebed873266e4e8190e509b43de")
+(define-public sbcl-bubble-operator-upwards
+ (let ((commit "846275a318b960de81b62caecb1e31930f70aef6")
(revision "0"))
(package
- (name "sbcl-cl-dot")
- (version (git-version "0.9.0" revision commit))
+ (name "sbcl-bubble-operator-upwards")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/michaelw/cl-dot";)
+ (url "https://github.com/Hexstream/bubble-operator-upwards";)
(commit commit)))
- (file-name (git-file-name "cl-dot" version))
+ (file-name (git-file-name "cl-bubble-operator-upwards" version))
(sha256
- (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa"))))
+ (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/michaelw/cl-dot";)
- (synopsis "Generate Graphviz dot output from arbitrary Lisp data")
+ (native-inputs
+ (list sbcl-parachute))
+ (home-page
"https://www.hexstreamsoft.com/libraries/bubble-operator-upwards/";)
+ (synopsis "Function that bubbles an operator upwards in a form")
(description
- "CL-DOT is a Common Lisp library for generating Graphviz dot output from
-arbitrary Lisp data.")
- (license license:expat))))
+ "@code{bubble-operator-upwards} is a function that bubbles an operator
+upwards in a form, demultiplexing all alternative branches by way of
+cartesian product.")
+ (license license:unlicense))))
-(define-public cl-dot
- (sbcl-package->cl-source-package sbcl-cl-dot))
+(define-public cl-bubble-operator-upwards
+ (sbcl-package->cl-source-package sbcl-bubble-operator-upwards))
-(define-public ecl-cl-dot
- (sbcl-package->ecl-package sbcl-cl-dot))
+(define-public ecl-bubble-operator-upwards
+ (sbcl-package->ecl-package sbcl-bubble-operator-upwards))
-(define-public sbcl-cl-graph
- (let ((commit "c617de35390cb02db88bc5b5febffafdb8947ae8")
+(define-public sbcl-burgled-batteries3
+ (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
(revision "2"))
(package
- (name "sbcl-cl-graph")
- (version (git-version "0.10.2" revision commit))
+ (name "sbcl-burgled-batteries3")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/cl-graph";)
+ (url "https://github.com/snmsts/burgled-batteries3";)
(commit commit)))
- (file-name (git-file-name "cl-graph" version))
+ (file-name (git-file-name "cl-burgled-batteries3" version))
(sha256
- (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf"))))
+ (base32
+ "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))
+ (patches
+ (search-patches "sbcl-burgled-batteries3-fix-signals.patch"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; TODO: (Sharlatan-20221118T215839+0000): Tests failed
- ;;
- ;; https://github.com/gwkkwg/cl-graph/issues/17
- ;;
`(#:tests? #f
- #:asd-systems '("cl-graph" "cl-graph+hu.dwim.graphviz")))
- (native-inputs
- (list sbcl-lift sbcl-moptilities))
- (inputs
- (list sbcl-cl-containers
- sbcl-cl-mathstats
- sbcl-dynamic-classes
- sbcl-hu.dwim.graphviz
- sbcl-metabang-bind
- sbcl-metacopy
- sbcl-metatilities-base))
- (home-page "https://github.com/gwkkwg/cl-graph";)
- (synopsis "Graph manipulation utilities for Common Lisp")
- (description
- "This package provides a Common Lisp library for manipulating graphs
-and running graph algorithms.")
- (license license:expat))))
+ #:modules (((guix build python-build-system) #:select
(python-version))
+ ,@%asdf-build-system-modules)
+ #:imported-modules ((guix build python-build-system)
+ ,@%asdf-build-system-modules)
+ #:phases
+ (modify-phases (@ (guix build asdf-build-system) %standard-phases)
+ (add-after 'unpack 'set-*cpython-include-dir*-var
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((python (assoc-ref inputs "python")))
+ (setenv "BB_PYTHON3_INCLUDE_DIR"
+ (string-append python "/include/python"
+ (python-version python)))
+ (setenv "BB_PYTHON3_DYLIB"
+ (string-append python "/lib/libpython3.so"))
+ #t)))
+ (add-after 'unpack 'adjust-for-python-3.10
+ (lambda _
+ ;; These methods are no longer part of the public API.
+ (substitute* "ffi-interface.lisp"
+ ((".*PyEval_ReInitThreads.*") "")
+ ((".*\"PyErr_Warn\".*") "")
+ ((".*\"PyFloat_ClearFreeList\".*") "")
+ ((".*\"PyParser_SimpleParseString\".*") "")
+ ((".*\"PyParser_SimpleParseStringFlags\".*") "")
+ ((".*\"PyParser_SimpleParseStringFlagsFilename\".*") "")
+ ((".*\"PyParser_SimpleParseFile\".*") "")
+ ((".*\"PyParser_SimpleParseFileFlags\".*") "")
+ ((".*\"PyLong_FromUnicode\".*") "")))))))
+ (native-inputs
+ (list sbcl-cl-fad sbcl-lift sbcl-cl-quickcheck))
+ (inputs
+ (list python
+ sbcl-alexandria
+ sbcl-cffi
+ sbcl-parse-declarations
+ 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";)
+ (license license:expat))))
-;; NOTE: (Sharlatan-20221118T214734+0000): No ECL supoort
-;;
-;; ecl-cl-graph
+(define-public cl-burgled-batteries3
+ (sbcl-package->cl-source-package sbcl-burgled-batteries3))
-(define-public cl-cl-graph
- (sbcl-package->cl-source-package sbcl-cl-graph))
+(define-public ecl-burgled-batteries3
+ (sbcl-package->ecl-package sbcl-burgled-batteries3))
-(define-public sbcl-babel
- ;; No release since 2014.
- (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9")
- (revision "3"))
+(define-public sbcl-cache-while
+ (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7")
+ (revision "1"))
(package
- (name "sbcl-babel")
- (version (git-version "0.5.0" revision commit))
+ (name "sbcl-cache-while")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-babel/babel";)
+ (url "https://github.com/charje/cache-while";)
(commit commit)))
- (file-name (git-file-name "cl-babel" version))
+ (file-name (git-file-name "cache-while" version))
(sha256
- (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380"))))
+ (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.stefil))
- (inputs
- (list sbcl-alexandria sbcl-trivial-features))
- (home-page "https://common-lisp.net/project/babel/";)
- (synopsis "Charset encoding and decoding library")
- (description "Babel is a charset encoding and decoding library, not
unlike
-GNU libiconv, but completely written in Common Lisp.")
- (license (list license:bsd-2 license:expat)))))
-
-(define-public cl-babel
- (sbcl-package->cl-source-package sbcl-babel))
-
-(define-public ecl-babel
- (sbcl-package->ecl-package sbcl-babel))
-
-(define-public sbcl-cl-yacc
- (package
- (name "sbcl-cl-yacc")
- (version "0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jech/cl-yacc";)
- (commit (string-append "cl-yacc-" version))))
- (sha256
- (base32
- "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
- (file-name (string-append "cl-yacc-" version "-checkout"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("yacc")))
- (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to
Yacc")
- (description
- "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
-to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
-
-CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
-by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
-to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
- (home-page "https://www.irif.fr/~jch//software/cl-yacc/";)
- (license license:expat)))
+ (home-page "https://github.com/charje/cache-while";)
+ (synopsis "Temporary / one-time caching macro for Common Lisp")
+ (description
+ "This is a Common Lisp macro for defining temporary caches that
+invalidate based on expressions evaluating to different values.")
+ (license license:llgpl))))
-(define-public cl-yacc
- (sbcl-package->cl-source-package sbcl-cl-yacc))
+(define-public cl-cache-while
+ (sbcl-package->cl-source-package sbcl-cache-while))
-(define-public ecl-cl-yacc
- (sbcl-package->ecl-package sbcl-cl-yacc))
+(define-public ecl-cache-while
+ (sbcl-package->ecl-package sbcl-cache-while))
-(define-public sbcl-eager-future2
- (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30"))
+(define-public sbcl-calispel
+ (let ((commit "e9f2f9c1af97f4d7bb4c8ac25fb2a8f3e8fada7a"))
(package
- (name "sbcl-eager-future2")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-calispel")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git";)
+ ;; This fork replaces the dependency on the obsolete
+ ;; eager-future with eager-future2.
+ (url "https://github.com/hawkir/calispel";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld"))))
+ "08bmf3pi7n5hadpmqqkg65cxcj6kbvm997wcs1f53ml1nb79d9z8"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-bordeaux-threads sbcl-trivial-garbage))
- (synopsis "Futures promises synchronization mechanism for Common Lisp")
+ (list sbcl-jpl-queues sbcl-bordeaux-threads))
+ (native-inputs
+ (list sbcl-eager-future2))
+ (synopsis "Thread-safe message-passing channels in Common Lisp")
(description
- "Eager Future2 is a Common Lisp library that provides composable
-concurrency primitives that unify parallel and lazy evaluation, are integrated
-with the Common Lisp condition system, and have automatic resource
-management.")
- (home-page "https://gitlab.common-lisp.net/vsedach/eager-future2";)
- (license license:lgpl3+))))
+ "Calispel is a Common Lisp library for thread-safe message-passing
+channels, in the style of the occam programming language, also known as
+communicating sequential processes (CSP). See
+@url{https://en.wikipedia.org/wiki/Communicating_sequential_processes}.
-(define-public cl-eager-future2
- (sbcl-package->cl-source-package sbcl-eager-future2))
+Calispel channels let one thread communicate with another, facilitating
+unidirectional communication of any Lisp object. Channels may be unbuffered,
+where a sender waits for a receiver (or vice versa) before either operation can
+continue, or channels may be buffered with flexible policy options.
-(define-public ecl-eager-future2
- (sbcl-package->ecl-package sbcl-eager-future2))
+Because sending and receiving on a channel may block, either operation can time
+out after a specified amount of time.
-(define-public sbcl-easy-routes
- (let ((commit "7832f8bf3d07825b5eb967a2ef04da7c40c18248")
- (revision "0"))
+A syntax for alternation is provided (like @code{ALT} in occam, or Unix
+@code{select()}): given a sequence of operations, any or all of which may
+block, alternation selects the first operation that doesn't block and executes
+associated code. Alternation can also time out, executing an \"otherwise\"
+clause if no operation becomes available within a set amount of time.
+
+Calispel is a message-passing library, and as such leaves the role of
+threading abstractions and utilities left to be filled by complementary
+libraries such as Bordeaux-Threads and Eager Future.")
+ (home-page "https://www.thoughtcrime.us/software/calispel/";)
+ (license license:isc))))
+
+(define-public cl-calispel
+ (sbcl-package->cl-source-package sbcl-calispel))
+
+(define-public ecl-calispel
+ (sbcl-package->ecl-package sbcl-calispel))
+
+(define-public sbcl-calm
+ (package
+ (name "sbcl-calm")
+ (version "0.0.35")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/VitoVan/calm";)
+ (commit version)))
+ (file-name (git-file-name "cl-calm" version))
+ (sha256
+ (base32 "1k1kwpiq7ikk1mgfi26sd968d623jl6xffngd9vwswnaiwihk4dp"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cl-cairo2
+ sbcl-cl-str
+ sbcl-sdl2
+ sbcl-sdl2-image
+ sbcl-sdl2-mixer
+ sbcl-slime-swank))
+ (home-page "https://github.com/VitoVan/calm";)
+ (synopsis "Vector graphic library for Common Lisp")
+ (description
+ "This package provides a SDL2 based vector graphic library for Common
+Lisp.")
+ (license license:gpl2)))
+
+(define-public cl-calm
+ (sbcl-package->cl-source-package sbcl-calm))
+
+(define-public ecl-calm
+ (sbcl-package->ecl-package sbcl-calm))
+
+(define-public sbcl-cambl
+ (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
+ (revision "1"))
(package
- (name "sbcl-easy-routes")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cambl")
+ (version (git-version "4.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/easy-routes";)
+ (url "https://github.com/jwiegley/cambl";)
(commit commit)))
- (file-name (git-file-name "cl-easy-routes" version))
+ (file-name (git-file-name "cambl" version))
(sha256
- (base32 "1banw54kz2llzb9h5sm47ckfc9l348m7qncm0npsy0w837rxkyzx"))))
+ (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("easy-routes"
- "easy-routes+djula"
- "easy-routes+errors")))
(native-inputs
- (list sbcl-stefil))
+ (list sbcl-xlunit))
(inputs
- (list sbcl-djula
- sbcl-hunchentoot
- sbcl-hunchentoot-errors
- sbcl-routes))
- (home-page "https://github.com/mmontone/easy-routes/";)
- (synopsis "Routes handling utility on top of Hunchentoot")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-containers" ,sbcl-cl-containers)
+ ("local-time" ,sbcl-local-time)
+ ("periods" ,sbcl-periods)))
+ (synopsis "Commoditized amounts and balances for Common Lisp")
(description
- "EASY-ROUTES is yet another routes handling system on top of
-Hunchentoot. It's just glue code for Restas routing subsystem (CL-ROUTES).
-
-It supports:
-@itemize
-@item dispatch based on HTTP method
-@item arguments extraction from the url path
-@item decorators
-@item URL generation from route names
-@end itemize
+ "CAMBL is a Common Lisp library providing a convenient facility for
+working with commoditized values. It does not allow compound units (and so is
+not suited for scientific operations) but does work rather nicely for the
+purpose of financial calculations.")
+ (home-page "https://github.com/jwiegley/cambl";)
+ (license license:bsd-3))))
-This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS
-systems.")
- (license license:expat))))
+(define-public cl-cambl
+ (sbcl-package->cl-source-package sbcl-cambl))
-(define-public cl-easy-routes
- (sbcl-package->cl-source-package sbcl-easy-routes))
+(define-public ecl-cambl
+ (sbcl-package->ecl-package sbcl-cambl))
-(define-public ecl-easy-routes
- (sbcl-package->ecl-package sbcl-easy-routes))
+(define-public sbcl-canonicalized-initargs
+ (package
+ (name "sbcl-canonicalized-initargs")
+ (version "2.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/canonicalized-initargs";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-canonicalized-initargs" version))
+ (sha256
+ (base32 "0jmmjw86x9mmlfla4kdmdqf1fjrj0p2fmv1lc4k555mcf67mj2fq"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-cesdi
+ sbcl-closer-mop
+ sbcl-compatible-metaclasses
+ sbcl-enhanced-defclass
+ sbcl-enhanced-typep))
+ (home-page
+ "https://www.hexstreamsoft.com/libraries/canonicalized-initargs/";)
+ (synopsis "Standard way to canonicalize slot values")
+ (description
+ "This package provides a standard way to canonicalize slot values.")
+ (license license:unlicense)))
-(define-public sbcl-jpl-util
- (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
+(define-public cl-canonicalized-initargs
+ (sbcl-package->cl-source-package sbcl-canonicalized-initargs))
+
+(define-public ecl-canonicalized-initargs
+ (sbcl-package->ecl-package sbcl-canonicalized-initargs))
+
+(define-public sbcl-caveman
+ (let ((commit "35cd8bc6c322f9d88498405fc26168a1fb42ae1c") ; No release since
2012
+ (revision "2"))
(package
- (name "sbcl-jpl-util")
- (version "20151005")
+ (name "sbcl-caveman")
+ (version (git-version "2.4.0" revision commit))
+ (home-page "https://8arrow.org/caveman/";)
(source
(origin
(method git-fetch)
(uri (git-reference
- ;; Quicklisp uses this fork.
- (url "https://github.com/hawkir/cl-jpl-util";)
+ (url "https://github.com/fukamachi/caveman/";)
(commit commit)))
- (file-name
- (git-file-name "jpl-util" version))
+ (file-name (git-file-name "cl-caveman" version))
(sha256
- (base32
- "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
+ (base32 "1wvjm9m1fnapg0r9imhhcwgnhhqkkccnj3c0iw9yg1f72d7zhm2w"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Collection of Common Lisp utility functions and macros")
- (description
- "@command{cl-jpl-util} is a collection of Common Lisp utility functions
-and macros, primarily for software projects written in CL by the author.")
- (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/";)
- (license license:isc))))
+ (inputs
+ `(("ningle" ,cl-ningle)
+ ("lack" ,sbcl-lack)
+ ("cl-project" ,sbcl-cl-project)
+ ("dbi" ,sbcl-dbi)
+ ("sxql" ,sbcl-sxql)
+ ("cl-syntax" ,sbcl-cl-syntax)
+ ("myway" ,sbcl-myway)
+ ("quri" ,sbcl-quri)))
+ (native-inputs
+ `(("usocket" ,sbcl-usocket)
+ ("dexador" ,sbcl-dexador)
+ ("lack" ,sbcl-lack)
+ ("trivial-types" ,sbcl-trivial-types)
+ ("prove" ,sbcl-prove)))
+ (arguments
+ `(#:asd-systems '("caveman2"
+ "caveman2-db"
+ "caveman2-test"
+ "caveman-middleware-dbimanager")
+ ;; TODO: Tests fail with:
+ ;; writing
/gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
+ ;; While evaluating the form starting at line 38, column 0
+ ;; of
#P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
+ ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread
#<SB-THREAD:THREAD "main thread" RUNNING
+ ;;
{10009F8083}>:
+ ;; Component "myapp573" not found
+ ;;
+ ;; The above myapp573 component name is randomly generated by
+ ;; gensym on each test run. `(asdf:load-system *app-name*)` tries
+ ;; to load this component and fails.
+ ;; TODO: Ask fukamachi how to go around this.
+ #:tests? #f))
+ (synopsis "Lightweight web application framework in Common Lisp")
+ (description "Caveman is intended to be a collection of common parts for
+web applications. Caveman2 has three design goals:
-(define-public cl-jpl-util
- (sbcl-package->cl-source-package sbcl-jpl-util))
+@itemize
+@item Be extensible.
+@item Be practical.
+@item Don't force anything.
+@end itemize\n")
+ (license license:llgpl))))
-(define-public ecl-jpl-util
- (sbcl-package->ecl-package sbcl-jpl-util))
+(define-public cl-caveman
+ (package
+ (inherit
+ (sbcl-package->cl-source-package sbcl-caveman))
+ (propagated-inputs
+ `(("ningle" ,cl-ningle)))))
-(define-public sbcl-piping
- (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656")
- (revision "1"))
+(define-public ecl-caveman
+ (sbcl-package->ecl-package sbcl-caveman))
+
+(define-public sbcl-cells
+ (let ((commit "e8542b17fddd6340c1e237ce482a52327c8ead8e"))
(package
- (name "sbcl-piping")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-cells")
+ (version (git-version "3.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/piping/";)
+ (url "https://github.com/kennytilton/cells";)
(commit commit)))
- (file-name (git-file-name "piping" version))
+ (file-name (git-file-name "cl-cells" version))
(sha256
- (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5"))))
+ (base32 "0rkzvwq38lwb1045w54kw020pb9i63hxiawwhqkf8k1inhak3fdk"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://shinmera.github.io/piping/";)
- (synopsis "Library to enable simple message pipelines")
+ (inputs
+ (list sbcl-utils-kt))
+ (arguments
+ ;; Tests fail with #<TYPE-ERROR expected-type: STREAM datum: NIL>.
+ '(#:tests? #f))
+ (home-page "https://github.com/kennytilton/cells";)
+ (synopsis "Common Lisp implementation of the dataflow programming
paradigm")
(description
- "This is a Common Lisp library to enable simple message pipelines.")
- (license license:zlib))))
+ "Cells is a mature, stable extension to CLOS allowing one to create
+classes whose instances can have slot values determined by instance-specific
+formulas.")
+ (license license:llgpl))))
-(define-public ecl-piping
- (sbcl-package->ecl-package sbcl-piping))
+(define-public cl-cells
+ (sbcl-package->cl-source-package sbcl-cells))
-(define-public cl-piping
- (sbcl-package->cl-source-package sbcl-piping))
+(define-public ecl-cells
+ (sbcl-package->ecl-package sbcl-cells))
-(define-public sbcl-bobbin
- (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce")
+(define-public sbcl-cephes
+ (let ((commit "d87146fa38c8425ffb5fe425eee5eb3e818bacd4")
(revision "0"))
(package
- (name "sbcl-bobbin")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-cephes")
+ (version (git-version "1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sjl/bobbin";)
+ (url "https://github.com/Lisp-Stat/cephes.cl";)
(commit commit)))
- (file-name (git-file-name "cl-bobbin" version))
+ (file-name (git-file-name "cl-cephes" version))
(sha256
- (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm"))))
+ (base32 "09adls1lwwzwm1jmvhf11arwlsy5w0bi2rmniahas824mysv77lr"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-1am))
(inputs
- (list sbcl-split-sequence))
- (home-page "https://docs.stevelosh.com/bobbin/";)
- (synopsis "Simple (word) wrapping utilities for strings")
+ (list sbcl-cffi))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ ;; ECL has issues making the shared library automatically,
+ ;; so we make it explicitly.
+ (add-before 'build 'build-shared-library
+ (lambda _
+ (with-directory-excursion
+ (string-append #$output "/share/common-lisp/"
+ (%lisp-type) "/cephes/scipy-cephes")
+ (invoke "make")
+ ;; Remove temporary object files.
+ (for-each delete-file (find-files "." "\\.o$"))))))))
+ (home-page "https://lisp-stat.github.io/cephes.cl/";)
+ (synopsis "Common Lisp wrapper for the Cephes Mathematical Library")
(description
- "Bobbin is a simple word-wrapping library for strings in Common Lisp.
-It aims to be simple, work nicely for the majority of cases, and degrade
-gracefully for edge cases. It is not particularly concerned with speed — if
-you need very high-performance word wrapping, Bobbin is not for you.")
- (license license:expat))))
+ "This package provides a common lisp CFFI wrapper for the SciPy version
+of Cephes special functions.")
+ (license license:ms-pl))))
-(define-public cl-bobbin
- (sbcl-package->cl-source-package sbcl-bobbin))
+(define-public cl-cephes
+ (sbcl-package->cl-source-package sbcl-cephes))
-(define-public ecl-bobbin
- (sbcl-package->ecl-package sbcl-bobbin))
+(define-public ecl-cephes
+ (sbcl-package->ecl-package sbcl-cephes))
-(define-public sbcl-cl-pcg
- (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f")
+(define-public sbcl-cepl
+ (let ((commit "d1a10b6c8f4cedc07493bf06aef3a56c7b6f8d5b")
(revision "1"))
(package
- (name "sbcl-cl-pcg")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sjl/cl-pcg";)
- (commit commit)))
- (file-name (git-file-name "cl-pcg" version))
- (sha256
- (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-1am))
- (home-page "https://github.com/sjl/cl-pcg";)
- (synopsis "Permuted congruential generators in Common Lisp")
- (description
- "This is a bare-bones Permuted Congruential Generator implementation in
-pure Common Lisp.")
- (license license:expat))))
-
-(define-public ecl-cl-pcg
- (let ((pkg (sbcl-package->ecl-package sbcl-cl-pcg)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; Tests are failing on ECL with:
- ;; PCG.TEST::TEST-REWINDAn error occurred during initialization:
- ;; 40502229875678917802724098623316930025 is not of type
- ;; (INTEGER 0 2305843009213693951)
- ((#:tests? _ #f) #f))))))
+ (name "sbcl-cepl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cbaggers/cepl";)
+ (commit commit)))
+ (file-name (git-file-name "cepl" version))
+ (sha256
+ (base32 "0izbw2advqm3wailj3dpq6zqfrfirwn14pw5qmqh8i71r51xwmm2"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-opengl" ,sbcl-cl-opengl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("float-features" ,sbcl-float-features)
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("varjo" ,sbcl-varjo)))
+ (propagated-inputs
+ (list sbcl-quickproject))
+ (home-page "https://github.com/cbaggers/cepl";)
+ (synopsis "Development playground to work with OpenGL")
+ (description
+ "CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp
+library for working with OpenGL.
-(define-public cl-pcg
- (sbcl-package->cl-source-package sbcl-cl-pcg))
+Its definition of success is making the user feel that GPU programming has
+always been part of the languages standard.
-(define-public sbcl-seedable-rng
- (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15")
- (revision "1"))
- (package
- (name "sbcl-seedable-rng")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://git.mfiano.net/mfiano/seedable-rng";)
- (commit commit)))
- (file-name (git-file-name "seedable-rng" version))
- (sha256
- (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-pcg sbcl-golden-utils sbcl-ironclad))
- (home-page "https://git.mfiano.net/mfiano/seedable-rng";)
- (synopsis "Common Lisp random number generator")
- (description
- "SEEDABLE-RNG provides a convenient means of generating random numbers
-that are seedable with deterministic results across hardware and Common Lisp
-implementations.")
- (license license:expat))))
+The usual approach to using CEPL is to start it at the beginning of your Lisp
+session and leave it open for the duration of your work. You can then treat
the
+window it creates as just another output for your graphics, analogous to how
+@code{*standard-output*} is treated for text.")
+ (license license:bsd-2))))
-(define-public ecl-seedable-rng
- (sbcl-package->ecl-package sbcl-seedable-rng))
+(define-public cl-cepl
+ (sbcl-package->cl-source-package sbcl-cepl))
-(define-public cl-seedable-rng
- (sbcl-package->cl-source-package sbcl-seedable-rng))
+(define-public ecl-cepl
+ (sbcl-package->ecl-package sbcl-cepl))
-(define-public sbcl-jpl-queues
+(define-public sbcl-cesdi
(package
- (name "sbcl-jpl-queues")
- (version "0.1")
+ (name "sbcl-cesdi")
+ (version "1.0.1")
(source
(origin
- (method url-fetch)
- (uri (string-append
- "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-";
- version
- ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/cesdi";)
+ (commit version)))
+ (file-name (git-file-name "cl-cesdi" version))
(sha256
- (base32
- "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
+ (base32 "02f2pz5rw79ljkkx1ywh8nkpjj4g3z3s1lyvzqb8krbnx11wl0q9"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- `(("jpl-util" ,sbcl-jpl-util)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- ;; Tests seem to be broken.
- `(#:tests? #f))
- (synopsis "Common Lisp library implementing a few different kinds of
queues")
+ (list sbcl-closer-mop))
+ (home-page "https://www.hexstreamsoft.com/libraries/cesdi/";)
+ (synopsis "Ergonomic initialization of effective slot definition objects")
(description
- "A Common Lisp library implementing a few different kinds of queues:
-
-@itemize
-@item Bounded and unbounded FIFO queues.
-@item Lossy bounded FIFO queues that drop elements when full.
-@item Unbounded random-order queues that use less memory than unbounded FIFO
queues.
-@end itemize
-
-Additionally, a synchronization wrapper is provided to make any queue
-conforming to the @command{jpl-queues} API thread-safe for lightweight
-multithreading applications. (See Calispel for a more sophisticated CL
-multithreaded message-passing library with timeouts and alternation among
-several blockable channels.)")
- (home-page "https://www.thoughtcrime.us/software/jpl-queues/";)
- (license license:isc)))
+ "This package provides a @code{compute-effective-slot-definition-initargs}
+generic function that allows for more ergonomic initialization of effective
slot
+definition objects.")
+ (license license:unlicense)))
-(define-public cl-jpl-queues
- (sbcl-package->cl-source-package sbcl-jpl-queues))
+(define-public cl-cesdi
+ (sbcl-package->cl-source-package sbcl-cesdi))
-(define-public ecl-jpl-queues
- (sbcl-package->ecl-package sbcl-jpl-queues))
+(define-public ecl-cesdi
+ (sbcl-package->ecl-package sbcl-cesdi))
-(define-public sbcl-calispel
- (let ((commit "e9f2f9c1af97f4d7bb4c8ac25fb2a8f3e8fada7a"))
+(define-public sbcl-cf
+ (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e")
+ (revision "2"))
(package
- (name "sbcl-calispel")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-cf")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- ;; This fork replaces the dependency on the obsolete
- ;; eager-future with eager-future2.
- (url "https://github.com/hawkir/calispel";)
+ (url "https://codeberg.org/glv/cl-cf";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-cf" version))
(sha256
- (base32
- "08bmf3pi7n5hadpmqqkg65cxcj6kbvm997wcs1f53ml1nb79d9z8"))))
+ (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-jpl-queues sbcl-bordeaux-threads))
- (native-inputs
- (list sbcl-eager-future2))
- (synopsis "Thread-safe message-passing channels in Common Lisp")
- (description
- "Calispel is a Common Lisp library for thread-safe message-passing
-channels, in the style of the occam programming language, also known as
-communicating sequential processes (CSP). See
-@url{https://en.wikipedia.org/wiki/Communicating_sequential_processes}.
-
-Calispel channels let one thread communicate with another, facilitating
-unidirectional communication of any Lisp object. Channels may be unbuffered,
-where a sender waits for a receiver (or vice versa) before either operation can
-continue, or channels may be buffered with flexible policy options.
-
-Because sending and receiving on a channel may block, either operation can time
-out after a specified amount of time.
-
-A syntax for alternation is provided (like @code{ALT} in occam, or Unix
-@code{select()}): given a sequence of operations, any or all of which may
-block, alternation selects the first operation that doesn't block and executes
-associated code. Alternation can also time out, executing an \"otherwise\"
-clause if no operation becomes available within a set amount of time.
-
-Calispel is a message-passing library, and as such leaves the role of
-threading abstractions and utilities left to be filled by complementary
-libraries such as Bordeaux-Threads and Eager Future.")
- (home-page "https://www.thoughtcrime.us/software/calispel/";)
- (license license:isc))))
-
-(define-public cl-calispel
- (sbcl-package->cl-source-package sbcl-calispel))
-
-(define-public ecl-calispel
- (sbcl-package->ecl-package sbcl-calispel))
-
-(define-public sbcl-calm
- (package
- (name "sbcl-calm")
- (version "0.0.35")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/VitoVan/calm";)
- (commit version)))
- (file-name (git-file-name "cl-calm" version))
- (sha256
- (base32 "1k1kwpiq7ikk1mgfi26sd968d623jl6xffngd9vwswnaiwihk4dp"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-cairo2
- sbcl-cl-str
- sbcl-sdl2
- sbcl-sdl2-image
- sbcl-sdl2-mixer
- sbcl-slime-swank))
- (home-page "https://github.com/VitoVan/calm";)
- (synopsis "Vector graphic library for Common Lisp")
- (description
- "This package provides a SDL2 based vector graphic library for Common
-Lisp.")
- (license license:gpl2)))
+ (native-inputs (list sbcl-fiveam))
+ (synopsis "Continued fractions library")
+ (description "CF is a Common Lisp library for doing computations using
+continued fractions.")
+ (home-page "https://codeberg.org/glv/cl-cf";)
+ (license license:gpl3+))))
-(define-public cl-calm
- (sbcl-package->cl-source-package sbcl-calm))
+(define-public cl-cf
+ (sbcl-package->cl-source-package sbcl-cf))
-(define-public ecl-calm
- (sbcl-package->ecl-package sbcl-calm))
+(define-public ecl-cf
+ (sbcl-package->ecl-package sbcl-cf))
-(define-public sbcl-esrap
- (let ((commit "d806138342a6b27327649fd5f36e0fe2e0966867")
- (revision "4"))
+(define-public sbcl-cffi
+ (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112")
+ (revision "1"))
(package
- (name "sbcl-esrap")
- (version (git-version "0.18" revision commit))
+ (name "sbcl-cffi")
+ (version (git-version "0.24.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/scymtym/esrap";)
+ (url "https://github.com/cffi/cffi";)
(commit commit)))
- (file-name (git-file-name "cl-esrap" version))
+ (file-name (git-file-name "cl-cffi" version))
(sha256
- (base32 "0gs0mfamldhaihnlk0qxg2q4bl8bamq68dif9js9fkl8apg3iykl"))))
+ (base32 "1h7cw15f08gm6m4yz8hk7qkfwp7mwwnykjc5py6dhjakv0wh1g37"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-alexandria sbcl-trivial-with-current-source-form))
- (synopsis "Common Lisp packrat parser")
- (description
- "This is a packrat parser for Common Lisp.
-In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP
supports:
-
-@itemize
-@item dynamic redefinition of nonterminals
-@item inline grammars
-@item semantic predicates
-@item introspective facilities (describing grammars, tracing, setting breaks)
-@item left-recursive grammars
-@item functions as terminals
-@item accurate, customizable parse error reports
-@end itemize\n")
- (home-page "https://scymtym.github.io/esrap/";)
+ (list libffi
+ sbcl-alexandria
+ sbcl-babel
+ sbcl-trivial-features))
+ (native-inputs
+ (list pkg-config
+ sbcl-bordeaux-threads
+ sbcl-rt))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "libffi/libffi.lisp"
+ (("libffi.so.8" all)
+ (search-input-file inputs (string-append "/lib/"
all))))
+ (substitute* "toolchain/c-toolchain.lisp"
+ (("\"cc\"")
+ (format #f "~S" (which "gcc"))))))
+ (add-after 'build 'install-headers
+ (lambda _
+ (install-file "grovel/common.h"
+ (string-append #$output
+ "/include/grovel")))))
+ #:asd-systems ''("cffi"
+ "cffi-libffi"
+ "cffi-uffi-compat")))
+ (home-page "https://common-lisp.net/project/cffi/";)
+ (synopsis "Common Foreign Function Interface for Common Lisp")
+ (description "The Common Foreign Function Interface (CFFI)
+purports to be a portable foreign function interface for Common Lisp.
+The CFFI library is composed of a Lisp-implementation-specific backend
+in the CFFI-SYS package, and a portable frontend in the CFFI
+package.")
(license license:expat))))
-(define-public cl-esrap
- (sbcl-package->cl-source-package sbcl-esrap))
-
-(define-public ecl-esrap
- (sbcl-package->ecl-package sbcl-esrap))
-
-(define-public sbcl-split-sequence
- (package
- (name "sbcl-split-sequence")
- (version "2.0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/split-sequence";)
- (commit (string-append "v" version))))
- (sha256
- (base32
- "172k7iv775kwism6304p6z7mqpjvipl57nq1bgvmbk445943fmhq"))
- (file-name (git-file-name "split-sequence" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "Member of the Common Lisp Utilities family of programs")
- (description
- "Splits sequence into a list of subsequences delimited by objects
-satisfying the test.")
- (home-page "https://cliki.net/split-sequence";)
- (license license:expat)))
-
-(define-public cl-split-sequence
- (sbcl-package->cl-source-package sbcl-split-sequence))
-
-(define-public ecl-split-sequence
- (sbcl-package->ecl-package sbcl-split-sequence))
-
-(define-public sbcl-html-encode
- (package
- (name "sbcl-html-encode")
- (version "1.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
-
"http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-";
- version ".tgz"))
- (sha256
- (base32
- "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp library for encoding text in various web-savvy
encodings")
- (description
- "A library for encoding text in various web-savvy encodings.")
- (home-page "https://quickdocs.org/html-encode/";)
- (license license:expat)))
-
-(define-public cl-html-encode
- (sbcl-package->cl-source-package sbcl-html-encode))
-
-(define-public ecl-html-encode
- (sbcl-package->ecl-package sbcl-html-encode))
-
-(define-public sbcl-colorize
- (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
- (package
- (name "sbcl-colorize")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/kingcons/colorize";)
- (commit commit)))
- (sha256
- (base32
- "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
- (file-name (git-file-name "colorize" version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-split-sequence sbcl-html-encode))
- (synopsis "Common Lisp for syntax highlighting")
- (description
- "@command{colorize} is a Lisp library for syntax highlighting
-supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
-C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
- (home-page "https://github.com/kingcons/colorize";)
- ;; TODO: Missing license?
- (license license:expat))))
+(define-public cl-cffi
+ (sbcl-package->cl-source-package sbcl-cffi))
-(define-public cl-colorize
- (sbcl-package->cl-source-package sbcl-colorize))
+(define-public ecl-cffi
+ (sbcl-package->ecl-package sbcl-cffi))
-(define-public ecl-colorize
- (sbcl-package->ecl-package sbcl-colorize))
-(define-public sbcl-3bmd
- (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5")
- (revision "4"))
+(define-public sbcl-cffi-c-ref
+ (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce")
+ (revision "0"))
(package
- (name "sbcl-3bmd")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cffi-c-ref")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/3bmd";)
+ (url "https://github.com/borodust/cffi-c-ref";)
(commit commit)))
(sha256
- (base32 "12xqih1gnwsn1baqm7bq3kxss73phn06gvd0v1h1vwsjd1xgpq3g"))
- (file-name (git-file-name "cl-3bmd" version))))
+ (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z"))
+ (file-name (git-file-name "cffi-c-ref" version))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems
- '("3bmd"
- "3bmd-ext-definition-lists"
- "3bmd-ext-math"
- "3bmd-ext-tables"
- "3bmd-ext-wiki-links"
- "3bmd-youtube"
- "3bmd-ext-code-blocks")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-python3-path
- (lambda _
- (substitute* "code-blocks.lisp"
- (("python3") (which "python3"))))))))
- (native-inputs
- (list sbcl-fiasco))
(inputs
- (list python
- python-pygments
- sbcl-alexandria
- sbcl-colorize
- sbcl-split-sequence
- sbcl-esrap))
- (home-page "https://github.com/3b/3bmd";)
- (synopsis "Markdown processor in Command Lisp using esrap parser")
+ (list sbcl-alexandria sbcl-cffi))
+ (synopsis "Streamlined access to foreign memory")
(description
- "This is a Common Lisp Markdown to HTML converter, using @command{esrap}
-for parsing, and grammar based on @command{peg-markdown}.")
+ "This Common Lisp library provides macros to access foreign memory.")
+ (home-page "https://github.com/borodust/cffi-c-ref";)
(license license:expat))))
-(define-public cl-3bmd
- (sbcl-package->cl-source-package sbcl-3bmd))
+(define-public cl-cffi-c-ref
+ (sbcl-package->cl-source-package sbcl-cffi-c-ref))
-(define-public ecl-3bmd
- (sbcl-package->ecl-package sbcl-3bmd))
+(define-public ecl-cffi-c-ref
+ (sbcl-package->ecl-package sbcl-cffi-c-ref))
-(define-public sbcl-cl-fad
- ;; No release since 2019
- (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535")
+(define-public sbcl-chanl
+ (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
(revision "1"))
(package
- (name "sbcl-cl-fad")
- (version (git-version "0.7.6" revision commit))
+ (name "sbcl-chanl")
+ (version (git-version "0.4.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/cl-fad/";)
+ (url "https://github.com/zkat/chanl";)
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0a1xqldrq170lflnns3xp6swpnvsvllf5vq0h7sz8jqh4riqlny6"))
- (file-name (git-file-name "cl-fad" version))))
+ (base32
+ "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-cl-ppcre sbcl-unit-test))
+ (list sbcl-fiveam))
(inputs
- (list sbcl-alexandria sbcl-bordeaux-threads))
- (synopsis "Portable pathname library for Common Lisp")
- (description
- "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
-Lisp's standard pathname functions. It is intended to provide some
-unification between current CL implementations on Windows, OS X, Linux, and
-Unix. Most of the code was written by Peter Seibel for his book Practical
-Common Lisp.")
- (home-page "https://edicl.github.io/cl-fad/";)
- (license license:bsd-2))))
+ (list sbcl-bordeaux-threads))
+ (synopsis "Portable channel-based concurrency for Common Lisp")
+ (description "Common Lisp library for channel-based concurrency. In
+a nutshell, you create various threads sequentially executing tasks you need
+done, and use channel objects to communicate and synchronize the state of these
+threads.")
+ (home-page "https://github.com/zkat/chanl";)
+ (license (list license:expat license:bsd-3)))))
-(define-public cl-fad
- (sbcl-package->cl-source-package sbcl-cl-fad))
+(define-public cl-chanl
+ (sbcl-package->cl-source-package sbcl-chanl))
-(define-public ecl-cl-fad
- (sbcl-package->ecl-package sbcl-cl-fad))
+(define-public ecl-chanl
+ (sbcl-package->ecl-package sbcl-chanl))
-(define-public sbcl-fn
- (let ((commit "8d8587d03a7b5e26b306fc90018e385d9e5acc2c")
- (revision "1"))
- (package
- (name "sbcl-fn")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cbaggers/fn";)
- (commit commit)))
- (file-name (git-file-name "fn" version))
- (sha256
- (base32 "0yyp9z6iwx476whz0n1rpjznjyqqhlylhzwpgg5xx92lxmskl752"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-named-readtables))
- (home-page "https://github.com/cbaggers/fn";)
- (synopsis "Macros for lambda brevity")
- (description
- "This is a Common Lisp library providing lambda shorthand macros aiming
-to be used in cases where the word @emph{lambda} and the arguments are longer
-than the body of the lambda.")
- (license license:public-domain))))
-
-(define-public ecl-fn
- (sbcl-package->ecl-package sbcl-fn))
-
-(define-public cl-fn
- (sbcl-package->cl-source-package sbcl-fn))
-
-(define-public sbcl-nibbles
- ;; No tagged release since 2018.
- (let ((commit "a46a67736e07b548cdd7485cb36834f7942313f1")
- (revision "3"))
- (package
- (name "sbcl-nibbles")
- (version (git-version "0.14" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/nibbles/";)
- (commit commit)))
- (file-name (git-file-name "cl-nibbles" version))
- (sha256
- (base32 "12qjich11hp31dhbvbsixyjbddmr6faaajigrivgbxy9kw6d279j"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- ;; Tests only.
- (list sbcl-rt))
- (synopsis
- "Common Lisp library for accessing octet-addressed blocks of data")
- (description
- "When dealing with network protocols and file formats, it's common to
-have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
-flavors. Common Lisp sort of supports this by specifying :element-type for
-streams, but that facility is underspecified and there's nothing similar for
-read/write from octet vectors. What most people wind up doing is rolling their
-own small facility for their particular needs and calling it a day.
-
-This library attempts to be comprehensive and centralize such
-facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
-vectors in signed or unsigned flavors are provided; these functions are also
-SETFable. Since it's sometimes desirable to read/write directly from streams,
-functions for doing so are also provided. On some implementations,
-reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
-also be supported.")
- (home-page "https://github.com/sharplispers/nibbles";)
- (license license:bsd-3))))
+(define-public sbcl-charje.documentation
+ (package
+ (name "sbcl-charje.documentation")
+ (version "0.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.sr.ht/~charje/documentation";)
+ (commit (string-append "v" version))))
+ (sha256
+ (base32
+ "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc"))
+ (file-name (git-file-name "cl-charje.documentation" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://git.sr.ht/~charje/documentation";)
+ (synopsis "Docstring parsing library for Common Lisp")
+ (description "Charje.documentation can used to parse Common Lisp
+docstrings the charje way, or it can be used to create custom docstring
+parsers. Docstring parsers are composed using mixin classes and
+initialization methods.")
+ (license license:agpl3+)))
-(define-public cl-nibbles
- (sbcl-package->cl-source-package sbcl-nibbles))
+(define-public cl-charje.documentation
+ (sbcl-package->cl-source-package sbcl-charje.documentation))
-(define-public ecl-nibbles
- (sbcl-package->ecl-package sbcl-nibbles))
+(define-public ecl-charje.documentation
+ (sbcl-package->ecl-package sbcl-charje.documentation))
-(define-public sbcl-ironclad
+(define-public sbcl-charje.loop
(package
- (name "sbcl-ironclad")
- (version "0.60")
+ (name "sbcl-charje.loop")
+ (version "0.0.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/ironclad/";)
+ (url "https://git.sr.ht/~charje/loop";)
(commit (string-append "v" version))))
+ (file-name (git-file-name "cl-charje.loop" version))
(sha256
- (base32 "122ldxiddkscb3li5wjrppr7vyn77znyjfgs8pbflrskzyxlabdd"))
- (file-name (git-file-name "cl-ironclad" version))))
+ (base32
+ "1x1hw5xmrx9xmfzga8y0yi6s27r7zc80rwl2z7l4d2h24ykscvd4"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- ;; Tests only.
- (list sbcl-rt))
(inputs
- (list sbcl-bordeaux-threads sbcl-flexi-streams))
- (synopsis "Cryptographic toolkit written in Common Lisp")
- (description
- "Ironclad is a cryptography library written entirely in Common Lisp.
-It includes support for several popular ciphers, digests, MACs and public key
-cryptography algorithms. For several implementations that support Gray
-streams, support is included for convenient stream wrappers.")
- (home-page "https://github.com/sharplispers/ironclad";)
- (license license:bsd-3)))
+ (list sbcl-alexandria
+ sbcl-binding-arrows
+ sbcl-parse-declarations))
+ (home-page "https://git.sr.ht/~charje/loop";)
+ (synopsis "Loop abstraction for Common Lisp that is consistent for
+different kinds of data")
+ (description "Loop is a joy to use and has a consistent interface unlike
+other looping abstractions and ANSI list operations. You can define your own
+iterators and aggregators that integrate tightly into other operations. All
+operations are non-consing when possible.")
+ (license license:agpl3+)))
-(define-public cl-ironclad
- (sbcl-package->cl-source-package sbcl-ironclad))
+(define-public cl-charje.loop
+ (sbcl-package->cl-source-package sbcl-charje.loop))
-(define-public ecl-ironclad
- (sbcl-package->ecl-package sbcl-ironclad))
+(define-public ecl-charje.loop
+ (sbcl-package->ecl-package sbcl-charje.loop))
-(define-public sbcl-named-readtables
- (let ((commit "d5ff162ce02035ec7de1acc9721385f325e928c0")
- (revision "4"))
- (package
- (name "sbcl-named-readtables")
- (version (git-version "0.9" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/melisgl/named-readtables";)
- (commit commit)))
- (sha256
- (base32 "0gfgxywzbmavy0kpnxav11vz10qfzxwwrpgqaak9sgzg17g8x5yv"))
- (file-name (git-file-name "cl-named-readtables" version))))
- (build-system asdf-build-system/sbcl)
- ;; (native-inputs (list sbcl-try))
- ;; Tests disabled because of a circular dependency issue:
- ;; try -> named-readtables -> mgl-pax -> try
- (arguments
- (list #:tests? #f))
- (home-page "https://github.com/melisgl/named-readtables/";)
- (synopsis "Library that creates a namespace for named readtables")
- (description
- "Named readtables is a library that creates a namespace for named
-readtables, which is akin to package namespacing in Common Lisp.")
- (license license:bsd-3))))
+(define-public sbcl-chemboy
+ (package
+ (name "sbcl-chemboy")
+ (version "0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://common-lisp.net/project/chemboy/chemboy-";
+ version ".tar.gz"))
+ (sha256
+ (base32 "0lr134l16mjcgdj3fm2yff4chlfbihn1sji7q80y7lnr176zgs7d"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("chemical-compounds" ,sbcl-chemical-compounds)
+ ("periodic-table" ,sbcl-periodic-table)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-files
+ (lambda _
+ ;; Fix incorrect version number.
+ (substitute* "chemboy.asd"
+ ((":version \"0.2\"")
+ (string-append ":version \"" ,version "\"")))
+ ;; Remove incorrect declaration of string type.
+ (substitute* "query-parsing.lisp"
+ (("\\(declare \\(simple-base-string string\\)")
+ "(declare"))
+ ;; Fix incorrect function calls.
+ (substitute* "conversions.lisp"
+ (("\\(pprint-compound element s\\)")
+ "(pprint-compound element :stream s)")
+ (("\\(pprint-compound parsed-compound s\\)")
+ "(pprint-compound parsed-compound :stream s)")))))))
+ (home-page "https://common-lisp.net/project/chemboy/";)
+ (synopsis "Common Lisp program for doing basic chemistry calculations")
+ (description
+ "Chemboy is a Common Lisp program for doing basic chemistry calculations.
+This package provides the text-based interface for Chemboy.")
+ (license license:llgpl)))
-(define-public cl-named-readtables
- (sbcl-package->cl-source-package sbcl-named-readtables))
+(define-public cl-chemboy
+ (sbcl-package->cl-source-package sbcl-chemboy))
-(define-public ecl-named-readtables
- (sbcl-package->ecl-package sbcl-named-readtables))
+(define-public ecl-chemboy
+ (sbcl-package->ecl-package sbcl-chemboy))
-(define-public sbcl-py-configparser
- ;; NOTE: (Sharlatan <2021-01-05 Tue> <19:52:19 UTC+0000>) Project updated
last
- ;; time 8y ago, it looks like abandoned. VCS of the project:
- ;; https://svn.common-lisp.net/py-configparser/trunk
+(define-public sbcl-chemical-compounds
(package
- (name "sbcl-py-configparser")
- (version "1.0.3")
+ (name "sbcl-chemical-compounds")
+ (version "1.0.2")
(source
(origin
(method url-fetch)
(uri (string-append
- "https://common-lisp.net/project/py-configparser/releases/";
- "py-configparser-" version ".tar.gz"))
+ "https://common-lisp.net/project/chemboy/chemical-compounds-";
+ version ".tar.gz"))
(sha256
- (base32 "0i4rqz5cv7d7c2w81x5lwy05s6fbi3zikf4k5kpi3bkx3cabwdxj"))))
+ (base32 "12fd8a6ay5qlsq4givzgh9d55mbg4ci2vvmymig6pjl2ms64v0pf"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-parse-number))
- (home-page "https://common-lisp.net/project/py-configparser/";)
- (synopsis "ConfigParser Python module functionality for Common Lisp")
- (description "The py-configparser package implements the ConfigParser
-Python module functionality in Common Lisp. In short, it implements reading
-and writing of .INI-file style configuration files with sections containing
-key/value pairs of configuration options. In line with the functionalities in
-the python module, does this package implement basic interpolation of option
-values in other options.")
- (license license:expat)))
-
-(define-public cl-py-configparser
- (sbcl-package->cl-source-package sbcl-py-configparser))
+ `(("periodic-table" ,sbcl-periodic-table)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-files
+ (lambda _
+ ;; Fix incorrect version number.
+ (substitute* "chemical-compounds.asd"
+ ((":version \"1.0.1\"")
+ (string-append ":version \"" ,version "\"")))
+ ;; Remove incorrect declaration of string type.
+ (substitute* "parsing.lisp"
+ (("\\(declare \\(simple-base-string string\\)")
+ "(declare")))))))
+ (home-page "https://common-lisp.net/project/chemboy/";)
+ (synopsis "Chemical formula parser and pretty-printer for Common Lisp")
+ (description
+ "It can sometimes be useful to be able to parse chemical compounds in a
+user-friendly syntax into easy-to-manipulate s-expressions. You also want to
+be able to go in reverse. You could probably write your own parser — or you
+could just install the chemical-compounds package.")
+ (license license:llgpl)))
-(define-public ecl-py-configparser
- (sbcl-package->ecl-package sbcl-py-configparser))
+(define-public cl-chemical-compounds
+ (sbcl-package->cl-source-package sbcl-chemical-compounds))
-(define-public sbcl-cl-ini
- (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7")
- (revision "0"))
+(define-public ecl-chemical-compounds
+ (sbcl-package->ecl-package sbcl-chemical-compounds))
+
+(define-public sbcl-chipz
+ (let ((version "0.8")
+ (commit "82a17d39c78d91f6ea63a03aca8f9aa6069a5e11")
+ (revision "2"))
(package
- (name "sbcl-cl-ini")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-chipz")
+ (version (git-version version revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/compufox/cl-ini";)
+ (url "https://github.com/sharplispers/chipz";)
(commit commit)))
- (file-name (git-file-name "sbcl-cl-ini" version))
+ (file-name (git-file-name "cl-chipz" version))
(sha256
- (base32
- "12vy3gspqn0wmkyz5id1xrgv1scgb16m7pkvmbmi19vlpj2iyq7p"))))
+ (base32 "1n4f22i9j8iapjd6yx1z348rggcybvg9h794kx9libjgz4bs371h"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-prove))
- (inputs (list sbcl-cl-str))
- (home-page "https://github.com/compufox/cl-ini";)
- (synopsis "INI file parser for Common Lisp")
+ (native-inputs
+ (list sbcl-flexi-streams))
+ (home-page "http://method-combination.net/lisp/chipz/";)
+ (synopsis
+ "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
+data")
(description
- "Parse INI formatted files into a Common Lisp list structure.")
+ "DEFLATE data, defined in RFC1951, forms the core of popular
+compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
+Chipz also provides for decompressing data in those formats as well. BZIP2 is
+the format used by the popular compression tool bzip2.")
+ ;; The author describes it as "MIT-like"
(license license:expat))))
-(define-public cl-ini
- (sbcl-package->cl-source-package sbcl-cl-ini))
+(define-public cl-chipz
+ (sbcl-package->cl-source-package sbcl-chipz))
-(define-public ecl-cl-ini
- (sbcl-package->ecl-package sbcl-cl-ini))
+(define-public ecl-chipz
+ (sbcl-package->ecl-package sbcl-chipz))
-(define-public sbcl-pythonic-string-reader
- (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
+(define-public sbcl-chirp
+ (let ((commit "01c79fa41939688216d1f86d0766a687becb0654")
+ (revision "1"))
(package
- (name "sbcl-pythonic-string-reader")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-chirp")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/smithzvk/pythonic-string-reader/";)
+ (url "https://github.com/Shinmera/chirp";)
(commit commit)))
+ (file-name (git-file-name "chirp" version))
(sha256
- (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
- (file-name (git-file-name "pythonic-string-reader" version))))
+ (base32 "10xlz1vwdv3jv48kmpndpnrg6672m0r5vsjgm2pksfl8bc05j2m0"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("chirp-core" "chirp-dexador" "chirp-drakma" "chirp")))
(inputs
- (list sbcl-named-readtables))
- (home-page "https://github.com/smithzvk/pythonic-string-reader";)
- (synopsis "Read table modification inspired by Python's three quote
strings")
- (description "This piece of code sets up some reader macros that make it
-simpler to input string literals which contain backslashes and double quotes
-This is very useful for writing complicated docstrings and, as it turns out,
-writing code that contains string literals that contain code themselves.")
- (license license:bsd-3))))
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("cl-base64" ,sbcl-cl-base64)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("dexador" ,sbcl-dexador)
+ ("drakma" ,sbcl-drakma)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("ironclad" ,sbcl-ironclad)
+ ("local-time" ,sbcl-local-time)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("uuid" ,sbcl-uuid)
+ ("yason" ,sbcl-yason)))
+ (home-page "https://shinmera.github.io/chirp/";)
+ (synopsis "Twitter client library for Common Lisp")
+ (description
+ "This package provides a Common Lisp Twitter client featuring full API
+coverage.")
+ (license license:zlib))))
-(define-public cl-pythonic-string-reader
- (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
+(define-public cl-chirp
+ (sbcl-package->cl-source-package sbcl-chirp))
-(define-public ecl-pythonic-string-reader
- (sbcl-package->ecl-package sbcl-pythonic-string-reader))
+(define-public ecl-chirp
+ (sbcl-package->ecl-package sbcl-chirp))
-(define-public sbcl-slime-swank
- ;; Update together with emacs-slime.
+(define-public sbcl-chlorophyll
+ (let ((commit "f2a50ad36d2fb11823c0e5a8da08a0de89c5c35f")
+ (revision "1"))
+ (package
+ (name "sbcl-chlorophyll")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/gorozhin/chlorophyll";)
+ (commit commit)))
+ (file-name (git-file-name "cl-chlorophyll" version))
+ (sha256
+ (base32 "1hgl8sjsmyqx4gs77q4p94b63zgpxk1wi9w9niki8j0213dr1s3y"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiveam))
+ (inputs (list sbcl-alexandria))
+ (home-page "https://github.com/gorozhin/chlorophyll";)
+ (synopsis "ANSI escape code library for Common Lisp")
+ (description
+ "This package provides a Common Lisp system CHLOROPHYLL which
+implements an ANSI escape code functionality.")
+ (license license:expat))))
+
+(define-public cl-chlorophyll
+ (sbcl-package->cl-source-package sbcl-chlorophyll))
+
+(define-public ecl-chlorophyll
+ (sbcl-package->ecl-package sbcl-chlorophyll))
+
+(define-public sbcl-chronicity
(package
- (name "sbcl-slime-swank")
- (version "2.29.1")
+ (name "sbcl-chronicity")
+ (version "0.4.1")
(source
(origin
- (file-name (git-file-name "cl-slime-swank" version))
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slime/slime/";)
+ (url "https://github.com/chaitanyagupta/chronicity";)
(commit (string-append "v" version))))
+ (file-name (git-file-name "chronicity" version))
(sha256
- (base32 "1fcasqsdfwsphkfx1vd3r5mr89vgvzb9g2dbw82mc9lijg1mr1ki"))
- (modules '((guix build utils)))
- (snippet
- ;; The doc folder drags `gawk' into the closure. Doc is already
- ;; provided by emacs-slime.
- `(begin
- (delete-file-recursively "doc")
- #t))))
+ (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("swank" "swank/exts")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'set-fasl-directory
- (lambda* (#:key outputs #:allow-other-keys)
- (substitute* "swank-loader.lisp"
- (("\\(probe-file fasl\\)" all)
- ;; Do not try to delete Guix store files.
- (string-append
- all "\n"
- " (not (equal (subseq (pathname-directory fasl) 1 3)"
- " '(\"gnu\" \"store\"))) ; XXX: GUIX PATCH"))))))))
- (home-page "https://github.com/slime/slime";)
- (synopsis "Common Lisp Swank server")
+ (native-inputs
+ (list sbcl-lisp-unit))
+ (inputs
+ (list sbcl-cl-interpol sbcl-cl-ppcre sbcl-local-time))
+ (home-page "https://github.com/chaitanyagupta/chronicity";)
+ (synopsis "Natural language date and time parser for Common Lisp")
(description
- "This is only useful if you want to start a Swank server in a Lisp
-processes that doesn't run under Emacs. Lisp processes created by
-@command{M-x slime} automatically start the server.")
- (license (list license:gpl2+ license:public-domain))))
+ "CHRONICITY is Common Lisp natural language date and time parser inspired
+by Ruby's @code{Chronic}.")
+ (license license:bsd-3)))
-(define-public cl-slime-swank
- (sbcl-package->cl-source-package sbcl-slime-swank))
+(define-public ecl-chronicity
+ (sbcl-package->ecl-package sbcl-chronicity))
-(define-public ecl-slime-swank
- (sbcl-package->ecl-package sbcl-slime-swank))
+(define-public cl-chronicity
+ (sbcl-package->cl-source-package sbcl-chronicity))
-(define-public sbcl-mgl-pax
- (let ((commit "6782eb041c152721972420dfafa192692d16b7ce")
- (revision "1"))
+(define-public sbcl-chunga
+ (package
+ (name "sbcl-chunga")
+ (version "1.1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/chunga";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-trivial-gray-streams))
+ (home-page "https://edicl.github.io/chunga/";)
+ (synopsis "Portable chunked streams for Common Lisp")
+ (description
+ "Chunga implements streams capable of chunked encoding on demand as
+defined in RFC 2616.")
+ (license license:bsd-2)))
+
+(define-public cl-chunga
+ (sbcl-package->cl-source-package sbcl-chunga))
+
+(define-public ecl-chunga
+ (sbcl-package->ecl-package sbcl-chunga))
+
+(define-public sbcl-ciel
+ (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a")
+ (revision "0"))
(package
- (name "sbcl-mgl-pax")
- (version (git-version "0.3.0" revision commit))
+ (name "sbcl-ciel")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/melisgl/mgl-pax";)
+ (url "https://github.com/ciel-lang/CIEL";)
(commit commit)))
+ (file-name (git-file-name "ciel" version))
(sha256
- (base32 "0fjbzc2fn17m80lfsc8121sa0bk7fg42fqlwhm01sk1fj4s48pma"))
- (file-name (git-file-name "cl-mgl-pax" version))))
+ (base32 "1bwafbbsppxqvijf43dii55mpzrklh6faj2m5dhajg2f2m8qckgi"))))
(build-system asdf-build-system/sbcl)
- ;; (native-inputs
- ;; (list sbcl-try))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-3bmd
+ (list sbcl-access
sbcl-alexandria
- sbcl-colorize
- sbcl-md5
- sbcl-named-readtables
- sbcl-pythonic-string-reader
- sbcl-slime-swank
- sbcl-trivial-utf-8))
- (arguments
- `(#:asd-systems '("mgl-pax"
- "mgl-pax/navigate"
- "mgl-pax/document"
- "mgl-pax/transcribe")
- ;; Tests disabled because of a circular dependency
- ;; try -> mgl-pax -> try
- #:tests? #f))
- (synopsis "Exploratory programming environment and documentation
generator")
- (description
- "PAX provides an extremely poor man's Explorable Programming
-environment. Narrative primarily lives in so called sections that mix markdown
-docstrings with references to functions, variables, etc, all of which should
-probably have their own docstrings.
-
-The primary focus is on making code easily explorable by using SLIME's
-@command{M-.} (@command{slime-edit-definition}). See how to enable some
-fanciness in Emacs Integration. Generating documentation from sections and all
-the referenced items in Markdown or HTML format is also implemented.
-
-With the simplistic tools provided, one may accomplish similar effects as with
-Literate Programming, but documentation is generated from code, not vice versa
-and there is no support for chunking yet. Code is first, code must look
-pretty, documentation is code.")
- (home-page "https://melisgl.github.io/mgl-pax/";)
+ sbcl-arrow-macros
+ sbcl-bordeaux-threads
+ sbcl-cl-ansi-text
+ sbcl-cl-ansi-text
+ sbcl-cl-cron
+ sbcl-cl-csv
+ sbcl-cl-json-pointer
+ sbcl-cl-ppcre
+ sbcl-cl-punch
+ sbcl-cl-reexport
+ sbcl-cl-str
+ sbcl-clesh
+ sbcl-clingon
+ sbcl-closer-mop
+ sbcl-cmd
+ sbcl-dbi
+ sbcl-defstar
+ sbcl-deploy
+ sbcl-dexador
+ sbcl-dissect
+ sbcl-easy-routes
+ sbcl-file-notify
+ sbcl-fn
+ sbcl-for
+ sbcl-fset
+ sbcl-generic-cl
+ sbcl-hunchentoot
+ sbcl-local-time
+ sbcl-log4cl
+ sbcl-lparallel
+ sbcl-lquery
+ sbcl-metabang-bind
+ sbcl-modf
+ sbcl-named-readtables
+ sbcl-nodgui
+ sbcl-parse-float
+ sbcl-parse-number
+ sbcl-printv
+ sbcl-pythonic-string-reader
+ sbcl-quicksearch
+ sbcl-quri
+ sbcl-repl-utilities
+ sbcl-serapeum
+ sbcl-shasht
+ sbcl-shlex
+ sbcl-spinneret
+ sbcl-sxql
+ sbcl-trivia
+ sbcl-trivial-arguments
+ sbcl-trivial-do
+ sbcl-trivial-monitored-thread
+ sbcl-trivial-package-local-nicknames
+ sbcl-trivial-types
+ sbcl-vgplot
+ sbcl-which))
+ (home-page "http://ciel-lang.org/";)
+ (synopsis "CIEL Is an Extended Lisp")
+ (description
+ "CIEL is a ready-to-use collection of libraries providing: a binary, to
+run CIEL scripts; a simple full-featured REPL for the terminal; a Lisp library
+and a core image .")
(license license:expat))))
-(define-public cl-mgl-pax
- (sbcl-package->cl-source-package sbcl-mgl-pax))
+(define-public cl-ciel
+ (sbcl-package->cl-source-package sbcl-ciel))
-(define-public ecl-mgl-pax
- (sbcl-package->ecl-package sbcl-mgl-pax))
+(define-public ecl-ciel
+ (sbcl-package->ecl-package sbcl-ciel))
-(define-public sbcl-40ants-doc
- (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b")
- (revision "0"))
+(define-public sbcl-circular-streams
+ (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
+ (revision "1"))
(package
- (name "sbcl-40ants-doc")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-circular-streams")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/circular-streams";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; The tests depend on cl-test-more which is now prove. Prove
+ ;; tests aren't working for some reason.
+ `(#:tests? #f))
+ (inputs
+ (list sbcl-fast-io sbcl-trivial-gray-streams))
+ (home-page "https://github.com/fukamachi/circular-streams";)
+ (synopsis "Circularly readable streams for Common Lisp")
+ (description
+ "Circular-Streams allows you to read streams circularly by wrapping real
+streams. Once you reach end-of-file of a stream, it's file position will be
+reset to 0 and you're able to read it again.")
+ (license license:llgpl))))
+
+(define-public cl-circular-streams
+ (sbcl-package->cl-source-package sbcl-circular-streams))
+
+(define-public ecl-circular-streams
+ (sbcl-package->ecl-package sbcl-circular-streams))
+
+(define-public sbcl-cl-abnf
+ ;; There are no releases
+ (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-abnf")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dimitri/cl-abnf";)
+ (commit commit)))
+ (file-name (git-file-name "cl-abnf" version))
+ (sha256
+ (base32 "0f09nsndxa90acm71zd4qdnp40v705a4sqm04mnv9x76h6dlggmz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("esrap" ,sbcl-esrap)))
+ (arguments
+ `(#:asd-systems '("abnf")))
+ (home-page "https://github.com/dimitri/cl-abnf";)
+ (synopsis "ABNF parser generator for Common Lisp")
+ (description "This Common Lisp library implements a parser generator for
+the ABNF grammar format as described in RFC2234. The generated parser is a
+regular expression scanner provided by the cl-ppcre lib, which means that we
+can't parse recursive grammar definition. One such definition is the ABNF
+definition as given by the RFC. Fortunately, as you have this lib, you most
+probably don't need to generate another parser to handle that particular ABNF
+grammar.")
+ (license license:expat))))
+
+(define-public cl-abnf
+ (sbcl-package->cl-source-package sbcl-cl-abnf))
+
+(define-public ecl-cl-abnf
+ (sbcl-package->ecl-package sbcl-cl-abnf))
+
+(define-public sbcl-cl-algebraic-data-type
+ (let ((commit "b2568428193a512d141d6b615772d50ceb5f9bca"))
+ (package
+ (name "sbcl-cl-algebraic-data-type")
+ (version (git-version "1.2.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/40ants/doc";)
+ (url "https://github.com/stylewarning/cl-algebraic-data-type";)
(commit commit)))
+ (file-name (git-file-name "cl-algebraic-data-type" version))
(sha256
- (base32 "1v6gnhrk02vsixmprzk4wvvj7vh11vp5waxyih0qz2ih8d38r5pg"))
- (file-name (git-file-name "cl-40ants-doc" version))))
+ (base32 "1lnqxcv8pd5z8n0g5p2l0dbljx9pqiv18hxl0vhsh7ldhkrjv2jx"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; TODO: Add remaining dependencies of 40ants-doc-full and
- ;; 40ants-doc-test missing from Guix.
- '(#:asd-systems '("40ants-doc"
- ;;"40ants-doc-full"
- )
- #:tests? #f))
- ;;(native-inputs
- ;; (list sbcl-rove))
(inputs
- (list sbcl-named-readtables
- sbcl-pythonic-string-reader
- ;; For 40ants-doc-full:
- ;;sbcl-3bmd
- ;;sbcl-alexandria
- ;;sbcl-babel
- ;;sbcl-cl-cookie
- ;;sbcl-cl-fad
- ;;sbcl-cl-ppcre
- ;;sbcl-common-doc ; Missing from Guix
- ;;sbcl-common-html ; Missing from Guix
- ;;sbcl-commondoc-markdown ; Missing from Guix
- ;;sbcl-dexador
- ;;sbcl-docs-builder ; Missing from Guix
- ;;sbcl-fare-utils
- ;;sbcl-jonathan
- ;;sbcl-lass
- ;;sbcl-local-time
- ;;sbcl-log4cl
- ;;sbcl-slime-swank
- ;;sbcl-slynk
- ;;sbcl-spinneret
- ;;sbcl-stem ; Missing from Guix; also, license is unconfirmed
- ;;sbcl-str
- ;;sbcl-tmpdir ; Missing from Guix
- ;;sbcl-trivial-extract ; Missing from Guix
- ;;sbcl-xml-emitter
- ))
- (home-page "https://40ants.com/doc/";)
- (synopsis "Exploratory programming environment and documentation
generator")
+ (list sbcl-alexandria
+ sbcl-global-vars))
+ (arguments
+ '(#:tests? #f)) ; No tests.
+ (home-page "https://github.com/stylewarning/cl-algebraic-data-type";)
+ (synopsis "Common Lisp library for algebraic data types")
(description
- "@code{40ants-doc} provides a rudimentary explorable programming
-environment. The narrative primarily lives in so-called sections that mix
-Markdown docstrings with references to functions, variables, etc., all of
-which should probably have their own docstrings.
-
-The primary focus is on making code easily explorable by using SLIME's
-@kbd{M-.} (@code{slime-edit-definition}). Generating documentation in
-Markdown or HTML format from sections and all the referenced items is also
-implemented.
-
-With the simplistic tools provided, one may obtain results similar to literate
-programming, but documentation is generated from code, not the other way
-around, and there is no support for chunking. Code comes first, code must
-look pretty, documentation is code.
-
-@code{40ants-doc} is a fork of MGL-PAX with fewer dependencies (only
-@code{named-readtables} and @code{pythonic-string-reader}) for the core
-system, and additional features in the full system.")
- (license license:expat))))
+ "CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic
+data types in a similar spirit to Haskell or Standard ML, as well as for
+operating on them.")
+ (license license:bsd-3))))
-(define-public cl-40ants-doc
- (sbcl-package->cl-source-package sbcl-40ants-doc))
+(define-public cl-algebraic-data-type
+ (sbcl-package->cl-source-package sbcl-cl-algebraic-data-type))
-(define-public ecl-40ants-doc
- (sbcl-package->ecl-package sbcl-40ants-doc))
+(define-public ecl-algebraic-data-type
+ (sbcl-package->ecl-package sbcl-cl-algebraic-data-type))
-(define-public sbcl-mssql
- (let ((commit "045602a19a32254108f2b75871049293f49731eb")
- (revision "1"))
+(define-public sbcl-cl-all
+ (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace")
+ (revision "0"))
(package
- (name "sbcl-mssql")
- (version (git-version "0.0.3" revision commit))
+ (name "sbcl-cl-all")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/cl-mssql";)
+ (url "https://github.com/Shinmera/cl-all";)
(commit commit)))
- (file-name (git-file-name "cl-mssql" version))
+ (file-name (git-file-name "cl-all" version))
(sha256
- (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm"))))
+ (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("freetds" ,freetds)
- ("garbage-pools" ,sbcl-garbage-pools)
- ("iterate" ,sbcl-iterate)
- ("parse-number" ,sbcl-parse-number)))
+ (outputs '("out" "bin"))
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/mssql.lisp"
- (("libsybdb" all)
- (string-append (assoc-ref inputs "freetds") "/lib/" all)))
- #t)))))
- (home-page "https://github.com/archimag/cl-mssql";)
- (synopsis "Common Lisp library to interact with MS SQL Server databases")
- (description
- "@code{cl-mssql} provides an interface to connect to Microsoft SQL
-server. It uses the @code{libsybdb} foreign library provided by the FreeTDS
-project.")
- (license license:llgpl))))
-
-(define-public ecl-mssql
- (sbcl-package->ecl-package sbcl-mssql))
-
-(define-public cl-mssql
- (sbcl-package->cl-source-package sbcl-mssql))
-
-(define-public sbcl-anaphora
- (package
- (name "sbcl-anaphora")
- (version "0.9.8")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tokenrove/anaphora";)
- (commit version)))
- (sha256
- (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b"))
- (file-name (git-file-name "cl-anaphora" version))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-rt))
- (synopsis "The anaphoric macro collection from Hell")
- (description
- "Anaphora is the anaphoric macro collection from Hell: it includes many
-new fiends in addition to old friends like @command{aif} and
-@command{awhen}.")
- (home-page "https://github.com/tokenrove/anaphora";)
- (license license:public-domain)))
-
-(define-public cl-anaphora
- (sbcl-package->cl-source-package sbcl-anaphora))
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'create-asdf-configuration 'build-program
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-program
+ (string-append (assoc-ref outputs "bin") "/bin/cl-all")
+ outputs
+ #:entry-program '((cl-all:toplevel arguments))
+ #:compress? #t))))))
+ (home-page "https://github.com/Shinmera/cl-all";)
+ (synopsis "Evaluate Common Lisp expressions in multiple implementations")
+ (description "@samp{cl-all} is a library and script for evaluating Common
+Lisp expressions in multiple implementations.")
+ (license license:zlib))))
-(define-public ecl-anaphora
- (sbcl-package->ecl-package sbcl-anaphora))
+(define-public cl-all
+ (sbcl-package->cl-source-package sbcl-cl-all))
-(define-public sbcl-let-plus
- (let ((commit "455e657e077235829b197f7ccafd596fcda69e30")
+(define-public sbcl-cl-ana
+ (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e")
(revision "2"))
(package
- (name "sbcl-let-plus")
+ (name "sbcl-cl-ana")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/let-plus";)
+ (url "https://github.com/ghollisjr/cl-ana";)
(commit commit)))
+ (file-name (git-file-name "cl-ana" version))
(sha256
- (base32 "00c0nq6l4zb692rzsc9aliqzj3avrssfyz4bhxzl7f1jsz3m29jb"))
- (file-name (git-file-name "cl-let-plus" version))))
+ (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-anaphora))
(native-inputs
- (list sbcl-lift))
- (synopsis "Destructuring extension of let*")
+ (list openmpi ;; for hdf-cffi
+ pkg-config
+ sbcl-cl-fad))
+ (inputs
+ (list gsl
+ hdf5-parallel-openmpi
+ libffi
+ sbcl-antik
+ sbcl-cffi
+ sbcl-cl-csv
+ sbcl-closer-mop
+ sbcl-external-program
+ sbcl-gsll
+ sbcl-iterate
+ sbcl-alexandria
+ sbcl-split-sequence))
+ (propagated-inputs
+ (list gnuplot)) ;; for gnuplot-interface
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "hdf-cffi/src/library.lisp"
+ (("libhdf5.so")
+ (search-input-file inputs "/lib/libhdf5.so")))
+ (substitute* (list "gsl-cffi/gsl-cffi.lisp"
+ "spline/spline.lisp")
+ (("libgsl.so")
+ (search-input-file inputs "/lib/libgsl.so")))))
+ (add-after 'fix-paths 'fix-newer-hdf5-compatibility
+ (lambda _
+ (substitute* (list "hdf-cffi/src/h5-grovel.lisp"
+ "hdf-cffi/src/h5a-grovel.lisp"
+ "hdf-cffi/src/h5d-grovel.lisp"
+ "hdf-cffi/src/h5f-grovel.lisp"
+ "hdf-cffi/src/h5g-grovel.lisp"
+ "hdf-cffi/src/h5i-grovel.lisp"
+ "hdf-cffi/src/h5l-grovel.lisp"
+ "hdf-cffi/src/h5o-grovel.lisp"
+ "hdf-cffi/src/h5p-grovel.lisp"
+ "hdf-cffi/src/h5pl-grovel.lisp"
+ "hdf-cffi/src/h5r-grovel.lisp"
+ "hdf-cffi/src/h5s-grovel.lisp"
+ "hdf-cffi/src/h5t-grovel.lisp"
+ "hdf-cffi/src/h5z-grovel.lisp")
+ (("_H5private_H")
+ "H5private_H")))))))
+ (synopsis "Common Lisp data analysis library")
(description
- "This library implements the let+ macro, which is a dectructuring
-extension of let*. It features:
-
-@itemize
-@item Clean, consistent syntax and small implementation (less than 300 LOC,
-not counting tests)
-@item Placeholder macros allow editor hints and syntax highlighting
-@item @command{&ign} for ignored values (in forms where that makes sense)
-@item Very easy to extend
-@end itemize\n")
- (home-page "https://github.com/sharplispers/let-plus";)
- (license license:boost1.0))))
-
-(define-public cl-let-plus
- (sbcl-package->cl-source-package sbcl-let-plus))
+ "CL-ANA is a data analysis library in Common Lisp providing tabular and
+binned data analysis along with nonlinear least squares fitting and
+visualization.")
+ (home-page "https://github.com/ghollisjr/cl-ana";)
+ (license license:gpl3))))
-(define-public ecl-let-plus
- (sbcl-package->ecl-package sbcl-let-plus))
+(define-public cl-ana
+ (sbcl-package->cl-source-package sbcl-cl-ana))
-(define-public sbcl-cl-cairo2
- (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b")
+(define-public sbcl-cl-annot
+ (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
(revision "1"))
(package
- (name "sbcl-cl-cairo2")
- (version (git-version "0.6" revision commit))
+ (name "sbcl-cl-annot")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/cl-cairo2";)
+ (url "https://github.com/m2ym/cl-annot";)
(commit commit)))
- (file-name (git-file-name "cl-cairo2" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0cpfgyxw6pz7y033dlya8c4vjmkpw127zdq3a9xclp9q8jbdlb7q"))))
+ (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '(;; "cl-cairo2-gtk2" ; cl-gtk2 is not packed and quite
old.
- ;; "cl-cairo2-quartz" ; Failing when enabled.
- ;; "cl-cairo2-xlib" ; cl-xcb-xlib is not packed yet
and quite old.
- ;; "cl-cairo2-xcb"
- "cl-cairo2")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/load-libraries.lisp"
- (("libcairo.so.2")
- (search-input-file inputs "/lib/libcairo.so.2"))))))))
(inputs
- (list cairo
- sbcl-cffi
- sbcl-cl-colors
- sbcl-cl-freetype2
- sbcl-cl-utilities
- sbcl-metabang-bind
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (home-page "https://github.com/rpav/cl-cairo2";)
- (synopsis "Cairo bindings for Common Lisp")
+ (list sbcl-alexandria))
+ (home-page "https://github.com/m2ym/cl-annot";)
+ (synopsis "Python-like Annotation Syntax for Common Lisp")
(description
- "This package provides CFFI bindings for Common Lisp to the Cairo
-C library.")
- (license license:boost1.0))))
+ "@code{cl-annot} is an general annotation library for Common Lisp.")
+ (license license:llgpl))))
-(define-public ecl-cl-cairo2
- (sbcl-package->ecl-package sbcl-cl-cairo2))
+(define-public cl-annot
+ (sbcl-package->cl-source-package sbcl-cl-annot))
-(define-public cl-cairo2
- (sbcl-package->cl-source-package sbcl-cl-cairo2))
+(define-public ecl-cl-annot
+ (sbcl-package->ecl-package sbcl-cl-annot))
-(define-public sbcl-cl-colors
- (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
+(define-public sbcl-cl-ansi-text
+ (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c"))
(package
- (name "sbcl-cl-colors")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-cl-ansi-text")
+ (version (git-version "2.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tpapp/cl-colors";)
+ (url "https://github.com/pnathan/cl-ansi-text";)
(commit commit)))
(sha256
(base32
- "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
- (file-name (git-file-name "cl-colors" version))))
+ "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14"))
+ (file-name (git-file-name "cl-ansi-text" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-let-plus))
- (synopsis "Simple color library for Common Lisp")
+ (list sbcl-alexandria sbcl-cl-colors2))
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "ANSI terminal color implementation for Common Lisp")
(description
- "This is a very simple color library for Common Lisp, providing
-
-@itemize
-@item Types for representing colors in HSV and RGB spaces.
-@item Simple conversion functions between the above types (and also
-hexadecimal representation for RGB).
-@item Some predefined colors (currently X11 color names – of course the
-library does not depend on X11).Because color in your terminal is nice.
-@end itemize
+ "@command{cl-ansi-text} provides utilities which enable printing to an
+ANSI terminal with colored text. It provides the macro @command{with-color}
+which causes everything printed in the body to be displayed with the provided
+color. It further provides functions which will print the argument with the
+named color.")
+ (home-page "https://github.com/pnathan/cl-ansi-text";)
+ (license license:llgpl))))
-This library is no longer supported by its author.")
- (home-page "https://github.com/tpapp/cl-colors";)
- (license license:boost1.0))))
-
-(define-public cl-colors
- (sbcl-package->cl-source-package sbcl-cl-colors))
+(define-public cl-ansi-text
+ (sbcl-package->cl-source-package sbcl-cl-ansi-text))
-(define-public ecl-cl-colors
- (sbcl-package->ecl-package sbcl-cl-colors))
+(define-public ecl-cl-ansi-text
+ (sbcl-package->ecl-package sbcl-cl-ansi-text))
-(define-public sbcl-format-colors
- (let ((commit "fecb1d8c6e7a07ff9f10a7a4eb4c3bd629d4969f")
- (revision "0"))
+(define-public sbcl-cl-ascii-table
+ (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
+ (revision "1"))
(package
- (name "sbcl-format-colors")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-cl-ascii-table")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vindarel/format-colors";)
+ (url "https://github.com/telephil/cl-ascii-table";)
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "084ydjhic2dq0gb7wfm6plnjq3l7485hb3yhxl03mm64a6sr3fxv"))
- (file-name (git-file-name "cl-format-colors" version))))
+ (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
(build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cl-ansi-text))
- (synopsis "Custom format functions for colorful output")
- (description "This package provides simple format directives to
- print in colors.")
- (home-page "https://github.com/vindarel/format-colors";)
- (license license:llgpl))))
+ (synopsis "Library to make ascii-art tables")
+ (description
+ "This is a Common Lisp library to present tabular data in ascii-art
+tables.")
+ (home-page "https://github.com/telephil/cl-ascii-table";)
+ (license license:expat))))
-(define-public cl-format-colors
- (sbcl-package->cl-source-package sbcl-format-colors))
+(define-public cl-ascii-table
+ (sbcl-package->cl-source-package sbcl-cl-ascii-table))
-(define-public ecl-format-colors
- (sbcl-package->ecl-package sbcl-format-colors))
+(define-public ecl-cl-ascii-table
+ (sbcl-package->ecl-package sbcl-cl-ascii-table))
-(define-public sbcl-cl-ansi-text
- (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c"))
+(define-public sbcl-cl-async
+ (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
+ (revision "1"))
(package
- (name "sbcl-cl-ansi-text")
- (version (git-version "2.0.1" "1" commit))
+ (name "sbcl-cl-async")
+ (version (git-version "0.6.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pnathan/cl-ansi-text";)
+ (url "https://github.com/orthecreedence/cl-async";)
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
(base32
- "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14"))
- (file-name (git-file-name "cl-ansi-text" version))))
+ "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-cl-colors2))
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "ANSI terminal color implementation for Common Lisp")
+ `(("babel" ,sbcl-babel)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-libuv" ,sbcl-cl-libuv)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("fast-io" ,sbcl-fast-io)
+ ("openssl" ,openssl)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("vom" ,sbcl-vom)))
+ (arguments
+ `(#:asd-systems '("cl-async"
+ "cl-async-repl"
+ "cl-async-ssl")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/ssl/package.lisp"
+ (("libcrypto\\.so")
+ (search-input-file inputs "/lib/libcrypto.so"))
+ (("libssl\\.so")
+ (search-input-file inputs "/lib/libssl.so"))))))))
+ (synopsis "Asynchronous operations for Common Lisp")
(description
- "@command{cl-ansi-text} provides utilities which enable printing to an
-ANSI terminal with colored text. It provides the macro @command{with-color}
-which causes everything printed in the body to be displayed with the provided
-color. It further provides functions which will print the argument with the
-named color.")
- (home-page "https://github.com/pnathan/cl-ansi-text";)
- (license license:llgpl))))
+ "Cl-async is a library for general purpose, non-blocking programming in
+Common Lisp. It uses the libuv library as backend.")
+ (home-page "https://orthecreedence.github.io/cl-async/";)
+ (license license:expat))))
-(define-public cl-ansi-text
- (sbcl-package->cl-source-package sbcl-cl-ansi-text))
+(define-public cl-async
+ (sbcl-package->cl-source-package sbcl-cl-async))
-(define-public ecl-cl-ansi-text
- (sbcl-package->ecl-package sbcl-cl-ansi-text))
+(define-public ecl-cl-async
+ (sbcl-package->ecl-package sbcl-cl-async))
-(define-public sbcl-proc-parse
- (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
+(define-public sbcl-cl-async-future
+ (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
+ (revision "1"))
(package
- (name "sbcl-proc-parse")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-cl-async-future")
+ (version (git-version "0.4.4.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/proc-parse";)
+ (url "https://github.com/orthecreedence/cl-async-future";)
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
(base32
- "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
- (file-name (git-file-name "proc-parse" version))))
+ "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)))
+ (list sbcl-blackbird))
(native-inputs
- (list sbcl-prove))
- (arguments
- '(#:asd-systems '("proc-parse-test"
- "proc-parse")))
- (synopsis "Procedural vector parser")
+ (list sbcl-cl-async sbcl-eos))
+ (synopsis "Futures implementation for Common Lisp")
(description
- "This is a string/octets parser library for Common Lisp with speed and
-readability in mind. Unlike other libraries, the code is not a
-pattern-matching-like, but a char-by-char procedural parser.")
- (home-page "https://github.com/fukamachi/proc-parse";)
- (license license:bsd-2))))
+ "This is futures implementation for Common Lisp. It plugs in nicely
+to cl-async.")
+ (home-page "https://orthecreedence.github.io/cl-async/future";)
+ (license license:expat))))
-(define-public cl-proc-parse
- (sbcl-package->cl-source-package sbcl-proc-parse))
+(define-public cl-async-future
+ (sbcl-package->cl-source-package sbcl-cl-async-future))
-(define-public ecl-proc-parse
- (sbcl-package->ecl-package sbcl-proc-parse))
+(define-public ecl-cl-async-future
+ (sbcl-package->ecl-package sbcl-cl-async-future))
-(define-public sbcl-parse-float
- (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c")
- (revision "2"))
+(define-public sbcl-cl-autowrap
+ (let ((revision "2")
+ (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4"))
+ ;; no taged branches
(package
- (name "sbcl-parse-float")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-autowrap")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/soemraws/parse-float";)
+ (url "https://github.com/rpav/cl-autowrap";)
(commit commit)))
+ (file-name (git-file-name "cl-autowrap" version))
(sha256
- (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr"))
- (file-name (git-file-name "proc-parse" version))))
+ (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; FIXME: https://github.com/soemraws/parse-float/issues/12
- `(#:asd-systems '("parse-float" "parse-float-tests")))
- (native-inputs
- (list sbcl-lisp-unit))
+ `(#:asd-systems '("cl-plus-c" "cl-autowrap")))
(inputs
- `(("alexandria" ,sbcl-alexandria)))
- (home-page "https://github.com/soemraws/parse-float";)
- (synopsis "Parse a floating point value from a string in Common Lisp")
- (description
- "This package exports the following function to parse floating-point
-values from a string in Common Lisp.")
- (license license:public-domain))))
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-json" ,sbcl-cl-json)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("defpackage-plus" ,sbcl-defpackage-plus)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/rpav/cl-autowrap";)
+ (synopsis "FFI wrapper generator for Common Lisp")
+ (description "This is a c2ffi-based wrapper generator for Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-parse-float
- (sbcl-package->cl-source-package sbcl-parse-float))
+(define-public cl-autowrap
+ (sbcl-package->cl-source-package sbcl-cl-autowrap))
-(define-public ecl-parse-float
- (sbcl-package->ecl-package sbcl-parse-float))
+(define-public ecl-cl-autowrap
+ (sbcl-package->ecl-package sbcl-cl-autowrap))
-(define-public sbcl-cl-string-match
- (let ((revision "1")
- (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
+(define-public sbcl-cl-base32
+ (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
+ (revision "1"))
(package
- (name "sbcl-cl-string-match")
- (version (git-version "0" revision changeset))
+ (name "sbcl-cl-base32")
+ (version (git-version "0.1" revision commit))
(source
(origin
- (method hg-fetch)
- (uri (hg-reference
- (url "https://github.com/vityok/cl-string-match";)
- (changeset changeset)))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hargettp/cl-base32";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
- (file-name (git-file-name "cl-string-match" version))))
+ (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)
- ("iterate" ,sbcl-iterate)
- ("jpl-queues" ,sbcl-jpl-queues)
- ("jpl-util" ,sbcl-jpl-util)
- ("mgl-pax" ,sbcl-mgl-pax)
- ("parse-float" ,sbcl-parse-float)
- ("proc-parse" ,sbcl-proc-parse)
- ("yacc" ,sbcl-cl-yacc)))
- ;; TODO: Tests are not evaluated properly.
(native-inputs
- ;; For testing:
(list sbcl-lisp-unit))
- (arguments
- `(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-dependency
- (lambda _
- (substitute* "cl-string-match.asd"
- ((":mgl-pax")
- ":mgl-pax/document")))))))
- (synopsis "Set of utilities to manipulate strings in Common Lisp")
+ (synopsis "Common Lisp library for base32 encoding and decoding")
(description
- "@command{cl-strings} is a small, portable, dependency-free set of
-utilities that make it even easier to manipulate text in Common Lisp. It has
-100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
- (home-page "https://github.com/vityok/cl-string-match";)
- (license license:bsd-3))))
+ "This package provides functions for base32 encoding and decoding as
+defined in RFC4648.")
+ (home-page "https://github.com/hargettp/cl-base32";)
+ (license license:expat))))
-(define-public cl-string-match
- (sbcl-package->cl-source-package sbcl-cl-string-match))
-
-(define-public ecl-cl-string-match
- (sbcl-package->ecl-package sbcl-cl-string-match))
-
-(define-public sbcl-cl-punch
- (package
- (name "sbcl-cl-punch")
- (version "0.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/windymelt/cl-punch";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-punch" version))
- (sha256
- (base32 "1vmbaz9y9lq4wvi8mfbyif8vc9yfk2i0qd3ysbzl152wx32dbzs3"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
- (inputs
- (list sbcl-cl-syntax))
- (home-page "https://github.com/windymelt/cl-punch";)
- (synopsis "Anonymous lambda literal in Common Lisp, respecting Scala")
- (description
- "CL-PUNCH is a Scala-like anonymous lambda literal.")
- (license license:expat )))
-
-(define-public cl-punch
- (sbcl-package->cl-source-package sbcl-cl-punch))
+(define-public cl-base32
+ (sbcl-package->cl-source-package sbcl-cl-base32))
-(define-public ecl-cl-punch
- (sbcl-package->ecl-package sbcl-cl-punch))
+(define-public ecl-cl-base32
+ (sbcl-package->ecl-package sbcl-cl-base32))
-(define-public sbcl-puri
- (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b")
- (revision "2"))
+(define-public sbcl-cl-base58
+ (let ((commit "f446835b4104896e0eed6a61d2ceb4ad22f589d8")
+ (revision "1"))
(package
- (name "sbcl-puri")
- (version (git-version "1.5.7" revision commit))
+ (name "sbcl-cl-base58")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://git.kpe.io/puri.git";)
+ (url "https://github.com/eudoxia0/cl-base58/";)
(commit commit)))
- (file-name (git-file-name "puri" version))
+ (file-name (git-file-name "cl-base58" version))
(sha256
- (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd"))
- (modules '((guix build utils)))
- (snippet
- ;; The useless bundled debian folder drags `make' into the closure.
- `(begin
- (delete-file-recursively "debian")
- #t))))
+ (base32 "01wiiyz1jzxx3zhxi2hpq5n8hv28g1mn0adk793vwjzh4v5bi5zz"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("cl-base58-test" "cl-base58")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "cl-base58-test.asd"
+ (("cl-test-more")
+ "prove"))
+ #t)))))
(native-inputs
- (list sbcl-ptester))
- (home-page "http://puri.kpe.io/";)
- (synopsis "Portable URI Library")
+ (list sbcl-prove))
+ (home-page "https://github.com/eudoxia0/cl-base58";)
+ (synopsis "Implementation of base58 for Common Lisp")
(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-public ecl-puri
- (sbcl-package->ecl-package sbcl-puri))
-
-(define-public sbcl-qmynd
- (let ((commit "7e56daf73f0ed5f49a931c01af75fb874bcf3445")
- (revision "1"))
- (package
- (name "sbcl-qmynd")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/qitab/qmynd";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "06gw5wxcpdclb6a5i5k9lbmdlyqsp182czrm9bm1cpklzbj0ihrl"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-asdf-finalizers
- sbcl-babel
- sbcl-chipz
- sbcl-cl+ssl
- sbcl-flexi-streams
- sbcl-ironclad
- sbcl-salza2
- sbcl-trivial-gray-streams
- sbcl-usocket))
- (home-page "https://github.com/qitab/qmynd";)
- (synopsis "QITAB MySQL Native Driver for Common Lisp")
- (description "QMyND, the QITAB MySQL Native Driver, is a MySQL client
-library that directly talks to a MySQL server in its native network protocol.
-
-It's a part of QITAB umbrella project.")
+ "This library implements the @code{base58} encoding algorithm. It's
+basically @code{base64} but with a smaller alphabet (58, as in the name) that
+doesn't include similar looking characters, among other things. See
+@url{https://github.com/bitcoin/bitcoin/blob/master/src/base58.h} for a full
+reference.")
(license license:expat))))
-(define-public ecl-qmynd
- (sbcl-package->ecl-package sbcl-qmynd))
+(define-public cl-base58
+ (sbcl-package->cl-source-package sbcl-cl-base58))
-(define-public cl-qmynd
- (sbcl-package->cl-source-package sbcl-qmynd))
+(define-public ecl-cl-base58
+ (sbcl-package->ecl-package sbcl-cl-base58))
-(define-public sbcl-queues
- (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
+(define-public sbcl-cl-base64
+ (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
(package
- (name "sbcl-queues")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-cl-base64")
+ (version (git-version "3.3.4" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/oconnore/queues";)
+ (url "http://git.kpe.io/cl-base64.git/";)
(commit commit)))
- (file-name (git-file-name "queues" version))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
+ (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The useless bundled debian folder drags `make' into the closure.
+ `(begin
+ (delete-file-recursively "debian")
+ #t))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- '(#:asd-systems '("queues"
- "queues.simple-queue"
- "queues.simple-cqueue"
- "queues.priority-queue"
- "queues.priority-cqueue")))
- (home-page "https://github.com/oconnore/queues";)
- (synopsis "Common Lisp queue library")
+ (native-inputs ; For tests.
+ (list sbcl-ptester sbcl-kmrcl))
+ (home-page "http://files.kpe.io/cl-base64/";)
+ (synopsis
+ "Common Lisp package to encode and decode base64 with URI support")
(description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
- (license license:expat))))
+ "This package provides highly optimized base64 encoding and decoding.
+Besides conversion to and from strings, integer conversions are supported.
+Encoding with Uniform Resource Identifiers is supported by using a modified
+encoding table that uses only URI-compatible characters.")
+ (license license:bsd-3))))
-(define-public cl-queues
- (sbcl-package->cl-source-package sbcl-queues))
+(define-public cl-base64
+ (sbcl-package->cl-source-package sbcl-cl-base64))
-(define-public ecl-queues
- (sbcl-package->ecl-package sbcl-queues))
+(define-public ecl-cl-base64
+ (sbcl-package->ecl-package sbcl-cl-base64))
-(define-public sbcl-glsl-packing
- (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a")
+(define-public sbcl-cl-cairo2
+ (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b")
(revision "1"))
(package
- (name "sbcl-glsl-packing")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-cairo2")
+ (version (git-version "0.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/glsl-packing/";)
+ (url "https://github.com/rpav/cl-cairo2";)
(commit commit)))
- (file-name (git-file-name "glsl-packing" version))
+ (file-name (git-file-name "cl-cairo2" version))
(sha256
- (base32 "0k2f1771wd9kdrcasldy1r00k5bdgi9fd07in52zmjggc0i7dd80"))))
+ (base32 "0cpfgyxw6pz7y033dlya8c4vjmkpw127zdq3a9xclp9q8jbdlb7q"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '(;; "cl-cairo2-gtk2" ; cl-gtk2 is not packed and quite
old.
+ ;; "cl-cairo2-quartz" ; Failing when enabled.
+ ;; "cl-cairo2-xlib" ; cl-xcb-xlib is not packed yet
and quite old.
+ ;; "cl-cairo2-xcb"
+ "cl-cairo2")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/load-libraries.lisp"
+ (("libcairo.so.2")
+ (search-input-file inputs "/lib/libcairo.so.2"))))))))
(inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/3b/glsl-packing/";)
- (synopsis "Common Lisp utilities to calculate OpenGL layouts")
+ (list cairo
+ sbcl-cffi
+ sbcl-cl-colors
+ sbcl-cl-freetype2
+ sbcl-cl-utilities
+ sbcl-metabang-bind
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/rpav/cl-cairo2";)
+ (synopsis "Cairo bindings for Common Lisp")
(description
- "This is a Common Lisp library to calculate std140 or std430 layouts for
-a glsl UBO/SSBO.")
- (license license:expat))))
+ "This package provides CFFI bindings for Common Lisp to the Cairo
+C library.")
+ (license license:boost1.0))))
-(define-public ecl-glsl-packing
- (sbcl-package->ecl-package sbcl-glsl-packing))
+(define-public cl-cairo2
+ (sbcl-package->cl-source-package sbcl-cl-cairo2))
-(define-public cl-glsl-packing
- (sbcl-package->cl-source-package sbcl-glsl-packing))
+(define-public ecl-cl-cairo2
+ (sbcl-package->ecl-package sbcl-cl-cairo2))
-(define-public sbcl-glsl-spec
- (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d")
- (revision "1"))
+(define-public sbcl-cl-cffi-gtk
+ (let ((commit "1700fe672c65455c1fc33061ec92a3df84287ec7")
+ (revision "3"))
(package
- (name "sbcl-glsl-spec")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-cffi-gtk")
+ (version (git-version "3.8.8" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cbaggers/glsl-spec";)
+ (url "https://github.com/sharplispers/cl-cffi-gtk/";)
(commit commit)))
- (file-name (git-file-name "glsl-spec" version))
+ (file-name (git-file-name "cl-cffi-gtk" version))
(sha256
- (base32 "01ipspr22fgfj3w8wq2y81lzrjc4vpfiwnr3dqhjlpzzra46am8c"))))
+ (base32 "1cn2f6b62axjzdzfv971218ably32dvqfdy499li25vjd8nb2qm3"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("glsl-spec" "glsl-symbols" "glsl-docs")))
- (home-page "https://github.com/cbaggers/glsl-spec";)
- (synopsis "Common Lisp GLSL specification as a datastructure")
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list cairo
+ gdk-pixbuf
+ glib
+ gtk+
+ pango
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-closer-mop
+ sbcl-iterate
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (arguments
+ (list
+ ;; TODO: Tests fail with memory fault.
+ ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
+ #:tests? #f
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "glib/glib.init.lisp"
+ (("libglib-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all)))
+ (("libgthread-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "gobject/gobject.init.lisp"
+ (("libgobject-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "gio/gio.init.lisp"
+ (("libgio-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "cairo/cairo.init.lisp"
+ (("libcairo\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "pango/pango.init.lisp"
+ (("libpango-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all)))
+ (("libpangocairo-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
+ (("libgdk_pixbuf-[0-9.]*\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "gdk/gdk.init.lisp"
+ (("libgdk-[0-9]\\.so" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "gdk/gdk.package.lisp"
+ (("libgtk-[0-9]\\.so" all)
+ (search-input-file inputs (string-append "/lib/"
all)))))))))
+ (home-page "https://github.com/sharplispers/cl-cffi-gtk/";)
+ (synopsis "Common Lisp binding for GTK+3")
(description
- "This package contains the specification of all functions and variables
-from GLSL as data.")
- (license license:unlicense))))
+ "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
+is a library for creating graphical user interfaces.")
+ (license license:lgpl3))))
-(define-public ecl-glsl-spec
- (sbcl-package->ecl-package sbcl-glsl-spec))
+(define-public cl-cffi-gtk
+ (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
-(define-public cl-glsl-spec
- (sbcl-package->cl-source-package sbcl-glsl-spec))
+(define-public ecl-cl-cffi-gtk
+ (sbcl-package->ecl-package sbcl-cl-cffi-gtk))
-(define-public sbcl-rtg-math
- (let ((commit "29fc5b3d0028a4a11a82355ecc8cca62662c69e0")
+(define-public sbcl-cl-change-case
+ (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022")
(revision "1"))
(package
- (name "sbcl-rtg-math")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-change-case")
+ (version (git-version "0.2.0" revision commit))
+ (home-page "https://github.com/rudolfochrist/cl-change-case";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cbaggers/rtg-math";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "rtg-math" version))
+ (file-name (git-file-name "cl-change-case" version))
(sha256
- (base32 "0bhxxnv7ldkkb18zdxyz2rj2a3iawzq2kcp7cn5i91iby7n0082x"))))
+ (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-documentation-utils sbcl-glsl-spec))
- (home-page "https://github.com/cbaggers/rtg-math";)
- (synopsis "Common Lisp library of game-related math functions")
+ (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode))
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis
+ "Convert Common Lisp strings between camelCase, PascalCase and more")
(description
- "RTG-MATH provides a selection of the math routines most commonly needed
-for making realtime graphics in Lisp.")
- (license license:bsd-2))))
+ "@code{cl-change-case} is a library to convert strings between
+camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
+ (license license:llgpl))))
-(define-public ecl-rtg-math
- (sbcl-package->ecl-package sbcl-rtg-math))
+(define-public cl-change-case
+ (sbcl-package->cl-source-package sbcl-cl-change-case))
-(define-public cl-rtg-math
- (sbcl-package->cl-source-package sbcl-rtg-math))
+(define-public ecl-cl-change-case
+ (sbcl-package->ecl-package sbcl-cl-change-case))
-(define-public sbcl-varjo
- (let ((commit "9e77f30220053155d2ef8870ceba157f75e538d4")
+(define-public sbcl-cl-charms
+ (let ((commit "64aba59d89f85bc5c9402e445873965338a66a02")
(revision "1"))
(package
- (name "sbcl-varjo")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-charms")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cbaggers/varjo";)
+ (url "https://github.com/HiTECNOLOGYs/cl-charms";)
(commit commit)))
- (file-name (git-file-name "varjo" version))
+ (file-name (git-file-name "cl-charms" version))
(sha256
- (base32 "1p9x1wj576x5d31yvls9r1avkjkyhri7kyxbjfkg9z93a1w18j9z"))))
+ (base32 "1jczaypa9dhxr34yyhsxb6lrdnircjx8am4iqkc3shfpjn32q323"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-alexandria
- sbcl-cl-ppcre
- sbcl-documentation-utils
- sbcl-fn
- sbcl-glsl-spec
- sbcl-named-readtables
- sbcl-parse-float
- sbcl-vas-string-metrics))
- (home-page "https://github.com/cbaggers/varjo";)
- (synopsis "Lisp to GLSL Language Translator")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("ncurses" ,ncurses)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/low-level/curses-bindings.lisp"
+ (("libncursesw.so")
+ (string-append (assoc-ref inputs "ncurses")
+ "/lib/libncursesw.so"))))))))
+ (home-page "https://github.com/HiTECNOLOGYs/cl-charms";)
+ (synopsis "Interface to libcurses in Common Lisp")
(description
- "Varjo is a Lisp to GLSL compiler. Vari is the dialect of lisp Varjo
-compiles. It aims to be as close to Common Lisp as possible, but naturally it
-is statically typed so there are differences.")
- (license license:bsd-2))))
+ "@code{cl-charms} is an interface to libcurses in Common Lisp. It
+provides both a raw, low-level interface to libcurses via CFFI, and a more
+higher-level lispier interface.")
+ (license license:expat))))
-(define-public ecl-varjo
- (sbcl-package->ecl-package sbcl-varjo))
+(define-public cl-charms
+ (sbcl-package->cl-source-package sbcl-cl-charms))
-(define-public cl-varjo
- (sbcl-package->cl-source-package sbcl-varjo))
+(define-public ecl-cl-charms
+ (sbcl-package->ecl-package sbcl-cl-charms))
-(define-public sbcl-cffi
- (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112")
- (revision "1"))
+(define-public sbcl-cl-collider
+ (let ((commit "a46908896982868955b29bfb3a5337a0af489b0b")
+ (revision "0"))
(package
- (name "sbcl-cffi")
- (version (git-version "0.24.1" revision commit))
- (source
+ (name "sbcl-cl-collider")
+ (version (git-version "2018.7.15" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cffi/cffi";)
+ (url "https://github.com/byulparan/cl-collider";)
(commit commit)))
- (file-name (git-file-name "cl-cffi" version))
+ (file-name (git-file-name "cl-collider" version))
(sha256
- (base32 "1h7cw15f08gm6m4yz8hk7qkfwp7mwwnykjc5py6dhjakv0wh1g37"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list libffi
- sbcl-alexandria
- sbcl-babel
- sbcl-trivial-features))
- (native-inputs
- (list pkg-config
- sbcl-bordeaux-threads
- sbcl-rt))
- (arguments
+ (base32 "10wvjbwvbgr0b57hpfxycg90yjmb29pirygr1sxrdaqxll328sz1"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
(list #:phases
#~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
+ (add-after 'unpack 'patch-executables-and-paths
(lambda* (#:key inputs #:allow-other-keys)
- (substitute* "libffi/libffi.lisp"
- (("libffi.so.8" all)
- (search-input-file inputs (string-append "/lib/"
all))))
- (substitute* "toolchain/c-toolchain.lisp"
- (("\"cc\"")
- (format #f "~S" (which "gcc"))))))
- (add-after 'build 'install-headers
- (lambda _
- (install-file "grovel/common.h"
- (string-append #$output
- "/include/grovel")))))
- #:asd-systems ''("cffi"
- "cffi-libffi"
- "cffi-uffi-compat")))
- (home-page "https://common-lisp.net/project/cffi/";)
- (synopsis "Common Foreign Function Interface for Common Lisp")
- (description "The Common Foreign Function Interface (CFFI)
-purports to be a portable foreign function interface for Common Lisp.
-The CFFI library is composed of a Lisp-implementation-specific backend
-in the CFFI-SYS package, and a portable frontend in the CFFI
-package.")
- (license license:expat))))
-
-(define-public cl-cffi
- (sbcl-package->cl-source-package sbcl-cffi))
+ (substitute* "server.lisp"
+ (("/usr/local/lib/SuperCollider/plugins")
+ (search-input-directory
+ inputs "/lib/SuperCollider/plugins"))
+ (("/usr/local/share/SuperCollider/Extensions")
+ (search-input-directory
+ inputs "/share/SuperCollider/Extensions"))
+ (("which scsynth")
+ (string-append
+ "which "
+ (search-input-file inputs "/bin/scsynth")))
+ (("jack_connect")
+ (search-input-file inputs "/bin/jack_connect"))))))))
+ (inputs
+ (list jack-1
+ supercollider
+ sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-cl-ppcre
+ sbcl-flexi-streams
+ sbcl-ieee-floats ; sc-osc dependencies.
+ sbcl-named-readtables
+ sbcl-osc
+ sbcl-pileup
+ sbcl-simple-inferiors ; For ecl.
+ sbcl-split-sequence
+ sbcl-usocket))
+ (synopsis "SuperCollider client for CommonLisp")
+ (description "This package provides a SuperCollider client for
+Common Lisp.")
+ (home-page "https://github.com/byulparan/cl-collider/";)
+ (license license:public-domain))))
-(define-public ecl-cffi
- (sbcl-package->ecl-package sbcl-cffi))
+(define-public cl-collider
+ (sbcl-package->cl-source-package sbcl-cl-collider))
-(define-public sbcl-cffi-c-ref
- (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce")
- (revision "0"))
+(define-public ecl-cl-collider
+ (sbcl-package->ecl-package sbcl-cl-collider))
+
+(define-public sbcl-cl-colors
+ (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
(package
- (name "sbcl-cffi-c-ref")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cl-colors")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/borodust/cffi-c-ref";)
+ (url "https://github.com/tpapp/cl-colors";)
(commit commit)))
(sha256
- (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z"))
- (file-name (git-file-name "cffi-c-ref" version))))
+ (base32
+ "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
+ (file-name (git-file-name "cl-colors" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-cffi))
- (synopsis "Streamlined access to foreign memory")
+ (list sbcl-alexandria sbcl-let-plus))
+ (synopsis "Simple color library for Common Lisp")
(description
- "This Common Lisp library provides macros to access foreign memory.")
- (home-page "https://github.com/borodust/cffi-c-ref";)
- (license license:expat))))
-
-(define-public cl-cffi-c-ref
- (sbcl-package->cl-source-package sbcl-cffi-c-ref))
+ "This is a very simple color library for Common Lisp, providing
-(define-public ecl-cffi-c-ref
- (sbcl-package->ecl-package sbcl-cffi-c-ref))
+@itemize
+@item Types for representing colors in HSV and RGB spaces.
+@item Simple conversion functions between the above types (and also
+hexadecimal representation for RGB).
+@item Some predefined colors (currently X11 color names – of course the
+library does not depend on X11).Because color in your terminal is nice.
+@end itemize
-(define-public sbcl-ffa
- (let ((commit "b7012f51c4c37d1e759ff9cf78cea178504d8e07")
- (revision "1"))
- (package
- (name "sbcl-ffa")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tpapp/ffa";)
- (commit commit)))
- (file-name (git-file-name "cl-ffa" version))
- (sha256
- (base32 "0l7kqcjp3sn1129hpwq6zhjqc0ydx9gc53z7k13i38x3z1asap7a"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cffi sbcl-cl-utilities sbcl-iterate sbcl-metabang-bind))
- (synopsis "Foreign friendly arrays for Common Lisp")
- (description
- "This package provides a macro that allows foreign functions to access
-the contents of the array at a given pointer, using the best available method
-given the Common Lisp implementation.")
- (home-page "https://cliki.net/ffa";)
- (license license:llgpl))))
+This library is no longer supported by its author.")
+ (home-page "https://github.com/tpapp/cl-colors";)
+ (license license:boost1.0))))
-(define-public cl-ffa
- (sbcl-package->cl-source-package sbcl-ffa))
+(define-public cl-colors
+ (sbcl-package->cl-source-package sbcl-cl-colors))
-(define-public ecl-ffa
- (sbcl-package->ecl-package sbcl-ffa))
+(define-public ecl-cl-colors
+ (sbcl-package->ecl-package sbcl-cl-colors))
-(define-public sbcl-cl-sqlite
+(define-public sbcl-cl-colors2
(package
- (name "sbcl-cl-sqlite")
- (version "0.2.1")
+ (name "sbcl-cl-colors2")
+ (version "0.6.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dmitryvk/cl-sqlite";)
- (commit version)))
- (file-name (git-file-name "cl-sqlite" version))
+ (url "https://codeberg.org/cage/cl-colors2";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-colors2" version))
(sha256
- (base32
- "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k"))))
+ (base32 "0vnvlq9xixs04768q7hapsi16cjp3ych6mypvs6chihd5dal4cnd"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("iterate" ,sbcl-iterate)
- ("cffi" ,sbcl-cffi)
- ("sqlite" ,sqlite)))
(native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- `(#:asd-systems '("sqlite")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "sqlite-ffi.lisp"
- (("libsqlite3" all) (string-append
- (assoc-ref inputs "sqlite")"/lib/"
all))))))))
- (home-page "https://common-lisp.net/project/cl-sqlite/";)
- (synopsis "Common Lisp binding for SQLite")
+ (list sbcl-clunit2))
+ (inputs
+ (list sbcl-alexandria sbcl-cl-ppcre sbcl-parse-number))
+ (synopsis "Color library for Common Lisp")
(description
- "The @command{cl-sqlite} package is an interface to the SQLite embedded
-relational database engine.")
- (license license:public-domain)))
+ "This is a very simple color library for Common Lisp, providing:
-(define-public cl-sqlite
- (sbcl-package->cl-source-package sbcl-cl-sqlite))
+@itemize
+@item Types for representing colors in HSV, HSL, and RGB spaces.
+@item Simple conversion functions between the above types.
+@item Function printing colors to HEX, RGB, RGBA, and HSL.
+@item Predefined colors from X11, SVG, and GDK.
+@end itemize\n")
+ (home-page "https://codeberg.org/cage/cl-colors2";)
+ (license license:boost1.0)))
-(define-public ecl-cl-sqlite
- (sbcl-package->ecl-package sbcl-cl-sqlite))
+(define-public cl-colors2
+ (sbcl-package->cl-source-package sbcl-cl-colors2))
-(define-public sbcl-cl-raylib
- (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d")
- (revision "0"))
+(define-public ecl-cl-colors2
+ (sbcl-package->ecl-package sbcl-cl-colors2))
+
+(define-public sbcl-cl-conspack
+ (let ((commit "6e529d7b3a7223ef1bb5c7b9f18384ba67b50b09")
+ (revision "2"))
(package
- (name "sbcl-cl-raylib")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-conspack")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/conspack/cl-conspack";)
+ (commit commit)))
+ (file-name (git-file-name "cl-conspack" version))
+ (sha256
+ (base32 "0y5wp5c89ph44k2xjppy1c1jf2ac3q9yrk22da2rkwnbxn0h1a8d"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-test-systems '("cl-conspack-test")))
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-fast-io
+ sbcl-ieee-floats
+ sbcl-trivial-garbage
+ sbcl-trivial-utf-8))
+ (home-page "https://github.com/conspack/cl-conspack";)
+ (synopsis "CONSPACK implementation for Common Lisp")
+ (description
+ "This package provides a CONSPACK implementation for Common Lisp.")
+ (license license:bsd-3))))
+
+(define-public cl-conspack
+ (sbcl-package->cl-source-package sbcl-cl-conspack))
+
+(define-public ecl-cl-conspack
+ (sbcl-package->ecl-package sbcl-cl-conspack))
+
+(define-public sbcl-cl-cont
+ (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-cont")
+ (version (git-version "0.3.8" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/longlene/cl-raylib";)
+ (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git";)
(commit commit)))
- (file-name (git-file-name "cl-raylib" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1kighj35g6dn426mhr2ppz3gm49v1q4n42ydn619pclrqwyrnc2z"))))
+ (base32
+ "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; no tests https://github.com/longlene/cl-raylib/issues/40
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libraylib\\.so")
- (search-input-file inputs "/lib/libraylib.so"))))))))
(inputs
- (list raylib
- sbcl-3d-matrices
- sbcl-3d-vectors
- sbcl-alexandria
- sbcl-cffi))
- (home-page "https://github.com/longlene/cl-raylib";)
- (synopsis "Common Lisp bindings to raylib")
- (description "This package provides Common Lisp CFFI bindings to the
-Raylib game development library.")
- (license license:expat))))
+ (list sbcl-alexandria sbcl-closer-mop))
+ (native-inputs
+ (list sbcl-rt))
+ (synopsis "Delimited continuations for Common Lisp")
+ (description
+ "This is a library that implements delimited continuations by
+transforming Common Lisp code to continuation passing style.")
+ (home-page "https://common-lisp.net/project/cl-cont/";)
+ (license license:llgpl))))
-(define-public cl-raylib
- (sbcl-package->cl-source-package sbcl-cl-raylib))
+(define-public cl-cont
+ (sbcl-package->cl-source-package sbcl-cl-cont))
-(define-public ecl-cl-raylib
- (sbcl-package->ecl-package sbcl-cl-raylib))
+(define-public ecl-cl-cont
+ (sbcl-package->ecl-package sbcl-cl-cont))
-(define-public sbcl-cl-redis
- (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d")
- (revision "0"))
+(define-public sbcl-cl-containers
+ (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f")
+ (revision "4"))
(package
- (name "sbcl-cl-redis")
- (version (git-version "2.3.8" revision commit))
+ (name "sbcl-cl-containers")
+ (version (git-version "0.12.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vseloved/cl-redis";)
+ (url "https://github.com/hraban/cl-containers";)
(commit commit)))
- (file-name (git-file-name "cl-redis" version))
+ (file-name (git-file-name "cl-containers" version))
(sha256
- (base32 "0x5ahxb5cx37biyn3cjycshhm1rr9p5cf1a9l5hd1n1xjxm2f8vi"))))
+ (base32
+ "1nrql8s1j123v5gscy99lxvhlzp0ijig9x94w30v3lwfa58hf90l"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lift))
+ (inputs
+ (list sbcl-asdf-system-connections
+ sbcl-metatilities-base
+ sbcl-moptilities))
(arguments
- '(#:phases
+ '(#:asd-systems '("cl-containers"
+ "cl-containers/with-moptilities"
+ "cl-containers/with-utilities")
+ #:phases
(modify-phases %standard-phases
- (add-before 'check 'start-redis
+ (add-after 'unpack 'relax-version-checks
(lambda _
- (system "redis-server --port 6379 &"))))))
- (native-inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("redis" ,redis)
- ("should-test" ,sbcl-should-test)))
- (inputs
- `(("babel" ,sbcl-babel)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("rutils" ,sbcl-rutils)
- ("usocket" ,sbcl-usocket)))
- (home-page "https://github.com/vseloved/cl-redis";)
- (synopsis "Common Lisp client for Redis")
- (description "This is a Common Lisp wrapper for interacting with the
-Redis data structure store.")
+ (substitute* "cl-containers.asd"
+ (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
+ "\"metatilities-base\""))
+ (substitute* "cl-containers-test.asd"
+ (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
+ "\"lift\""))
+ #t)))))
+ (synopsis "Container library for Common Lisp")
+ (description
+ "Common Lisp ships with a set of powerful built in data structures
+including the venerable list, full featured arrays, and hash-tables.
+CL-containers enhances and builds on these structures by adding containers
+that are not available in native Lisp (for example: binary search trees,
+red-black trees, sparse arrays and so on), and by providing a standard
+interface so that they are simpler to use and so that changing design
+decisions becomes significantly easier.")
+ (home-page "https://common-lisp.net/project/cl-containers/";)
(license license:expat))))
-(define-public cl-redis
- (sbcl-package->cl-source-package sbcl-cl-redis))
+(define-public cl-containers
+ (sbcl-package->cl-source-package sbcl-cl-containers))
-(define-public ecl-cl-redis
- (let ((pkg (sbcl-package->ecl-package sbcl-cl-redis)))
+(define-public ecl-cl-containers
+ (sbcl-package->ecl-package sbcl-cl-containers))
+
+(define-public sbcl-cl-cookie
+ (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
+ (revision "1"))
(package
- (inherit pkg)
+ (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
+ (list sbcl-prove))
(arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; Tests are failing on ECL with:
- ;; Test L-COMMANDS: An error occurred during initialization:
- ;; Protocol not found: "tcp".
- ((#:tests? _ #f) #f))))))
+ '(#:asd-systems '("cl-cookie-test" "cl-cookie")))
+ (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-parenscript
- ;; Source archives are overwritten on every release, we use the Git repo
instead.
- (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
+(define-public cl-cookie
+ (sbcl-package->cl-source-package sbcl-cl-cookie))
+
+(define-public ecl-cl-cookie
+ (sbcl-package->ecl-package sbcl-cl-cookie))
+
+(define-public sbcl-cl-coroutine
+ (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
+ (revision "1"))
(package
- (name "sbcl-parenscript")
- (version (git-version "2.7.1" "1" commit))
+ (name "sbcl-cl-coroutine")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/parenscript/parenscript";)
+ (url "https://github.com/takagi/cl-coroutine";)
(commit commit)))
- (file-name (git-file-name "parenscript" version))
+ (file-name (git-file-name name version))
(sha256
(base32
- "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
+ "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-ppcre sbcl-anaphora sbcl-named-readtables))
- (home-page "https://common-lisp.net/project/parenscript/";)
- (synopsis "Translator from a subset of Common Lisp to JavaScript")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-cont" ,sbcl-cl-cont)))
+ (native-inputs
+ (list sbcl-prove))
+ (arguments
+ `(;; TODO: Fix the tests. They fail with:
+ ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "cl-coroutine-test.asd"
+ (("cl-test-more")
+ "prove"))
+ #t)))))
+ (synopsis "Coroutine library for Common Lisp")
(description
- "Parenscript is a translator from an extended subset of Common Lisp to
-JavaScript. Parenscript code can run almost identically on both the
-browser (as JavaScript) and server (as Common Lisp).
-
-Parenscript code is treated the same way as Common Lisp code, making the full
-power of Lisp macros available for JavaScript. This provides a web
-development environment that is unmatched in its ability to reduce code
-duplication and provide advanced meta-programming facilities to web
-developers.
-
-At the same time, Parenscript is different from almost all other \"language
-X\" to JavaScript translators in that it imposes almost no overhead:
-
-@itemize
-@item No run-time dependencies: Any piece of Parenscript code is runnable
-as-is. There are no JavaScript files to include.
-@item Native types: Parenscript works entirely with native JavaScript data
-types. There are no new types introduced, and object prototypes are not
-touched.
-@item Native calling convention: Any JavaScript code can be called without the
-need for bindings. Likewise, Parenscript can be used to make efficient,
-self-contained JavaScript libraries.
-@item Readable code: Parenscript generates concise, formatted, idiomatic
-JavaScript code. Identifier names are preserved. This enables seamless
-debugging in tools like Firebug.
-@item Efficiency: Parenscript introduces minimal overhead for advanced Common
-Lisp features. The generated code is almost as fast as hand-written
-JavaScript.
-@end itemize\n")
- (license license:bsd-3))))
+ "This is a coroutine library for Common Lisp implemented using the
+continuations of the @code{cl-cont} library.")
+ (home-page "https://github.com/takagi/cl-coroutine";)
+ (license license:llgpl))))
-(define-public cl-parenscript
- (sbcl-package->cl-source-package sbcl-parenscript))
+(define-public cl-coroutine
+ (sbcl-package->cl-source-package sbcl-cl-coroutine))
-(define-public ecl-parenscript
- (sbcl-package->ecl-package sbcl-parenscript))
+(define-public ecl-cl-coroutine
+ (sbcl-package->ecl-package sbcl-cl-coroutine))
-(define-public sbcl-cl-json
+(define-public sbcl-cl-cpus
(package
- (name "sbcl-cl-json")
- (version "0.6.0")
+ (name "sbcl-cl-cpus")
+ (version "0.0.3")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/cl-json";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-json" version))
- (sha256
- (base32 "12vakz47d1i7pywgb9cm2364fzykidc9m7l7b6n9lx0gn2qx9ar5"))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/muyinliu/cl-cpus";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-cpus" version))
+ (sha256
+ (base32 "0sdaff9hpsx7bpkkkqavmxmrrlc2d61gmqjjgn8xchncng4a0rf8"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/sharplispers/cl-json";)
- (synopsis "JSON encoder and decoder for Common-Lisp")
- (description "@command{cl-json} provides an encoder of Lisp objects
-to JSON format and a corresponding decoder of JSON data to Lisp
-objects. Both the encoder and the decoder are highly customizable; at the
-same time, the default settings ensure a very simple mode of operation,
-similar to that provided by @command{yason} or @command{st-json}.")
- (license license:expat)))
+ (inputs
+ (list sbcl-cffi))
+ (home-page "https://github.com/muyinliu/cl-cpus";)
+ (synopsis "Common Lisp feature to get number of CPUs")
+ (description
+ "This package provides a Common Lisp system which has only one function to
+return the CPU count of the current system.")
+ (license license:isc)))
-(define-public cl-json
- (sbcl-package->cl-source-package sbcl-cl-json))
+(define-public cl-cpus
+ (sbcl-package->cl-source-package sbcl-cl-cpus))
-(define-public ecl-cl-json
- (sbcl-package->ecl-package sbcl-cl-json))
+(define-public ecl-cl-cpus
+ (sbcl-package->ecl-package sbcl-cl-cpus))
-(define-public sbcl-cl-json-pointer
- (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c")
+(define-public sbcl-cl-cron
+ (let ((commit "092aef5d5666fb43c04258e4043f609670a20456")
(revision "0"))
(package
- (name "sbcl-cl-json-pointer")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-cron")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/y2q-actionman/cl-json-pointer";)
+ (url "https://github.com/ciel-lang/cl-cron";)
(commit commit)))
- (file-name (git-file-name "cl-json-pointer" version))
+ (file-name (git-file-name "cl-cron" version))
(sha256
- (base32 "0b7a755wc2ghsd1pv7d32877b21h4nssp41xs017anbmj55czb2h"))))
+ (base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; FIXME: Component "cl-json-pointer/test" not found.
- `(#:tests? #f
- #:asd-systems '("cl-json-pointer" "cl-json-pointer/synonyms")))
(inputs
- (list sbcl-alexandria
- sbcl-boost-json
- sbcl-cl-json
- sbcl-closer-mop
- sbcl-st-json))
- (home-page "https://github.com/y2q-actionman/cl-json-pointer";)
- (synopsis "JSON Pointer processor for Common Lisp")
- (description "
-This package provides a JSON
-Pointer (@url{https://tools.ietf.org/html/rfc6901,RFC6901}) implementation for
-Common Lisp. This libary aims to be independent from any JSON libraries (as
much
-as possible).")
- (license license:expat))))
+ (list sbcl-bordeaux-threads))
+ (home-page "https://github.com/ciel-lang/cl-cron/";)
+ (synopsis "Run cron like jobs in Common Lisp")
+ (description
+ "@code{cl-cron} is a simple tool that provides cron like facilities
+directly inside of Common Lisp.")
+ (license license:gpl3+))))
-(define-public cl-json-pointer
- (sbcl-package->cl-source-package sbcl-cl-json-pointer))
+(define-public cl-cron
+ (sbcl-package->cl-source-package sbcl-cl-cron))
-(define-public ecl-cl-json-pointer
- (sbcl-package->ecl-package sbcl-cl-json-pointer))
+(define-public ecl-cl-cron
+ (sbcl-package->ecl-package sbcl-cl-cron))
-(define-public sbcl-unix-opts
- (let ((commit "0e61f34b2ecf62288437810d4abb31e572048b04")
- (revision "1"))
+(define-public sbcl-cl-css
+ (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
(package
- (name "sbcl-unix-opts")
- (version (git-version "0.1.7" revision commit))
+ (name "sbcl-cl-css")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/libre-man/unix-opts";)
+ (url "https://github.com/inaimathi/cl-css/";)
(commit commit)))
- (file-name (git-file-name "unix-opts" version))
+ (file-name (git-file-name "cl-css" version))
(sha256
- (base32 "16mcqpzwrz808p9n3wwl99ckg3hg7yihw08y1i4l7c92aldbkasq"))))
+ (base32
+ "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/hankhero/cl-json";)
- (synopsis "Unix-style command line options parser")
+ (home-page "https://github.com/inaimathi/cl-css/";)
+ (synopsis "Non-validating, inline CSS generator for Common Lisp")
(description
- "This is a minimalistic parser of command line options. The main
-advantage of the library is the ability to concisely define command line
-options once and then use this definition for parsing and extraction of
-command line arguments, as well as printing description of command line
-options (you get --help for free). This way you don't need to repeat
-yourself. Also, @command{unix-opts} doesn't depend on anything and
-precisely controls the behavior of the parser via Common Lisp restarts.")
+ "This is a dead-simple, non validating, inline CSS generator for Common
+Lisp. Its goals are axiomatic syntax, simple implementation to support
+portability, and boilerplate reduction in CSS.")
(license license:expat))))
-(define-public cl-unix-opts
- (sbcl-package->cl-source-package sbcl-unix-opts))
+(define-public cl-css
+ (sbcl-package->cl-source-package sbcl-cl-css))
-(define-public ecl-unix-opts
- (sbcl-package->ecl-package sbcl-unix-opts))
+(define-public ecl-cl-css
+ (sbcl-package->ecl-package sbcl-cl-css))
-(define-public sbcl-trivial-garbage
- (let ((commit "3474f6414b73d4e3aa2d5c53080f4247a34f6380")
- (revision "0"))
+(define-public sbcl-cl-csv
+ (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
+ (revision "2"))
(package
- (name "sbcl-trivial-garbage")
- (version (git-version "0.21" revision commit))
+ (name "sbcl-cl-csv")
+ (version (git-version "1.0.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/trivial-garbage/trivial-garbage";)
+ (url "https://github.com/AccelerationNet/cl-csv";)
(commit commit)))
- (file-name (git-file-name "cl-trivial-garbage" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0rfwxvwg0kpcaa0hsi035yrkfdfks4bq8d9azmrww2f0rmv9g6sd"))))
+ (base32
+ "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
+ `(#:tests? #f))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-interpol" ,sbcl-cl-interpol)
+ ("iterate" ,sbcl-iterate)))
(native-inputs
- (list sbcl-rt))
- (home-page "https://common-lisp.net/project/trivial-garbage/";)
- (synopsis "Portable GC-related APIs for Common Lisp")
- (description "@command{trivial-garbage} provides a portable API to
-finalizers, weak hash-tables and weak pointers on all major implementations of
-the Common Lisp programming language.")
- (license license:public-domain))))
+ (list sbcl-lisp-unit2))
+ (synopsis "Common lisp library for comma-separated values")
+ (description
+ "This is a Common Lisp library providing functions to read/write CSV
+from/to strings, streams and files.")
+ (home-page "https://github.com/AccelerationNet/cl-csv";)
+ (license license:bsd-3))))
-(define-public cl-trivial-garbage
- (sbcl-package->cl-source-package sbcl-trivial-garbage))
+(define-public cl-csv
+ (sbcl-package->cl-source-package sbcl-cl-csv))
-(define-public ecl-trivial-garbage
- (sbcl-package->ecl-package sbcl-trivial-garbage))
+(define-public ecl-cl-csv
+ (sbcl-package->ecl-package sbcl-cl-csv))
-(define-public sbcl-ucons
- (let ((commit "d976810ef2b12a2caaf55bd0f258272e9b79f3be")
- (revision "0"))
+(define-public sbcl-cl-debug
+ (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31")
+ (revision "1"))
(package
- (name "sbcl-ucons")
+ (name "sbcl-cl-debug")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/kmx-io/cl-debug";)
+ (commit commit)))
+ (file-name (git-file-name "cl-debug" version))
+ (sha256
+ (base32 "0w5vxbjsgr3zfpivdmghmhzxskfdvm1p34c8whwps2xlhypxsa78"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/kmx-io/cl-debug";)
+ (synopsis "Common Lisp cross-package debugging facility")
+ (description
+ "CL-DEBUG provides a unified way to enable or disable debug-specific
code.
+Debugging code can be enabled or disabled relative to program features denoted
+by either a symbol or a keyword.")
+ (license license:isc))))
+
+(define-public cl-debug
+ (sbcl-package->cl-source-package sbcl-cl-debug))
+
+(define-public ecl-cl-debug
+ (sbcl-package->ecl-package sbcl-cl-debug))
+
+(define-public sbcl-cl-dejavu
+ (let ((commit "9d68ced4edee6f96fead42cb4835d0ff4a158373")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-dejavu")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/ucons";)
+ (url "https://github.com/dkochmanski/cl-dejavu";)
(commit commit)))
- (file-name (git-file-name "cl-ucons" version))
+ (file-name (git-file-name "cl-dejavu" version))
(sha256
- (base32 "17aj47pdjiywnf33hl46p27za2q0pq5ar3fpqxaqskggxrfxmijl"))))
+ (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-atomics
- sbcl-bordeaux-threads
- sbcl-named-readtables
- sbcl-trivia))
- (home-page "https://github.com/marcoheisig/ucons";)
- (synopsis "Unique conses for Common Lisp")
- (description "UCONS is a Common Lisp library providing unique conses.
-Unique conses are different from regular conses in that, in addition to their
-@code{car} and @code{cdr}, they maintain a table of past users. Also, the
-@code{cdr} of each ucons is restricted to other uconses or @code{nil}.
-Uconses are meant for those situations where even reusing regular conses (to
-avoid consing) is too computationally expensive.")
- (license license:expat))))
+ (home-page "https://github.com/dkochmanski/cl-dejavu";)
+ (synopsis "DejaVu fonts for Common Lisp")
+ (description
+ "This is a repackage of the original DejaVu Fonts with some convenience
+functions.")
+ (license (list license:cc0
+ (license:x11-style "http://dejavu-fonts.org/";))))))
-(define-public cl-ucons
- (sbcl-package->cl-source-package sbcl-ucons))
+(define-public cl-dejavu
+ (sbcl-package->cl-source-package sbcl-cl-dejavu))
-(define-public ecl-ucons
- (sbcl-package->ecl-package sbcl-ucons))
+(define-public ecl-dejavu
+ (sbcl-package->ecl-package sbcl-cl-dejavu))
-(define-public sbcl-clobber
- (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98")
+(define-public sbcl-cl-difflib
+ (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e")
(revision "0"))
(package
- (name "sbcl-clobber")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-difflib")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Clobber";)
+ (url "https://github.com/wiseman/cl-difflib";)
(commit commit)))
- (file-name (git-file-name "cl-clobber" version))
+ (file-name
+ (git-file-name name version))
(sha256
- (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n"))))
+ (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/robert-strandh/Clobber";)
- (synopsis "Common Lisp Library for transaction-oriented databases")
+ ;; Due to the age of this library tests use some deprecated
+ ;; functionality and keep failing.
+ (arguments
+ '(#:tests? #f))
+ (home-page "https://github.com/wiseman/cl-difflib";)
+ (synopsis "Compute differences between pairs of sequences")
(description
- "CLOBBER is an alternative to so-called @emph{object prevalence}, and in
-particular to @code{cl-prevalence}. Clobber is both simpler, more flexible,
and
-more robust than systems based on object prevalence.")
- (license license:bsd-2))))
+ "A Common Lisp library for computing differences between
+sequences based on the Python difflib module.")
+ (license license:expat))))
-(define-public cl-clobber
- (sbcl-package->cl-source-package sbcl-clobber))
+(define-public cl-difflib
+ (sbcl-package->cl-source-package sbcl-cl-difflib))
-(define-public ecl-clobber
- (sbcl-package->ecl-package sbcl-clobber))
+(define-public ecl-cl-difflib
+ (sbcl-package->ecl-package sbcl-cl-difflib))
-(define-public sbcl-closer-mop
- (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc")
- (revision "3"))
+(define-public sbcl-cl-diskspace
+ (let ((commit "2dce2d0387d58221c452bd76c7b9b7a7de81ef55")
+ (revision "1"))
(package
- (name "sbcl-closer-mop")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-diskspace")
+ (version (git-version "0.3.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pcostanza/closer-mop";)
+ (url "https://github.com/muyinliu/cl-diskspace";)
(commit commit)))
+ (file-name (git-file-name "cl-diskspace" version))
(sha256
- (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16"))
- (file-name (git-file-name "cl-closer-mop" version ))))
+ (base32 "0l19hxqw6b8i5i1jdbr45k1xib9axcwdagsp3y8wkb35g6wwc0s7"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pcostanza/closer-mop";)
- (synopsis "Rectifies absent or incorrect CLOS MOP features")
- (description "Closer to MOP is a compatibility layer that rectifies many
-of the absent or incorrect CLOS MOP features across a broad range of Common
-Lisp implementations.")
- (license license:expat))))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/unix/cl-diskspace-list-all-disks-with-df.lisp"
+ (("grep")
+ (search-input-file inputs "/bin/grep")))
+ (substitute* "src/unix/cl-diskspace-list-all-disks-with-df.lisp"
+ (("/bin/df")
+ (which "df")))
+ #t)))))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cffi" ,sbcl-cffi)
+ ("grep" ,grep)))
+ (home-page "https://github.com/muyinliu/cl-diskspace";)
+ (synopsis "Disk space information library for Common Lisp")
+ (description
+ "CL-DISKSPACE is a Common Lisp library to list disks with the command
+line tool @code{df} and get disk space information using @code{statvfs}.")
+ (license license:isc))))
-(define-public cl-closer-mop
- (sbcl-package->cl-source-package sbcl-closer-mop))
+(define-public cl-diskspace
+ (sbcl-package->cl-source-package sbcl-cl-diskspace))
-(define-public ecl-closer-mop
- (sbcl-package->ecl-package sbcl-closer-mop))
+(define-public ecl-cl-diskspace
+ (sbcl-package->ecl-package sbcl-cl-diskspace))
-(define-public sbcl-cl-cffi-gtk
- (let ((commit "1700fe672c65455c1fc33061ec92a3df84287ec7")
- (revision "3"))
+(define-public sbcl-cl-docutils
+ (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40")
+ (revision "1"))
(package
- (name "sbcl-cl-cffi-gtk")
- (version (git-version "3.8.8" revision commit))
+ (name "sbcl-cl-docutils")
+ (version (git-version "0.1.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/willijar/cl-docutils/";)
+ (commit commit)))
+ (file-name (git-file-name "cl-docutils" version))
+ (sha256
+ (base32
+ "132bxlj0jlhiabi29mygmkcbbgyb5s1yz1xdfhm3pgrf9f8605gg"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("docutils")))
+ (inputs
+ (list sbcl-cl-ppcre
+ sbcl-data-format-validation
+ sbcl-trivial-gray-streams))
+ (synopsis "Document utilities and Restructured text parser")
+ (description
+ "@code{cl-docutils} is a Common Lisp implementation of the Docutils text
+processing system for processing plaintext into presentational formats such as
+HTML and LaTeX. It is based upon the Python Docutils reference implementation
+but uses Common Lisp idioms making it easier to extend and more flexible. As
+with the reference implementation it includes a parser for the reStructured
+text plaintext markup syntax which is suitable for marking up documentation
+and for use as user markup for collaborative web sites. It is successfully
+used to support a higher education peer-review assessment and online tutorial
+system.")
+ (home-page "http://www.jarw.org.uk/lisp/cl-docutils.html";)
+ (license license:gpl3))))
+
+(define-public cl-docutils
+ (sbcl-package->cl-source-package sbcl-cl-docutils))
+
+(define-public ecl-cl-docutils
+ (sbcl-package->ecl-package sbcl-cl-docutils))
+
+(define-public sbcl-cl-dot
+ (let ((commit "73dfbb6e015a28ebed873266e4e8190e509b43de")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-dot")
+ (version (git-version "0.9.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/cl-cffi-gtk/";)
+ (url "https://github.com/michaelw/cl-dot";)
(commit commit)))
- (file-name (git-file-name "cl-cffi-gtk" version))
+ (file-name (git-file-name "cl-dot" version))
(sha256
- (base32 "1cn2f6b62axjzdzfv971218ably32dvqfdy499li25vjd8nb2qm3"))))
+ (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list cairo
- gdk-pixbuf
- glib
- gtk+
- pango
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-closer-mop
- sbcl-iterate
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (arguments
- (list
- ;; TODO: Tests fail with memory fault.
- ;; See https://github.com/Ferada/cl-cffi-gtk/issues/24.
- #:tests? #f
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "glib/glib.init.lisp"
- (("libglib-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all)))
- (("libgthread-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "gobject/gobject.init.lisp"
- (("libgobject-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "gio/gio.init.lisp"
- (("libgio-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "cairo/cairo.init.lisp"
- (("libcairo\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "pango/pango.init.lisp"
- (("libpango-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all)))
- (("libpangocairo-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "gdk-pixbuf/gdk-pixbuf.init.lisp"
- (("libgdk_pixbuf-[0-9.]*\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "gdk/gdk.init.lisp"
- (("libgdk-[0-9]\\.so" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "gdk/gdk.package.lisp"
- (("libgtk-[0-9]\\.so" all)
- (search-input-file inputs (string-append "/lib/"
all)))))))))
- (home-page "https://github.com/sharplispers/cl-cffi-gtk/";)
- (synopsis "Common Lisp binding for GTK+3")
+ (home-page "https://github.com/michaelw/cl-dot";)
+ (synopsis "Generate Graphviz dot output from arbitrary Lisp data")
(description
- "@command{cl-cffi-gtk} is a Lisp binding to GTK+ 3 (GIMP Toolkit) which
-is a library for creating graphical user interfaces.")
- (license license:lgpl3))))
+ "CL-DOT is a Common Lisp library for generating Graphviz dot output from
+arbitrary Lisp data.")
+ (license license:expat))))
-(define-public cl-cffi-gtk
- (sbcl-package->cl-source-package sbcl-cl-cffi-gtk))
+(define-public cl-dot
+ (sbcl-package->cl-source-package sbcl-cl-dot))
-(define-public ecl-cl-cffi-gtk
- (sbcl-package->ecl-package sbcl-cl-cffi-gtk))
+(define-public ecl-cl-dot
+ (sbcl-package->ecl-package sbcl-cl-dot))
-(define-public sbcl-cl-webkit
+(define-public sbcl-cl-emb
+ (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-emb")
+ (version (git-version "0.4.3" revision commit))
+ (home-page "https://common-lisp.net/project/cl-emb/";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/38a938c2/cl-emb";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cl-ppcre))
+ (synopsis "Templating system for Common Lisp")
+ (description "A mixture of features from eRuby and HTML::Template. You
+could name it \"Yet Another LSP\" (LispServer Pages) but it's a bit more than
+that and not limited to a certain server or text format.")
+ (license license:llgpl))))
+
+(define-public cl-emb
+ (sbcl-package->cl-source-package sbcl-cl-emb))
+
+(define-public ecl-cl-emb
+ (sbcl-package->ecl-package sbcl-cl-emb))
+
+(define-public sbcl-cl-environments
(package
- (name "sbcl-cl-webkit")
- (version "3.5.10")
+ (name "sbcl-cl-environments")
+ (version "0.4")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/joachifm/cl-webkit";)
- (commit version)))
- (file-name (git-file-name "cl-webkit" version))
+ (url "https://github.com/alex-gutev/cl-environments";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-environments" version))
(sha256
- (base32
- "0bn8idvbi58kg0g76lanvjzkgnkcy41yn9vbp7f80q9fa7w892rq"))))
+ (base32 "10jxj043d2dw5vc0i0lz0lsa4qszn8him5is8jdhl4nsyfcazmky"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("cffi" ,sbcl-cffi)
- ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
- ("webkitgtk" ,webkitgtk-for-gtk3)))
+ (list sbcl-alexandria sbcl-anaphora sbcl-collectors sbcl-optima))
(native-inputs
- `(;; Tests seem to need Xorg.
- ;; ("xorg-server" ,xorg-server-for-tests)
- ("calispel" ,sbcl-calispel)
- ("fiveam" ,sbcl-fiveam)
- ("float-features" ,sbcl-float-features)))
- (arguments
- `(#:asd-systems '("cl-webkit2")
- #:tests? #f ; TODO: Tests hang, why?
- #:phases
- (modify-phases %standard-phases
- ;; The following phase is needed for tests:
- ;; (add-before 'check 'start-xorg-server
- ;; (lambda* (#:key inputs #:allow-other-keys)
- ;; ;; The test suite requires a running X server.
- ;; (system (string-append (assoc-ref inputs "xorg-server")
- ;; "/bin/Xvfb :1 &"))
- ;; (setenv "DISPLAY" ":1")
- ;; #t))
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "webkit2/webkit2.init.lisp"
- (("libwebkit2gtk" all)
- (string-append
- (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
- (home-page "https://github.com/joachifm/cl-webkit";)
- (synopsis "Binding to WebKitGTK+ for Common Lisp")
+ (list sbcl-prove))
+ (home-page "https://github.com/alex-gutev/cl-environments";)
+ (synopsis "Implements the Common Lisp standard environment access API")
(description
- "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
-currently targeting WebKit version 2. The WebKitGTK+ library adds web
-browsing capabilities to an application, leveraging the full power of the
-WebKit browsing engine.")
+ "This library provides a uniform API, as specified in Common Lisp the
+Language 2, for accessing information about variable and function bindings
+from implementation-defined lexical environment objects. All major Common
+Lisp implementations are supported, even those which don't support the CLTL2
+environment access API.")
(license license:expat)))
-(define-public cl-webkit
- (sbcl-package->cl-source-package sbcl-cl-webkit))
+(define-public cl-environments
+ (sbcl-package->cl-source-package sbcl-cl-environments))
-(define-public ecl-cl-webkit
- (sbcl-package->ecl-package sbcl-cl-webkit))
+(define-public ecl-cl-environments
+ (sbcl-package->ecl-package sbcl-cl-environments))
-(define-public sbcl-lparallel
- (let ((commit "80fc2952a074776abd343d6b5d3ab157f0e1df7a")
+(define-public sbcl-cl-fad
+ ;; No release since 2019
+ (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535")
(revision "1"))
(package
- (name "sbcl-lparallel")
- (version (git-version "2.8.4" revision commit))
+ (name "sbcl-cl-fad")
+ (version (git-version "0.7.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/lparallel/";)
+ (url "https://github.com/edicl/cl-fad/";)
(commit commit)))
- (file-name (git-file-name "cl-lparallel" version))
(sha256
- (base32 "0nv2dx8cl25g68icqhw95yr5mygm86lcjzmzijql51na1p60g6y9"))))
+ (base32 "0a1xqldrq170lflnns3xp6swpnvsvllf5vq0h7sz8jqh4riqlny6"))
+ (file-name (git-file-name "cl-fad" version))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-cl-ppcre sbcl-unit-test))
(inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-trivial-garbage))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-dependency
- ;; lparallel loads a SBCL specific system in its asd file. This is
- ;; not carried over into the fasl which is generated. In order for
- ;; it to be carried over, it needs to be listed as a dependency.
- (lambda _
- (substitute* "lparallel.asd"
- ((":depends-on \\(:alexandria" all)
- (string-append all " #+sbcl :sb-cltl2"))))))))
- (home-page "https://lparallel.org/";)
- (synopsis "Parallelism for Common Lisp")
+ (list sbcl-alexandria sbcl-bordeaux-threads))
+ (synopsis "Portable pathname library for Common Lisp")
(description
- "@command{lparallel} is a library for parallel programming in Common
-Lisp, featuring:
-
-@itemize
-@item a simple model of task submission with receiving queue,
-@item constructs for expressing fine-grained parallelism,
-@item asynchronous condition handling across thread boundaries,
-@item parallel versions of map, reduce, sort, remove, and many others,
-@item promises, futures, and delayed evaluation constructs,
-@item computation trees for parallelizing interconnected tasks,
-@item bounded and unbounded FIFO queues,
-@item high and low priority tasks,
-@item task killing by category,
-@item integrated timeouts.
-@end itemize\n")
- (license license:expat))))
+ "CL-FAD (for \"Files and Directories\") is a thin layer atop Common
+Lisp's standard pathname functions. It is intended to provide some
+unification between current CL implementations on Windows, OS X, Linux, and
+Unix. Most of the code was written by Peter Seibel for his book Practical
+Common Lisp.")
+ (home-page "https://edicl.github.io/cl-fad/";)
+ (license license:bsd-2))))
-(define-public cl-lparallel
- (sbcl-package->cl-source-package sbcl-lparallel))
+(define-public cl-fad
+ (sbcl-package->cl-source-package sbcl-cl-fad))
-(define-public ecl-lparallel
- (sbcl-package->ecl-package sbcl-lparallel))
+(define-public ecl-cl-fad
+ (sbcl-package->ecl-package sbcl-cl-fad))
-(define-public sbcl-cl-markup
- (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
+(define-public sbcl-cl-fast-ecs
+ (package
+ (name "sbcl-cl-fast-ecs")
+ (version "0.2.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.com/lockie/cl-fast-ecs";)
+ (commit version)))
+ (file-name (git-file-name "cl-fast-ecs" version))
+ (sha256
+ (base32 "00nw5nwzcz8x1x1lycmjik8pcqzxrl896j0xjjl33rjljsmj45sx"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-chlorophyll sbcl-cl-mock sbcl-parachute))
+ (inputs
+ (list sbcl-alexandria sbcl-trivial-garbage))
+ (home-page "https://lockie.gitlab.io/cl-fast-ecs/";)
+ (synopsis "Blazingly fast Entity-Component-System microframework")
+ (description
+ "CL-FAST-ECS is a Common Lisp library providing an implementation of the
+@acronym{ECS, Entity-Component-System} pattern, primarily focused on speed and
+interactive development.
+
+ECS is an architectural data-oriented design pattern that allows for the
+effective processing of a large number of in-game objects while keeping the
code
+and data separated. This provides flexibility in the way that game objects are
+built at runtime.")
+ (license license:expat)))
+
+(define-public cl-fast-ecs
+ (sbcl-package->cl-source-package sbcl-cl-fast-ecs))
+
+(define-public ecl-cl-fast-ecs
+ (sbcl-package->ecl-package sbcl-cl-fast-ecs))
+
+(define-public sbcl-cl-fastcgi
+ (let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20")
+ (revision "2"))
(package
- (name "sbcl-cl-markup")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-cl-fastcgi")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/arielnetworks/cl-markup/";)
+ (url "https://github.com/KDr2/cl-fastcgi/";)
(commit commit)))
- (file-name (git-file-name "cl-markup" version))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
+ (base32 "0xgmhx766q4nmrvn5z7ag3ikpr9phlh8ypi8b14azshq9lqbq0m7"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/arielnetworks/cl-markup/";)
- (synopsis "Markup generation library for Common Lisp")
+ (inputs
+ `(("usocket" ,sbcl-usocket)
+ ("cffi" ,sbcl-cffi)
+ ("fcgi" ,fcgi)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "cl-fastcgi.lisp"
+ (("\"libfcgi.so\"")
+ (string-append
+ "\""
+ (assoc-ref inputs "fcgi") "/lib/libfcgi.so\""))))))))
+ (home-page "https://kdr2.com/project/cl-fastcgi.html";)
+ (synopsis "FastCGI wrapper for Common Lisp")
(description
- "A modern markup generation library for Common Lisp that features:
-
-@itemize
-@item Fast (even faster through compiling the code)
-@item Safety
-@item Support for multiple document types (markup, xml, html, html5, xhtml)
-@item Output with doctype
-@item Direct output to stream
-@end itemize\n")
- (license license:lgpl3+))))
+ "CL-FastCGI is a generic version of SB-FastCGI, targeting to run on
+mostly Common Lisp implementation.")
+ (license license:bsd-2))))
-(define-public cl-markup
- (sbcl-package->cl-source-package sbcl-cl-markup))
+(define-public cl-fastcgi
+ (sbcl-package->cl-source-package sbcl-cl-fastcgi))
-(define-public ecl-cl-markup
- (sbcl-package->ecl-package sbcl-cl-markup))
+(define-public ecl-cl-fastcgi
+ (sbcl-package->ecl-package sbcl-cl-fastcgi))
-;;; The following package is renamed from "markup" to "markup-reader" in order
-;;; not to conflict with the "cl-markup" package.
-(define-public sbcl-markup-reader
- (let ((commit "d2d4d7b073554f47c24223a9304452966608702e")
- (revision "1"))
+(define-public sbcl-cl-flac
+ (let ((commit "d094d33d3cc2cf263263b917798d338eded3c532")
+ (revision "0"))
(package
- (name "sbcl-markup-reader")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-flac")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/moderninterpreters/markup";)
+ (url "https://github.com/Shirakumo/cl-flac";)
(commit commit)))
- (file-name (git-file-name "markup-reader" version))
+ (file-name (git-file-name "cl-flac" version))
(sha256
- (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj"))))
+ (base32 "1dgr5xqf175hzq3sxpbixxia2k2g3rz0pn6msch4dnvk7a1naqlc"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Delete bundled libraries.
+ `(begin
+ (delete-file-recursively "static")))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-systems '("markup")))
- (native-inputs
- (list sbcl-fiveam))
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "low-level.lisp"
+ (("libflac.so")
+ (search-input-file inputs "/lib/libFLAC.so"))))))))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-str" ,sbcl-cl-str)
- ("named-readtables" ,sbcl-named-readtables)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (home-page "https://github.com/moderninterpreters/markup";)
- (synopsis "Reader-macro to read HTML tags inside of Common Lisp code")
- (description
- "Markup allows the use of HTML syntax with in Common Lisp code.
-This has the advantage of being able to copy HTML snippets and have them
-instantly be functional, less double quotes than a s-expression approach,
-and designers will be able to understand the embedded HTML.")
- (license license:asl2.0))))
-
-(define-public ecl-markup-reader
- (sbcl-package->ecl-package sbcl-markup-reader))
-
-(define-public cl-markup-reader
- (sbcl-package->cl-source-package sbcl-markup-reader))
-
-(define-public sbcl-xml-emitter
- (package
- (name "sbcl-xml-emitter")
- (version "1.1.0")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/VitoVan/xml-emitter";)
- (commit version)))
- (file-name (git-file-name "cl-xml-emitter" version))
- (sha256
- (base32
- "1w9yx8gc4imimvjqkhq8yzpg3kjrp2y37rjix5c1lnz4s7bxvhk9"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-1am))
- (inputs (list sbcl-cl-utilities))
- (synopsis "Common lisp library for emitting XML output")
- (description
- "This package provides functions to emit XML, with some complexity for
-handling indentation. It can be used to produce all sorts of useful XML
-output; it has an RSS 2.0 emitter built in, so you can make RSS feeds
-trivially.")
- (home-page "https://www.cliki.net/xml-emitter";)
- (license license:expat)))
+ (list flac
+ sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (home-page "https://shirakumo.github.io/cl-flac";)
+ (synopsis "CFFI bindings to libflac for Common Lisp")
+ (description "This package provides CFFI bindings to the @code{libflac}
+audio library for Common Lisp.")
+ (license license:zlib))))
-(define-public cl-xml-emitter
- (sbcl-package->cl-source-package sbcl-xml-emitter))
+(define-public cl-flac
+ (sbcl-package->cl-source-package sbcl-cl-flac))
-(define-public ecl-xml-emitter
- (sbcl-package->ecl-package sbcl-xml-emitter))
+(define-public ecl-cl-flac
+ (sbcl-package->ecl-package sbcl-cl-flac))
-(define-public sbcl-kdlcl
- (let ((commit "dd4a48a3473c3c8fb34d4a37f87d6a1776c5875c")
- (revision "0"))
+(define-public sbcl-cl-fond
+ (let ((commit "dac975cbc73f231b400d5b8d8539b16330239a4a")
+ (revision "1"))
(package
- (name "sbcl-kdlcl")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cl-fond")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/chee/kdlcl";)
+ (url "https://github.com/Shirakumo/cl-fond";)
(commit commit)))
- (file-name (git-file-name "cl-kdlcl" version))
+ (file-name (git-file-name "cl-fond" version))
(sha256
- (base32 "0bqqxkd6s420ld2hmhvbbvpzss0m2kimmxaqhz7j1ksmq86bvvmj"))))
+ (base32 "03ygcw1azb44bhdsqcq99xi4ci0by76ap5jf5l2d1vfxq04v8grq"))))
(build-system asdf-build-system/sbcl)
- (arguments `(#:asd-systems '("kdl")))
- (inputs (list sbcl-esrap sbcl-parse-number))
- (home-page "https://github.com/chee/kdlcl/";)
- (synopsis "KDL reader/printer for Common Lisp")
- (description "This package provides a KDL reader/writer for
- Common Lisp.")
- (license license:expat-0))))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-cl-opengl
+ sbcl-documentation-utils
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (home-page "https://shirakumo.github.io/cl-fond/";)
+ (synopsis "Bindings to libfond, a simple text rendering engine for
OpenGL")
+ (description "This is a Common Lisp bindings library to libfond, a
+simple OpenGL text rendering engine.")
+ (license license:zlib))))
-(define-public cl-kdlcl
- (sbcl-package->cl-source-package sbcl-kdlcl))
+(define-public cl-fond
+ (sbcl-package->cl-source-package sbcl-cl-fond))
-(define-public ecl-kdlcl
- (sbcl-package->ecl-package sbcl-kdlcl))
+(define-public ecl-cl-fond
+ (sbcl-package->ecl-package sbcl-cl-fond))
-(define-public sbcl-cl-mustache
+(define-public sbcl-cl-form-types
(package
- (name "sbcl-cl-mustache")
- (version "0.12.1")
+ (name "sbcl-cl-form-types")
+ (version "0.3.2")
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/kanru/cl-mustache";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-mustache" version))
- (sha256
- (base32 "149xbb6wxq1napliwm9cv729hwcgfnjli6y8hingfixz7f10lhks"))))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/cl-form-types";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0k4j657vfh4zblp9a7d3z15r82yyz4fzqh8vfn2s7ljsj1dmhp2n"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/kanru/cl-mustache";)
- (synopsis "Common Lisp Mustache template renderer")
- (description "This is a Common Lisp implementation for the Mustache
-template system. More details on the standard are available at
-@url{https://mustache.github.io}.";)
+ (inputs
+ (list sbcl-agutil
+ sbcl-anaphora
+ sbcl-arrows
+ sbcl-cl-environments
+ sbcl-introspect-environment
+ sbcl-optima))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/alex-gutev/cl-form-types";)
+ (synopsis "Determine the types of Common Lisp forms")
+ (description "This library provides functions for determining the value
+types of Common Lisp forms, based on type information contained in the
+environment.
+
+In order for this library to work the values types of variables and return
+types of functions have to be declared.
+
+Macros and symbol-macros are fully expanded and all special forms, except
+@code{CATCH}, are supported.")
(license license:expat)))
-(define-public cl-mustache
- (sbcl-package->cl-source-package sbcl-cl-mustache))
+(define-public cl-form-types
+ (sbcl-package->cl-source-package sbcl-cl-form-types))
-(define-public ecl-cl-mustache
- (sbcl-package->ecl-package sbcl-cl-mustache))
+(define-public ecl-cl-form-types
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-form-types)))
+ (package
+ (inherit pkg)
+ (arguments
+ ;; FIXME: Syntax error in declaration (TYPE T (FORM &KEY STRICT
+ ;; EXPAND-COMPILER-MACROS (TEST (QUOTE FORM-TYPE=))))
+ ;; An error occurred during initialization: COMPILE-FILE-ERROR while...
+ ;; See <https://github.com/alex-gutev/cl-form-types/issues/22>.
+ '(#:tests? #f)))))
-(define-public sbcl-cl-css
- (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
+(define-public sbcl-cl-freetype2
+ (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04")
+ (revision "1"))
(package
- (name "sbcl-cl-css")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-cl-freetype2")
+ (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/inaimathi/cl-css/";)
+ (url "https://github.com/rpav/cl-freetype2";)
(commit commit)))
- (file-name (git-file-name "cl-css" version))
+ (file-name (git-file-name "cl-freetype2" version))
(sha256
- (base32
- "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
+ (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/inaimathi/cl-css/";)
- (synopsis "Non-validating, inline CSS generator for Common Lisp")
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list freetype
+ sbcl-alexandria
+ sbcl-cffi
+ sbcl-trivial-garbage))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/ffi/ft2-lib.lisp"
+ (("\"libfreetype\"")
+ (string-append "\"" (assoc-ref inputs "freetype")
+ "/lib/libfreetype\"")))
+ (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
+ (("-I/usr/include/freetype")
+ (string-append "-I" (assoc-ref inputs "freetype")
+ "/include/freetype")))
+ #t)))))
+ (home-page "https://github.com/rpav/cl-freetype2";)
+ (synopsis "Common Lisp bindings for Freetype 2")
(description
- "This is a dead-simple, non validating, inline CSS generator for Common
-Lisp. Its goals are axiomatic syntax, simple implementation to support
-portability, and boilerplate reduction in CSS.")
- (license license:expat))))
+ "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
+geared toward both using Freetype directly by providing a simplified API, as
+well as providing access to the underlying C structures and functions for use
+with other libraries which may also use Freetype.")
+ (license license:bsd-3))))
-(define-public cl-css
- (sbcl-package->cl-source-package sbcl-cl-css))
+(define-public cl-freetype2
+ (sbcl-package->cl-source-package sbcl-cl-freetype2))
-(define-public ecl-cl-css
- (sbcl-package->ecl-package sbcl-cl-css))
+(define-public ecl-cl-freetype2
+ (sbcl-package->ecl-package sbcl-cl-freetype2))
-(define-public sbcl-portable-threads
- (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df"))
+(define-public sbcl-cl-gamepad
+ (let ((commit "d5b99fbaa2e39294d23061699e8f1e761eda7205")
+ (revision "3"))
(package
- (name "sbcl-portable-threads")
- (version (git-version "2.3" "2" commit))
+ (name "sbcl-cl-gamepad")
+ (version (git-version "3.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/binghe/portable-threads/";)
+ (url "https://github.com/Shirakumo/cl-gamepad";)
(commit commit)))
- (file-name (git-file-name "portable-threads" version))
+ (file-name (git-file-name "cl-gamepad" version))
(sha256
- (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs"))))
+ (base32 "0y6kg9wq92p07i1chm1v7j7p77iqc5c985pdvmmivcip8zmd4hm4"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(;; Tests seem broken.
- #:tests? #f))
- (home-page "https://github.com/binghe/portable-threads";)
- (synopsis "Portable threads API for Common Lisp")
+ `(#:tests? #f ; No tests
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-evdev-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "evdev-cffi.lisp"
+ (("libevdev.so")
+ (search-input-file inputs "/lib/libevdev.so"))))))))
+ (inputs
+ (list libevdev
+ sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-trivial-features))
+ (home-page "https://shirakumo.github.io/cl-gamepad/";)
+ (synopsis "Library for access to gamepads and joystick input devices")
(description
- "Portable Threads (and Scheduled and Periodic Functions) API for Common
-Lisp (from GBBopen project).")
- (license license:asl2.0))))
-
-(define-public cl-portable-threads
- (sbcl-package->cl-source-package sbcl-portable-threads))
+ "This is a library to provide cross-platform access to gamepads,
+joysticks, and other such HID devices.")
+ (license license:zlib))))
-(define-public ecl-portable-threads
- (sbcl-package->ecl-package sbcl-portable-threads))
+(define-public cl-gamepad
+ (sbcl-package->cl-source-package sbcl-cl-gamepad))
-(define-public sbcl-usocket
- (package
- (name "sbcl-usocket")
- (version "0.8.6")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/usocket/usocket/";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-usocket" version))
- (sha256
- (base32 "0by8hhg6gijdbq5vjykd374rmvqyikp4synpyk0wjcl7rk3r0vgn"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-rt))
- (inputs
- (list sbcl-bordeaux-threads sbcl-split-sequence))
- (arguments
- `(#:tests? #f ; FIXME: Tests need network access?
- #:asd-systems '("usocket"
- "usocket-server")))
- (home-page "https://common-lisp.net/project/usocket/";)
- (synopsis "Universal socket library for Common Lisp")
- (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)))
+(define-public ecl-cl-gamepad
+ (sbcl-package->ecl-package sbcl-cl-gamepad))
-(define-public cl-usocket
- (sbcl-package->cl-source-package sbcl-usocket))
+(define-public sbcl-cl-geometry
+ (let ((commit "24eddedc47b931cec27361752736ef0b54fc9984"))
+ (package
+ (name "sbcl-cl-geometry")
+ (version (git-version "0.0.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/vydd/cl-geometry";)
+ (commit commit)))
+ (file-name (git-file-name "cl-cl-geometry" version))
+ (sha256
+ (base32 "188xrd8plvc34gz7q01zmkdrzxbpwzln103l5dl78pa4a6vzz34h"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-iterate
+ sbcl-trees))
+ (home-page "https://github.com/lispgames/cl-geometry/";)
+ (synopsis "Simple two dimensional computational geometry in Common Lisp")
+ (description
+ "This is a system for two dimensional computational geometry for Common
Lisp.
-(define-public ecl-usocket
- (sbcl-package->ecl-package sbcl-usocket))
+Note: the system assumes exact rational arithmetic, so no floating point
+coordinates are allowed. This is not checked when creating geometric
+objects.")
+ ;; The .asd says BSD-style but the LICENSE.txt is expat.
+ (license license:expat))))
-(define-public sbcl-trivial-sockets
- (package
- (name "sbcl-trivial-sockets")
- (version "0.4")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/usocket/trivial-sockets/";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-trivial-sockets" version))
- (sha256
- (base32 "0xj9x5z3psxqap9c29qz1xswx5fiqxyzd35kmbw2g6z08cgb7nd0"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/usocket/trivial-sockets";)
- (synopsis "Simple socket library for Common Lisp")
- (description
- "This library is a portable socket interface that allows CL programs to
-open connected (client) stream sockets to network services.")
- (license license:expat)))
+(define-public cl-cl-geometry
+ (sbcl-package->cl-source-package sbcl-cl-geometry))
-(define-public cl-trivial-sockets
- (sbcl-package->cl-source-package sbcl-trivial-sockets))
+(define-public ecl-cl-geometry
+ (sbcl-package->ecl-package sbcl-cl-geometry))
-(define-public sbcl-s-xml
- (package
- (name "sbcl-s-xml")
- (version "3")
- (source
- (origin
- (method url-fetch)
- (uri "https://common-lisp.net/project/s-xml/s-xml.tgz";)
- (sha256
- (base32
- "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://common-lisp.net/project/s-xml/";)
- (synopsis "Simple XML parser implemented in Common Lisp")
- (description
- "S-XML is a simple XML parser implemented in Common Lisp. This XML
-parser implementation has the following features:
-
-@itemize
-@item It works (handling many common XML usages).
-@item It is very small (the core is about 700 lines of code, including
-comments and whitespace).
-@item It has a core API that is simple, efficient and pure functional, much
-like that from SSAX (see also http://ssax.sourceforge.net).
-@item It supports different DOM models: an XSML-based one, an LXML-based one
-and a classic xml-element struct based one.
-@item It is reasonably time and space efficient (internally avoiding garbage
-generatation as much as possible).
-@item It does support CDATA.
-@item It should support the same character sets as your Common Lisp
-implementation.
-@item It does support XML name spaces.
-@end itemize
-
-This XML parser implementation has the following limitations:
-
-@itemize
-@item It does not support any special tags (like processing instructions).
-@item It is not validating, even skips DTD's all together.
-@end itemize\n")
- (license license:lgpl3+)))
+(define-public sbcl-cl-glfw3
+ (let ((commit "32c3f34d592d55ee7ce932ed85804c1a9c4158c6")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-glfw3")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/AlexCharlton/cl-glfw3";)
+ (commit commit)))
+ (file-name (git-file-name "cl-glfw3" version))
+ (sha256
+ (base32 "1wzr43nckdx4rlgxzhm1r4kfc264q969mc43y0js9ramh7l8gba5"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-glfw-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "glfw-bindings.lisp"
+ (("libglfw.so.3" _)
+ (search-input-file inputs "/lib/libglfw.so.3"))))))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-opengl" ,sbcl-cl-opengl)
+ ("glfw" ,glfw)
+ ("trivial-main-thread" ,sbcl-trivial-main-thread)))
+ (home-page "https://github.com/AlexCharlton/cl-glfw3";)
+ (synopsis "Common Lisp bindings to GLFW version 3.x")
+ (description
+ "This package provides a Common Lisp bindings to @code{glfw}, an OpenGL
+application development library.")
+ (license license:bsd-2))))
-(define-public cl-s-xml
- (sbcl-package->cl-source-package sbcl-s-xml))
+(define-public cl-glfw3
+ (sbcl-package->cl-source-package sbcl-cl-glfw3))
-(define-public ecl-s-xml
- (sbcl-package->ecl-package sbcl-s-xml))
+(define-public ecl-cl-glfw3
+ (sbcl-package->ecl-package sbcl-cl-glfw3))
-(define-public sbcl-s-xml-rpc
- (package
- (name "sbcl-s-xml-rpc")
- (version "7")
- (source
- (origin
- (method url-fetch)
- (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz";)
- (sha256
- (base32
- "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-s-xml))
- (home-page "https://common-lisp.net/project/s-xml-rpc/";)
- (synopsis "Implementation of XML-RPC in Common Lisp for both client and
server")
- (description
- "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
-client and server.")
- (license license:lgpl3+)))
+(define-public sbcl-cl-glib
+ (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-glib")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/bohonghuang/cl-glib";)
+ (commit commit)))
+ (file-name (git-file-name "cl-glib" version))
+ (sha256
+ (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" ))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject")))
+ (inputs
+ (list glib
+ gobject-introspection
+ sbcl-bordeaux-threads
+ sbcl-cl-gobject-introspection-wrapper))
+ (home-page "https://github.com/bohonghuang/cl-glib";)
+ (synopsis "Glib, GIO and Gobject bindings for Common Lisp")
+ (description "This library provides Glib, GIO and Gobject bindings for
+Common Lisp via Gobject Introspection.")
+ (license license:lgpl3+))))
-(define-public cl-s-xml-rpc
- (sbcl-package->cl-source-package sbcl-s-xml-rpc))
+(define-public cl-glib
+ (sbcl-package->cl-source-package sbcl-cl-glib))
-(define-public ecl-s-xml-rpc
- (sbcl-package->ecl-package sbcl-s-xml-rpc))
+(define-public ecl-cl-glib
+ (sbcl-package->ecl-package sbcl-cl-glib))
-(define-public sbcl-trivial-arguments
- (let ((commit "ecd84ed9cf9ef8f1e873d7409e6bd04979372aa7")
+(define-public sbcl-cl-gltf
+ (let ((commit "7a3af05a7f491d8973b217f096806ef12a97474b")
(revision "1"))
(package
- (name "sbcl-trivial-arguments")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-cl-gltf")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/trivial-arguments";)
+ (url "https://github.com/Shirakumo/cl-gltf";)
(commit commit)))
- (file-name (git-file-name "trivial-arguments" version))
+ (file-name (git-file-name "cl-gltf" version))
(sha256
- (base32 "02vaqfavhj8jqxnr68nnzvzshm8jbgcy6m9lvyv4daa6f7ihqf88"))))
+ (base32 "1d64fg2l2c0wns3wpp1xypd8687gnp3k70fv9fb48m1kpzg4kvrh"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/Shinmera/trivial-arguments";)
- (synopsis "Common Lisp library to retrieve a function's lambda-list")
+ (arguments
+ ;; No tests provided.
+ `(#:tests? #f))
+ (inputs
+ (list sbcl-documentation-utils
+ sbcl-cffi
+ sbcl-jzon
+ sbcl-mmap
+ sbcl-nibbles
+ sbcl-qbase64
+ sbcl-static-vectors
+ sbcl-trivial-extensible-sequences))
+ (home-page "https://shirakumo.github.io/cl-gltf/";)
+ (synopsis "Common Lisp parser for glTF file format")
(description
- "This is a simple library to retrieve the argument list of a function.")
+ "This package provides a Common Lisp parser for glTF file format.")
(license license:zlib))))
-(define-public ecl-trivial-arguments
- (sbcl-package->ecl-package sbcl-trivial-arguments))
+(define-public cl-gltf
+ (sbcl-package->cl-source-package sbcl-cl-gltf))
-(define-public cl-trivial-arguments
- (sbcl-package->cl-source-package sbcl-trivial-arguments))
+;; FIXME: ECL part is failing
+;; ;;; Internal error:
+;;
+;; ** There is no package with the name SEQUENCE.An error occurred during
+;; initialization: COMPILE-FILE-ERROR while compiling #<cl-source-file
+;; "trivial-extensible-sequences" "fallback">.
+;;
+;; See <https://github.com/Shirakumo/cl-gltf/issues/3>
+;;
+;; (define-public ecl-cl-gltf
+;; (sbcl-package->ecl-package sbcl-cl-gltf))
-(define-public sbcl-trivial-clipboard
- (let ((commit "aee67d6132a46237f61d508ae4bd9ff44032566d")
- (revision "7"))
+(define-public sbcl-cl-gobject-introspection
+ (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9")
+ (revision "3"))
(package
- (name "sbcl-trivial-clipboard")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-gobject-introspection")
+ (version (git-version "0.3" revision commit))
+ (home-page "https://github.com/andy128k/cl-gobject-introspection";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/snmsts/trivial-clipboard";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-trivial-clipboard" version))
+ (file-name (git-file-name "cl-gobject-introspection" version))
(sha256
- (base32 "029qmx523xfk54p99ndgbmdd20s5i32mzpf77xymngrn4c33v9jk"))))
+ (base32 "0xwmj4b3whz12i474g54krp1v6h0fpvsx8lgwpk6rkli9xc71wc3"))))
(build-system asdf-build-system/sbcl)
(inputs
- ;; Pick xsel instead of xclip because its closure size is slightly
- ;; smaller.
- (list wl-clipboard xsel))
+ (list glib
+ gobject-introspection
+ sbcl-alexandria
+ sbcl-cffi
+ sbcl-iterate
+ sbcl-trivial-garbage))
(native-inputs
(list sbcl-fiveam))
(arguments
- `(#:phases
+ '(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/text.lisp"
- (("\"xsel\"")
- (string-append "\"" (assoc-ref inputs "xsel") "/bin/xsel\""))
- (("\"wl-copy\"")
- (string-append "\""
- (assoc-ref inputs "wl-clipboard")
- "/bin/wl-copy\""))
- (("\"wl-paste\"")
- (string-append "\""
- (assoc-ref inputs "wl-clipboard")
- "/bin/wl-paste\""))))))))
- (home-page "https://github.com/snmsts/trivial-clipboard";)
- (synopsis "Access system clipboard in Common Lisp")
+ (substitute* "src/init.lisp"
+ (("libgobject-2\\.0\\.so")
+ (search-input-file inputs "/lib/libgobject-2.0.so"))
+ (("libgirepository-1\\.0\\.so")
+ (search-input-file inputs
+ "/lib/libgirepository-1.0.so"))))))))
+ (synopsis "Common Lisp bindings to GObject Introspection")
(description
- "@command{trivial-clipboard} gives access to the system clipboard.")
- (license license:expat))))
+ "This library is a bridge between Common Lisp and GObject
+Introspection, which enables Common Lisp programs to access the full interface
+of C+GObject libraries without the need of writing dedicated bindings.")
+ (license (list license:bsd-3
+ ;; Tests are under a different license.
+ license:llgpl)))))
-(define-public cl-trivial-clipboard
- (sbcl-package->cl-source-package sbcl-trivial-clipboard))
+(define-public cl-gobject-introspection
+ (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
-(define-public ecl-trivial-clipboard
- (sbcl-package->ecl-package sbcl-trivial-clipboard))
+(define-public ecl-cl-gobject-introspection
+ (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
-(define-public sbcl-trivial-backtrace
- (let ((commit "7f90b4a4144775cca0728791e4b92ac2557b07a1")
- (revision "2"))
- (package
- (name "sbcl-trivial-backtrace")
- (version (git-version "1.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/hraban/trivial-backtrace";)
- (commit commit)))
- (file-name (git-file-name "trivial-backtrace" version))
- (sha256
- (base32 "11j0p3vgmnn5q84xw7sacr5p3cvff2hfhsh2is8xpm2iwxc723kn"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lift))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'check 'delete-test-results
- (lambda* (#:key outputs #:allow-other-keys)
- (let ((test-results (string-append (assoc-ref outputs "out")
- "/share/common-lisp/"
- (%lisp-type)
- "/trivial-backtrace"
- "/test-results")))
- (when (file-exists? test-results)
- (delete-file-recursively test-results)))
- #t)))))
- (home-page "https://common-lisp.net/project/trivial-backtrace/";)
- (synopsis "Portable simple API to work with backtraces in Common Lisp")
- (description
- "One of the many things that didn't quite get into the Common Lisp
-standard was how to get a Lisp to output its call stack when something has
-gone wrong. As such, each Lisp has developed its own notion of what to
-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:expat))))
-
-(define-public cl-trivial-backtrace
- (sbcl-package->cl-source-package sbcl-trivial-backtrace))
-
-(define-public ecl-trivial-backtrace
- (sbcl-package->ecl-package sbcl-trivial-backtrace))
-
-(define-public sbcl-rfc2388
- (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
+(define-public sbcl-cl-gobject-introspection-wrapper
+ (let ((commit "2d197cba7e7d734ac8a2e181e5e709e5b218bada")
(revision "1"))
(package
- (name "sbcl-rfc2388")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jdz/rfc2388";)
- (commit commit)))
- (file-name (git-file-name "rfc2388" version))
- (sha256
- (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/jdz/rfc2388/";)
- (synopsis "Implementation of RFC 2388 in Common Lisp")
- (description
- "This package contains an implementation of RFC 2388, which is used to
-process form data posted with HTTP POST method using enctype
-\"multipart/form-data\".")
- (license license:bsd-2))))
-
-(define-public cl-rfc2388
- (sbcl-package->cl-source-package sbcl-rfc2388))
-
-(define-public ecl-rfc2388
- (sbcl-package->ecl-package sbcl-rfc2388))
-
-(define-public sbcl-md5
- (package
- (name "sbcl-md5")
- (version "2.0.5")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/pmai/md5";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name "md5" version))
- (sha256
- (base32 "1g20np6rhn3y08z8mlmlk721mw2207s52v2pwp4smm3lz25sx3q5"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pmai/md5";)
- (synopsis
- "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC
1321)")
- (description
- "This package implements The MD5 Message-Digest Algorithm, as defined in
-RFC 1321 by R. Rivest, published April 1992.")
- (license license:public-domain)))
+ (name "sbcl-cl-gobject-introspection-wrapper")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url
"https://github.com/bohonghuang/cl-gobject-introspection-wrapper";)
+ (commit commit)))
+ (file-name (git-file-name "cl-gobject-introspection-wrapper" version))
+ (sha256
+ (base32 "05np2zs5806ib6qfz7d6knyaz6llxgwvjqavl1fsz5hcga40296s"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cl-gobject-introspection
+ sbcl-cl-ppcre))
+ (home-page
+ "https://github.com/bohonghuang/cl-gobject-introspection-wrapper";)
+ (synopsis
+ "Wrap and call GObject Introspection FFI function in Common Lisp")
+ (description
+ "This library converts the elements from GObject Introspection into
+Common Lisp-style definitions, based on cl-gobject-introspection.")
+ (license license:lgpl3+))))
-(define-public cl-md5
- (sbcl-package->cl-source-package sbcl-md5))
+(define-public cl-gobject-introspection-wrapper
+ (sbcl-package->cl-source-package sbcl-cl-gobject-introspection-wrapper))
-(define-public ecl-md5
- (package
- (inherit (sbcl-package->ecl-package sbcl-md5))
- (inputs
- (list ecl-flexi-streams))))
+(define-public ecl-cl-gobject-introspection-wrapper
+ (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper))
-(define-public sbcl-cl+ssl
- (let ((commit "17d5cdd65405f1d26e26f3e875e70027d0c8eedb")
- (revision "6"))
+(define-public sbcl-cl-gopher
+ (let ((commit "0899e7fa2134206f9d9778c7d53c49b7a59ff070")
+ (revision "3"))
(package
- (name "sbcl-cl+ssl")
+ (name "sbcl-cl-gopher")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-plus-ssl/cl-plus-ssl";)
+ (url "https://github.com/knusbaum/cl-gopher";)
(commit commit)))
- (file-name (git-file-name "cl+ssl" version))
+ (file-name (git-file-name "cl-gopher" version))
(sha256
- (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s"))))
+ (base32 "1ky4s33m5d0wvdaqji12pxr93qqfl5x62zjp3m4ihbdj0ws3yw2f"))
+ (snippet
+ '(begin
+ ;; These files are mostly examples (that assume Quicklisp) which
+ ;; drag the SBCL package into the CL package.
+ (for-each delete-file
+ '("cl-gopher-network.lsh"
+ "cl-gopher-start.lsh"))
+ #t))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/reload.lisp"
- (("libssl.so" all)
- (string-append
- (assoc-ref inputs "openssl") "/lib/" all))
- (("libcrypto.so" all)
- (string-append
- (assoc-ref inputs "openssl") "/lib/" all)))))
- (add-after 'fix-paths 'fix-tests
- (lambda _
- ;; Disable coverall support in tests because of a circular
- ;; dependency: cl+ssl -> cl-coverall -> dexador
- ;; -> clack -> hunchentoot -> cl+ssl
- (substitute* "cl+ssl.test.asd"
- (("\\(:feature \\(:or :sbcl :ccl\\) :cl-coveralls\\)")
- "")))))))
- (native-inputs
- (list ;sbcl-cl-coveralls
- sbcl-fiveam
- sbcl-trivial-sockets))
(inputs
- (list openssl
- sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cffi
+ (list sbcl-bordeaux-threads
+ sbcl-drakma
sbcl-flexi-streams
- sbcl-trivial-features
- sbcl-trivial-garbage
- sbcl-trivial-gray-streams
+ sbcl-quri
+ sbcl-split-sequence
sbcl-usocket))
- (home-page "https://common-lisp.net/project/cl-plus-ssl/";)
- (synopsis "Common Lisp bindings to OpenSSL")
+ (home-page "https://github.com/knusbaum/cl-gopher";)
+ (synopsis "Gopher protocol library in Common Lisp")
(description
- "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
-code was written by Eric Marsden and includes contributions by Jochen Schmidt.
-Development into CL+SSL was done by David Lichteblau.")
- (license license:expat))))
+ "@code{cl-gopher} is a Common Lisp library for interacting with the
+Gopher protocol.
-(define-public cl-cl+ssl
- (sbcl-package->cl-source-package sbcl-cl+ssl))
+It is suitable for building both clients and servers, and provides a sample
+client.")
+ (license license:bsd-2))))
-(define-public ecl-cl+ssl
- ;; The trivial-sockets system used for the tests doesn't support ECL, so we
- ;; remove it from native-inputs and disable the tests.
- (let ((pkg (sbcl-package->ecl-package sbcl-cl+ssl)))
- (package
- (inherit pkg)
- (native-inputs
- (modify-inputs (package-native-inputs pkg)
- (delete "sbcl-trivial-sockets")))
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:tests? _ #f) #f))))))
+(define-public cl-gopher
+ (sbcl-package->cl-source-package sbcl-cl-gopher))
-(define-public sbcl-kons-9
- (let ((commit "fe0b3228ca28c316457d35f9e7c67edc83b2a4cc")
- (revision "0"))
+(define-public ecl-cl-gopher
+ (sbcl-package->ecl-package sbcl-cl-gopher))
+
+(define-public sbcl-cl-graph
+ (let ((commit "c617de35390cb02db88bc5b5febffafdb8947ae8")
+ (revision "2"))
(package
- (name "sbcl-kons-9")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-graph")
+ (version (git-version "0.10.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/kaveh808/kons-9";)
+ (url "https://github.com/hraban/cl-graph";)
(commit commit)))
- (file-name (git-file-name "cl-kons-9" version))
+ (file-name (git-file-name "cl-graph" version))
(sha256
- (base32 "1kdwva4qj1s5vmbv6gbmpnk56ahaf8n2kvij5xjlfyk7nriy4bbi"))))
+ (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("kons-9")
- #:asd-test-systems '("kons-9/testsuite")))
+ ;; TODO: (Sharlatan-20221118T215839+0000): Tests failed
+ ;;
+ ;; https://github.com/gwkkwg/cl-graph/issues/17
+ ;;
+ `(#:tests? #f
+ #:asd-systems '("cl-graph" "cl-graph+hu.dwim.graphviz")))
(native-inputs
- (list sbcl-alexandria sbcl-confidence))
+ (list sbcl-lift sbcl-moptilities))
(inputs
- (list sbcl-closer-mop
- sbcl-cffi
- sbcl-cl-glfw3
- sbcl-cl-opengl
- sbcl-cl-vectors
- sbcl-clobber
- sbcl-origin
- sbcl-trivial-backtrace
- sbcl-trivial-main-thread
- sbcl-zpb-ttf))
- (home-page "https://github.com/kaveh808/kons-9";)
- (synopsis "Common Lisp 3D graphics system")
- (description
- "This package provides KONS-9 which can be considered as a traditional
user
-interface driven 3D application for general artists, or as a REPL-based
-development environment for technical artists and software developers. These
two
-approaches can be seamlessly combined into a flexible and powerful workflow,
-where non-technical users can immediately benefit from software tools and
-extensions developed by technical users.")
- (license (list license:expat
- ;; lib/JMC-font-libs/font-master
- ;; lib/JMC-font-libs/font-zpb-ttf-master
- license:lgpl2.1)))))
-
-(define-public cl-kons-9
- (sbcl-package->cl-source-package sbcl-kons-9))
-
-;; TODO: (Sharlatan-20221110T230620+0000): ECL is not supported yet.
-;; https://github.com/kaveh808/kons-9/issues/176
-;; (define-public ecl-kons-9
-;; (sbcl-package->ecl-package sbcl-kons-9))
-
-(define-public sbcl-kmrcl
- (let ((version "1.111")
- (commit "4a27407aad9deb607ffb8847630cde3d041ea25a")
- (revision "1"))
- (package
- (name "sbcl-kmrcl")
- (version (git-version version revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://git.kpe.io/kmrcl.git/";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "06gx04mah5nc8w78s0j8628divbf1s5w7af8w7pvzb2d5mgvrbd2"))
- (modules '((guix build utils)))
- (snippet
- ;; The useless bundled debian folder drags `make' into the closure.
- `(begin
- (delete-file-recursively "debian")
- #t))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-rt))
- (home-page "http://files.kpe.io/kmrcl/";)
- (synopsis "General utilities for Common Lisp programs")
+ (list sbcl-cl-containers
+ sbcl-cl-mathstats
+ sbcl-dynamic-classes
+ sbcl-hu.dwim.graphviz
+ sbcl-metabang-bind
+ sbcl-metacopy
+ sbcl-metatilities-base))
+ (home-page "https://github.com/gwkkwg/cl-graph";)
+ (synopsis "Graph manipulation utilities for Common Lisp")
(description
- "KMRCL is a collection of utilities used by a number of Kevin
-Rosenberg's Common Lisp packages.")
- (license license:llgpl))))
+ "This package provides a Common Lisp library for manipulating graphs
+and running graph algorithms.")
+ (license license:expat))))
-(define-public cl-kmrcl
- (sbcl-package->cl-source-package sbcl-kmrcl))
+(define-public cl-cl-graph
+ (sbcl-package->cl-source-package sbcl-cl-graph))
-(define-public ecl-kmrcl
- (sbcl-package->ecl-package sbcl-kmrcl))
+;; NOTE: (Sharlatan-20221118T214734+0000): No ECL support
+;;
+;; ecl-cl-graph
-(define-public sbcl-cl-base64
- (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
+(define-public sbcl-cl-grnm
+ (let ((commit "778a312e9eb3d3de7541457b516ea3d9055a15aa")
+ (revision "0"))
(package
- (name "sbcl-cl-base64")
- (version (git-version "3.3.4" "1" commit))
+ (name "sbcl-cl-grnm")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://git.kpe.io/cl-base64.git/";)
+ (url "https://github.com/quil-lang/cl-grnm";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-grnm" version))
(sha256
- (base32 "12jj54h0fs6n237cvnp8v6hn0imfksammq22ys6pi0gwz2w47rbj"))
- (modules '((guix build utils)))
- (snippet
- ;; The useless bundled debian folder drags `make' into the closure.
- `(begin
- (delete-file-recursively "debian")
- #t))))
+ (base32 "1hb5n37n3x2ylrghcqsia2g9a6f5wg24l659jiz4ncpi5bsv4m3s"))))
(build-system asdf-build-system/sbcl)
- (native-inputs ; For tests.
- (list sbcl-ptester sbcl-kmrcl))
- (home-page "http://files.kpe.io/cl-base64/";)
- (synopsis
- "Common Lisp package to encode and decode base64 with URI support")
+ (synopsis "Common Lisp implementation of (grid restrained) Nelder-Mead")
(description
- "This package provides highly optimized base64 encoding and decoding.
-Besides conversion to and from strings, integer conversions are supported.
-Encoding with Uniform Resource Identifiers is supported by using a modified
-encoding table that uses only URI-compatible characters.")
- (license license:bsd-3))))
+ "These common lisp sources contain two variants of the Nelder-Mead
+algorithm. The original algorithm and a provably convergent, reliable variant
+by A. Bürmen et al, called the
+@acronym{GRNMA, Grid Restrained Nelder Mead Algorithm}.")
+ (home-page "https://github.com/quil-lang/cl-grnm";)
+ (license license:expat))))
-(define-public cl-base64
- (sbcl-package->cl-source-package sbcl-cl-base64))
+(define-public cl-grnm
+ (sbcl-package->cl-source-package sbcl-cl-grnm))
-(define-public ecl-cl-base64
- (sbcl-package->ecl-package sbcl-cl-base64))
+(define-public ecl-cl-grnm
+ (sbcl-package->ecl-package sbcl-cl-grnm))
-(define-public sbcl-chunga
+(define-public sbcl-cl-gserver
(package
- (name "sbcl-chunga")
- (version "1.1.7")
+ (name "sbcl-cl-gserver")
+ (version "1.8.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/chunga";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (url "https://github.com/mdbergmann/cl-gserver";)
+
+ ;; The "1.8.0" tag must have been moved from
+ ;; c83d92a66102faa514b546029a9bd2078b95dc0f to
+ ;; 90832f02f0556463e332cd055c3c1be58f323aea, 22 commits later!
+ (commit "c83d92a66102faa514b546029a9bd2078b95dc0f")))
+ (file-name (git-file-name "cl-gserver" version))
(sha256
- (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
+ (base32 "1bfz7z8v417dvsp1jz76ir3ihcs8g7zis2d56xx1dpzqzjd95g7z"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-trivial-gray-streams))
- (home-page "https://edicl.github.io/chunga/";)
- (synopsis "Portable chunked streams for Common Lisp")
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-lparallel
+ sbcl-cl-speedy-queue
+ sbcl-log4cl
+ sbcl-cl-str
+ sbcl-blackbird
+ sbcl-cl-hamt
+ sbcl-binding-arrows
+ sbcl-atomics))
+ (native-inputs
+ (list sbcl-fiveam sbcl-cl-mock))
+ (home-page "https://mdbergmann.github.io/cl-gserver/index.html";)
+ (synopsis "Actor framework for easy access to state and async operations")
(description
- "Chunga implements streams capable of chunked encoding on demand as
-defined in RFC 2616.")
- (license license:bsd-2)))
+ "@code{cl-gserver} is a 'message passing' library / framework with actors
+similar to Erlang or Akka. It supports creating reactive systems for parallel
+computing and event based message handling.")
+ (license license:agpl3)))
-(define-public cl-chunga
- (sbcl-package->cl-source-package sbcl-chunga))
+(define-public cl-gserver
+ (sbcl-package->cl-source-package sbcl-cl-gserver))
-(define-public ecl-chunga
- (sbcl-package->ecl-package sbcl-chunga))
+(define-public ecl-cl-gserver
+ (sbcl-package->ecl-package sbcl-cl-gserver))
-(define-public sbcl-cl-who
- (let ((version "1.1.4")
- (commit "07dafe9b351c32326ce20b5804e798f10d4f273d")
- (revision "3"))
+(define-public sbcl-cl-gss
+ (let ((commit "60086f4fd3b82316352e7f2288edbd58f03e08c5")
+ (revision "1"))
(package
- (name "sbcl-cl-who")
- (version (git-version version revision commit))
+ (name "sbcl-cl-gss")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/cl-who";)
+ (url "https://github.com/lokedhs/cl-gss";)
(commit commit)))
- (file-name (git-file-name "cl-who" version))
+ (file-name (git-file-name "cl-gss" version))
(sha256
- (base32
- "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5"))))
+ (base32 "0zhxxn3zarird255s9i56bz0fm6dkv00mn8bbsjrhskg3wpcg4pb"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-flexi-streams))
- (home-page "https://edicl.github.io/cl-who/";)
- (synopsis "Yet another Lisp markup language")
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'patch-gss-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/functions.lisp"
+ (("libgssapi_krb5.so")
+ (search-input-file inputs "/lib/libgssapi_krb5.so"))))))))
+ (inputs
+ (list mit-krb5
+ sbcl-cffi
+ sbcl-trivial-garbage
+ sbcl-trivial-utf-8))
+ (home-page "https://github.com/lokedhs/cl-gss";)
+ (synopsis "Common Lisp CFFI bindings to Generic Security Service (GSS)")
(description
- "There are plenty of Lisp Markup Languages out there - every Lisp
-programmer seems to write at least one during his career - and CL-WHO (where
-WHO means \"with-html-output\" for want of a better acronym) is probably just
-as good or bad as the next one.")
- (license license:bsd-2))))
+ "This package provides Common Lisp bindings to GSSAPI, which is
+designed to provide a standard API to authentication services. The API itself
+is generic, and the system can provide different underlying implementations.
+The most common one is Kerberos, which has several implementations, the most
+common of which is probably Active Directory.")
+ (license license:bsd-3))))
-(define-public cl-who
- (sbcl-package->cl-source-package sbcl-cl-who))
+(define-public cl-gss
+ (sbcl-package->cl-source-package sbcl-cl-gss))
-(define-public ecl-cl-who
- (sbcl-package->ecl-package sbcl-cl-who))
+(define-public ecl-cl-gss
+ (sbcl-package->ecl-package sbcl-cl-gss))
-(define-public sbcl-chipz
- (let ((version "0.8")
- (commit "82a17d39c78d91f6ea63a03aca8f9aa6069a5e11")
- (revision "2"))
+(define-public sbcl-cl-gtk4
+ (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4")
+ (revision "1"))
(package
- (name "sbcl-chipz")
- (version (git-version version revision commit))
+ (name "sbcl-cl-gtk4")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/chipz";)
+ (url "https://github.com/bohonghuang/cl-gtk4";)
(commit commit)))
- (file-name (git-file-name "cl-chipz" version))
+ (file-name (git-file-name "cl-gtk4" version))
(sha256
- (base32 "1n4f22i9j8iapjd6yx1z348rggcybvg9h794kx9libjgz4bs371h"))))
+ (base32 "0mprmmvbagnflvhynn51l42nbwr08rld99ls0c48m5lpjn0ja4zc"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-flexi-streams))
- (home-page "http://method-combination.net/lisp/chipz/";)
- (synopsis
- "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
-data")
+ (arguments
+ '(#:asd-systems '("cl-gtk4" "cl-gdk4")))
+ ;; propagate because it at least requires the typelib files at runtime
+ (propagated-inputs (list gtk))
+ (inputs
+ (list gobject-introspection
+ sbcl-cl-glib
+ sbcl-cl-gobject-introspection-wrapper))
+ (home-page "https://github.com/bohonghuang/cl-gtk4";)
+ (synopsis "GTK4 bindings for Common Lisp")
(description
- "DEFLATE data, defined in RFC1951, forms the core of popular
-compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
-Chipz also provides for decompressing data in those formats as well. BZIP2 is
-the format used by the popular compression tool bzip2.")
- ;; The author describes it as "MIT-like"
- (license license:expat))))
+ "This library provides GTK4 bindings for Common Lisp via Gobject
+Introspection, in the cl-gtk4 ASDF system.")
+ (license license:lgpl3))))
-(define-public cl-chipz
- (sbcl-package->cl-source-package sbcl-chipz))
+(define-public cl-gtk4
+ (sbcl-package->cl-source-package sbcl-cl-gtk4))
-(define-public ecl-chipz
- (sbcl-package->ecl-package sbcl-chipz))
+(define-public ecl-cl-gtk4
+ (sbcl-package->ecl-package sbcl-cl-gtk4))
-(define-public sbcl-cl-tls
- (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba")
- (revision "0"))
+(define-public sbcl-cl-hamt
+ ;; No release
+ (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208"))
(package
- (name "sbcl-cl-tls")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-hamt")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/shrdlu68/cl-tls";)
+ (url "https://github.com/danshapero/cl-hamt/";)
(commit commit)))
- (file-name (git-file-name "cl-tls" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7"))))
+ (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cl-base64
- sbcl-fast-io
- sbcl-ironclad))
- (home-page "https://github.com/shrdlu68/cl-tls";)
- (synopsis "Implementation of Transport Layer Security Protocols")
- (description "This package provides prototype Common Lisp
-implementations of TLS, RFC5246, ASN.1, x{501,509}, and PKCS{1,3,5,8}.")
+ (list sbcl-cl-murmurhash))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/danshapero/cl-hamt";)
+ (synopsis "Dictionary & set data structure using hash array-mapped
tries")
+ (description
+ "This library provides purely functional dictionaries and sets in
+Common Lisp based on the hash array-mapped trie data structure.")
(license license:bsd-3))))
-(define-public cl-tls
- (sbcl-package->cl-source-package sbcl-cl-tls))
+(define-public cl-hamt
+ (sbcl-package->cl-source-package sbcl-cl-hamt))
-(define-public ecl-cl-tls
- (sbcl-package->ecl-package sbcl-cl-tls))
+(define-public ecl-cl-hamt
+ (sbcl-package->ecl-package sbcl-cl-hamt))
-(define-public sbcl-dns-client
- (let ((commit "9f252e9c2bb61c57a6cd367e21ad366b0d3e87e0")
- (revision "0"))
+(define-public sbcl-cl-heap
+ (package
+ (name "sbcl-cl-heap")
+ (version "0.1.6")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/cl-heap/releases/";
+ "cl-heap_" version ".tar.gz"))
+ (sha256
+ (base32
+ "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-xlunit))
+ (arguments
+ '(#:asd-test-systems '("cl-heap-tests")))
+ (synopsis "Heap and priority queue data structures for Common Lisp")
+ (description
+ "CL-HEAP provides various implementations of heap data structures (a
+binary heap and a Fibonacci heap) as well as an efficient priority queue.")
+ (home-page "https://common-lisp.net/project/cl-heap/";)
+ (license license:gpl3+)))
+
+(define-public cl-heap
+ (sbcl-package->cl-source-package sbcl-cl-heap))
+
+(define-public ecl-cl-heap
+ (sbcl-package->ecl-package sbcl-cl-heap))
+
+(define-public sbcl-cl-hooks
+ (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
+ (revision "1"))
(package
- (name "sbcl-dns-client")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-hooks")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.2.1" revision commit))
+ (home-page "https://github.com/scymtym/architecture.hooks";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/dns-client";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-dns-client" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1b6g2wvydwmv1k68favjyq4gfalfxfyl5i0hyh640wdaz2rfvi4n"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; No tests provided.
- `(#:tests? #f))
+ (base32
+ "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
(inputs
- (list sbcl-documentation-utils sbcl-usocket))
- (home-page "https://shinmera.github.io/dns-client/";)
- (synopsis "DNS protocol client for Common Lisp")
- (description
- "This package provides a pure-lisp implementation of a DNS client. It
can be
-used to resolve hostnames, reverse-lookup IP addresses, and fetch other kinds
of
-DNS records.")
- (license license:zlib))))
+ (list sbcl-alexandria sbcl-let-plus sbcl-trivial-garbage
+ sbcl-closer-mop))
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "Hooks extension point mechanism (as in Emacs) for Common
Lisp")
+ (description "A hook, in the present context, is a certain kind of
+extension point in a program that allows interleaving the execution of
+arbitrary code with the execution of a the program without introducing any
+coupling between the two. Hooks are used extensively in the extensible editor
+Emacs.
-(define-public ecl-dns-client
- (sbcl-package->ecl-package sbcl-dns-client))
+In the Common LISP Object System (CLOS), a similar kind of extensibility is
+possible using the flexible multi-method dispatch mechanism. It may even seem
+that the concept of hooks does not provide any benefits over the possibilities
+of CLOS. However, there are some differences:
-(define-public cl-dns-client
- (sbcl-package->cl-source-package sbcl-dns-client))
+@itemize
-(define-public sbcl-lisp-pay
- (let ((commit "c4de776f0a284709931ff3674160ced3b41bd000")
+@item There can be only one method for each combination of specializers and
+qualifiers. As a result this kind of extension point cannot be used by
+multiple extensions independently.
+@item Removing code previously attached via a @code{:before}, @code{:after} or
+@code{:around} method can be cumbersome.
+@item There could be other or even multiple extension points besides
@code{:before}
+and @code{:after} in a single method.
+@item Attaching codes to individual objects using eql specializers can be
+cumbersome.
+@item Introspection of code attached a particular extension point is
+cumbersome since this requires enumerating and inspecting the methods of a
+generic function.
+@end itemize
+
+This library tries to complement some of these weaknesses of method-based
+extension-points via the concept of hooks.")
+ (license license:llgpl))))
+
+(define-public cl-hooks
+ (sbcl-package->cl-source-package sbcl-cl-hooks))
+
+(define-public ecl-cl-hooks
+ (sbcl-package->ecl-package sbcl-cl-hooks))
+
+(define-public sbcl-cl-html-diff
+ (let ((commit "5a0b39d1c524278d6f60851d7786bb2585614310")
(revision "0"))
(package
- (name "sbcl-lisp-pay")
- (version (git-version "0.0.5" revision commit))
+ (name "sbcl-cl-html-diff")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/K1D77A/lisp-pay";)
+ (url "https://github.com/wiseman/cl-html-diff";)
(commit commit)))
- (file-name (git-file-name "cl-lisp-pay" version))
+ (file-name
+ (git-file-name name version))
(sha256
- (base32 "09r6qy4fipriqa0d6g9qm6dq992lr58vh24g5j0adm19i5fnjavh"))))
+ (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cl-base64
- sbcl-cl-str
- sbcl-cl-tls
- sbcl-closer-mop
- sbcl-dexador
- sbcl-hu.dwim.defclass-star
- sbcl-hunchentoot
- sbcl-ironclad
- sbcl-jonathan
- sbcl-lack
- sbcl-ningle
- sbcl-shasht))
- (home-page "https://github.com/K1D77A/lisp-pay/";)
- (synopsis "Wrappers over multiple Payment Processor APIs")
- (description "This library provides payment API wrappers over
-BTCPay, Paypal, and Stripe.")
+ (list sbcl-cl-difflib))
+ (home-page "https://github.com/wiseman/cl-html-diff";)
+ (synopsis "Generate a human-readable diff of two HTML documents")
+ (description
+ "A Common Lisp library for generating a human-readable diff of two
+HTML documents.")
(license license:expat))))
-(define-public cl-lisp-pay
- (sbcl-package->cl-source-package sbcl-lisp-pay))
+(define-public cl-html-diff
+ (sbcl-package->cl-source-package sbcl-cl-html-diff))
-(define-public ecl-lisp-pay
- (sbcl-package->ecl-package sbcl-lisp-pay))
+(define-public ecl-cl-html-diff
+ (sbcl-package->ecl-package sbcl-cl-html-diff))
-(define-public sbcl-stripe
- (let ((commit "b59631d21d63e101de6eb96b56941471504ba644")
- (revision "0"))
+(define-public sbcl-cl-html5-parser
+ (let ((commit "74a92eb3a183a0afd089ea33350e816e6b9aeefa")
+ (revision "1"))
(package
- (name "sbcl-stripe")
+ (name "sbcl-cl-html5-parser")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/stripe";)
+ (url "https://github.com/rotatef/cl-html5-parser";)
(commit commit)))
- (file-name (git-file-name "cl-stripe" version))
+ (file-name (git-file-name "cl-html5-parser" version))
(sha256
- (base32 "00sfq2f6dnpwa6pf7rgw5hazbwx4yf1g0jrkfz9h4kq5zyxwk1cy"))))
+ (base32 "04if61wigylsmn996rbfl8ylsd0d9hzdmg7p2wiglncibjzcl5k9"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-json-streams sbcl-split-sequence sbcl-stefil))
(inputs
- (list sbcl-dexador
- sbcl-golden-utils
- sbcl-local-time
- sbcl-yason))
- (home-page "https://github.com/atlas-engineer/stripe";)
- (synopsis "Stripe payment API client for Common Lisp")
- (description "A client for the Stripe payment API.")
- (license license:expat))))
+ (list sbcl-cl-ppcre sbcl-flexi-streams sbcl-string-case))
+ (synopsis "HTML5 parser for Common Lisp")
+ (description "This a Common Lisp library to parse HTML5 documents.")
+ (home-page "https://github.com/rotatef/cl-html5-parser";)
+ (license license:lgpl3+))))
-(define-public cl-stripe
- (sbcl-package->cl-source-package sbcl-stripe))
+(define-public cl-html5-parser
+ (sbcl-package->cl-source-package sbcl-cl-html5-parser))
-(define-public ecl-stripe
- (sbcl-package->ecl-package sbcl-stripe))
+(define-public ecl-cl-html5-parser
+ (sbcl-package->ecl-package sbcl-cl-html5-parser))
-(define-public sbcl-drakma
- (package
- (name "sbcl-drakma")
- (version "2.0.8")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/drakma";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-drakma" version))
- (sha256
- (base32
- "1wf2zivfvhsh6zvd6wcwfd67bm8s8a1p2fismszc8xb819dqk9yl"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-puri
- sbcl-cl-base64
- sbcl-chunga
- sbcl-flexi-streams
- sbcl-cl-ppcre
- sbcl-chipz
- sbcl-usocket
- sbcl-cl+ssl))
- (native-inputs
- (list 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)))
-
-(define-public cl-drakma
- (sbcl-package->cl-source-package sbcl-drakma))
+(define-public sbcl-cl-https-everywhere
+ ;; No release.
+ ;; Don't forget to update the https-everywhere input.
+ (let ((commit "cbcc73b985a5b1c0ce0d4ec38bc982a0538d4bd8"))
+ (package
+ (name "sbcl-cl-https-everywhere")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ruricolist/cl-https-everywhere/";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wcvx1icwym1ncd6wl1wxzkyyndrm796caalbklvjd4a2cbl3xxi"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("global-vars" ,sbcl-global-vars)
+ ("parenscript" ,sbcl-parenscript)
+ ("cl-markdown" ,sbcl-cl-markdown)
+ ("cl-tld" ,sbcl-cl-tld)
+ ("fxml" ,sbcl-fxml)
+ ("overlord" ,sbcl-overlord)
+ ("ppcre" ,sbcl-cl-ppcre)
+ ("serapeum" ,sbcl-serapeum)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("vernacular" ,sbcl-vernacular)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("https-everywhere"
+ ,(let ((version "2021.7.13"))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/EFForg/https-everywhere";)
+ (commit version)))
+ (file-name (git-file-name "https-everywhere" version))
+ (sha256
+ (base32
+ "1k5gj29imhxf47sv3d8rxyrgr6k65scp2fm040va3nfshayslzia")))))))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'link-https-everywhere-repo
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((https-everywhere (assoc-ref inputs "https-everywhere")))
+ (symlink https-everywhere "https-everywhere"))))
+ (add-after 'unpack 'fix-overlord-build
+ ;; Upstream bugs? See
+ ;; https://github.com/ruricolist/cl-https-everywhere/issues/1.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (rulesets.xml (string-append out "/share/common-lisp/"
(%lisp-type)
+
"/cl-https-everywhere/rulesets.xml")))
+ (substitute* "build.lisp"
+ (("\\(depends-on https-everywhere-version\\)") "")
+ ;; Don't rebuild the rulesets just because the timestamp is
epoch.
+ (("\\(vernacular:require-default
:cl-https-everywhere/rulesets-file \"rulesets.xml\"\\)")
+ (format #f "(if (uiop:file-exists-p ~s)
+ (compile-rulesets ~s)
+ (vernacular:require-default :cl-https-everywhere/rulesets-file
\"rulesets.xml\"))"
+ rulesets.xml
+ rulesets.xml))
+ (("\\(uiop:parse-unix-namestring
\"https-everywhere/src/chrome/content/rules/\\*\\.xml\")")
+ "\"https-everywhere/src/chrome/content/rules/*.xml\"")
+ (("\\(out temp :external-format :utf-8\\)")
+ "(out temp :external-format :utf-8 :if-exists
:supersede)")))
+ #t)))))
+ (home-page "https://github.com/ruricolist/cl-https-everywhere/";)
+ (synopsis "Use HTTPS Everywhere rules from Lisp")
+ (description
+ "CL-HTTPS-EVERYWHERE parses HTTPS Everywhere rulesets and makes them
+available for use in Lisp programs.")
+ (license (list license:expat
+ ;; For the ruleset
+ license:gpl2+)))))
-(define-public ecl-drakma
- (sbcl-package->ecl-package sbcl-drakma))
+(define-public cl-https-everywhere
+ (sbcl-package->cl-source-package sbcl-cl-https-everywhere))
-(define-public sbcl-hunchentoot
- ;; NOTE: (Sharlatan-20220520T213309+0100): The latest commit fixed tests,
- ;; switch to the version tag when release is ready.
- (let ((commit "76862391040c20255c7275e815c2175e46bfd080")
- (revision "1"))
+(define-public sbcl-cl-i18n
+ (let ((commit "acb162a12dac50fc46d83da8934fce85d19e31c4")
+ (revision "3"))
(package
- (name "sbcl-hunchentoot")
- (version (git-version "1.3.0" revision commit))
+ (name "sbcl-cl-i18n")
+ (version (git-version "0.5.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/hunchentoot";)
+ (url "https://codeberg.org/cage/cl-i18n";)
(commit commit)))
- (file-name (git-file-name "cl-hunchentoot" version))
+ (file-name (git-file-name "cl-i18n" version))
(sha256
- (base32 "1h7ggmmzvgwr4p6j3ai0dqrw30q5309l13w4c03gqrapvwrb65l0"))))
+ (base32 "1y29cirmlyc406a45sdx39spvnjzbs772c977075ccicz46qaxz7"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-cl-who sbcl-drakma))
(inputs
- (list sbcl-chunga
- sbcl-cl-base64
- sbcl-cl-fad
- sbcl-cl-ppcre
- sbcl-flexi-streams
- sbcl-cl+ssl
- sbcl-md5
- sbcl-rfc2388
- sbcl-trivial-backtrace
- sbcl-usocket))
- (home-page "https://edicl.github.io/hunchentoot/";)
- (synopsis "Web server written in Common Lisp")
+ (list sbcl-alexandria sbcl-babel sbcl-cl-ppcre-unicode))
+ (synopsis "Internationalisation framework for Common Lisp")
(description
- "Hunchentoot is a web server written in Common Lisp and at the same
-time a toolkit for building dynamic websites. As a stand-alone web server,
-Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
-connections (keep-alive), and SSL.")
- (license license:bsd-2))))
+ "This is a Gettext-style internationalisation framework for Common
+Lisp.")
+ (home-page "https://codeberg.org/cage/cl-i18n";)
+ (license license:llgpl))))
-(define-public cl-hunchentoot
- (sbcl-package->cl-source-package sbcl-hunchentoot))
+(define-public cl-i18n
+ (sbcl-package->cl-source-package sbcl-cl-i18n))
-(define-public ecl-hunchentoot
- (package
- (inherit (sbcl-package->ecl-package sbcl-hunchentoot))
- (arguments
- ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'.
- '(#:tests? #f))))
+(define-public ecl-cl-i18n
+ (sbcl-package->ecl-package sbcl-cl-i18n))
-(define-public sbcl-hunchentoot-errors
- (let ((commit "69eb3bcea59ed1ccf3dd1960e6d48fb21f1dadab")
- (revision "0"))
+(define-public sbcl-cl-indentify
+ (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53"))
(package
- (name "sbcl-hunchentoot-errors")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-indentify")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/hunchentoot-errors";)
+ (url "https://github.com/yitzchak/cl-indentify";)
(commit commit)))
- (file-name (git-file-name "cl-hunchentoot-errors" version))
+ (file-name (git-file-name name commit))
(sha256
- (base32 "0fab7s8qhhs713cw014qqvzm5z61wmxm2fcbkarhg41cz3li9k1j"))))
+ (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-mimeparse
- sbcl-hunchentoot
- sbcl-parse-number
- sbcl-string-case))
- (home-page "https://github.com/mmontone/hunchentoot-errors/";)
- (synopsis "Hunchentoot error pages and logs with request and session
information")
+ (list sbcl-alexandria sbcl-command-line-arguments
+ sbcl-trivial-gray-streams))
+ (native-inputs
+ (list sbcl-trivial-escapes sbcl-rove))
+ (home-page "https://github.com/yitzchak/cl-indentify";)
+ (synopsis "Code beautifier for Common Lisp")
(description
- "This package provides a functionality augmenting Hunchentoot error
-pages and logs with request and session information.")
+ "A library and command line utility to automatically indent Common Lisp
+source files.")
(license license:expat))))
-(define-public cl-hunchentoot-errors
- (sbcl-package->cl-source-package sbcl-hunchentoot-errors))
+(define-public cl-indentify
+ (sbcl-package->cl-source-package sbcl-cl-indentify))
-(define-public ecl-hunchentoot-errors
- (sbcl-package->ecl-package sbcl-hunchentoot-errors))
+(define-public ecl-cl-indentify
+ (sbcl-package->ecl-package sbcl-cl-indentify))
-(define-public sbcl-lunamech-matrix-api
- (let ((commit "aa54a820149584c237b03d500ad83397fe25dc92")
- (revision "0"))
+(define-public sbcl-cl-inflector
+ (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
+ (revision "1"))
(package
- (name "sbcl-lunamech-matrix-api")
- (version (git-version "0.0.2" revision commit))
+ (name "sbcl-cl-inflector")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/K1D77A/lunamech-matrix-api";)
+ (url "https://github.com/AccelerationNet/cl-inflector";)
(commit commit)))
- (file-name (git-file-name "cl-lunamech-matrix-api" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0a664qq4m5gk4iv5ck63gmsl3218jhjsalawklj56wn2pw0cf8a0"))))
+ (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lisp-unit2))
(inputs
- (list sbcl-cl-json
- sbcl-cl-str
- sbcl-closer-mop
- sbcl-dexador
- sbcl-do-urlencode
- sbcl-drakma
- sbcl-jonathan
- sbcl-plump
- sbcl-quri
- sbcl-reader
- sbcl-shasht))
- (home-page "https://github.com/K1D77A/lunamech-matrix-api/";)
- (synopsis "Implementation of the Matrix API")
- (description "This package provides an implementation of the Matrix
-API for Common Lisp.")
+ (list sbcl-alexandria sbcl-cl-ppcre))
+ (home-page "https://github.com/AccelerationNet/cl-inflector";)
+ (synopsis "Library to pluralize/singularize English and Portuguese
words")
+ (description
+ "This is a common lisp library to easily pluralize and singularize
+English and Portuguese words. This is a port of the ruby ActiveSupport
+Inflector module.")
(license license:expat))))
-(define-public cl-lunamech-matrix-api
- (sbcl-package->cl-source-package sbcl-lunamech-matrix-api))
+(define-public cl-inflector
+ (sbcl-package->cl-source-package sbcl-cl-inflector))
-(define-public ecl-lunamech-matrix-api
- (sbcl-package->ecl-package sbcl-lunamech-matrix-api))
+(define-public ecl-cl-inflector
+ (sbcl-package->ecl-package sbcl-cl-inflector))
-(define-public sbcl-trivial-types
- (package
- (name "sbcl-trivial-types")
- (version "0.0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/trivial-types";)
- (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/m2ym/trivial-types";)
- (synopsis "Trivial type definitions for Common Lisp")
- (description
- "TRIVIAL-TYPES provides missing but important type definitions such as
-PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
- (license license:llgpl)))
-
-(define-public cl-trivial-types
- (sbcl-package->cl-source-package sbcl-trivial-types))
-
-(define-public ecl-trivial-types
- (sbcl-package->ecl-package sbcl-trivial-types))
-
-(define-public sbcl-cl-annot
- (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
- (revision "1"))
+(define-public sbcl-cl-ini
+ (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7")
+ (revision "0"))
(package
- (name "sbcl-cl-annot")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-ini")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/m2ym/cl-annot";)
+ (url "https://github.com/compufox/cl-ini";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "sbcl-cl-ini" version))
(sha256
- (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
+ (base32
+ "12vy3gspqn0wmkyz5id1xrgv1scgb16m7pkvmbmi19vlpj2iyq7p"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/m2ym/cl-annot";)
- (synopsis "Python-like Annotation Syntax for Common Lisp")
+ (native-inputs (list sbcl-prove))
+ (inputs (list sbcl-cl-str))
+ (home-page "https://github.com/compufox/cl-ini";)
+ (synopsis "INI file parser for Common Lisp")
(description
- "@code{cl-annot} is an general annotation library for Common Lisp.")
- (license license:llgpl))))
+ "Parse INI formatted files into a Common Lisp list structure.")
+ (license license:expat))))
-(define-public cl-annot
- (sbcl-package->cl-source-package sbcl-cl-annot))
+(define-public cl-ini
+ (sbcl-package->cl-source-package sbcl-cl-ini))
-(define-public ecl-cl-annot
- (sbcl-package->ecl-package sbcl-cl-annot))
+(define-public ecl-cl-ini
+ (sbcl-package->ecl-package sbcl-cl-ini))
-(define-public sbcl-cl-syntax
- (package
- (name "sbcl-cl-syntax")
- (version "0.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m2ym/cl-syntax";)
- (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
- (file-name (git-file-name "cl-syntax" version))
- (sha256
- (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-annot" ,sbcl-cl-annot)
- ("cl-interpol" ,sbcl-cl-interpol)
- ("named-readtables" ,sbcl-named-readtables)
- ("trivial-types" ,sbcl-trivial-types)))
- (arguments
- '(#:asd-systems '("cl-syntax"
- "cl-syntax-annot"
- "cl-syntax-interpol")))
- (home-page "https://github.com/m2ym/cl-syntax";)
- (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
- (description
- "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
- (license license:llgpl)))
+(define-public sbcl-cl-inotify
+ (let ((commit "66f29e01ec28355ebba8292411b4de90eebd76a3")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-inotify")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Ferada/cl-inotify";)
+ (commit commit)))
+ (file-name (git-file-name "cl-inotify" version))
+ (sha256
+ (base32 "0d3bvp5lqnddzhk1w9yyli03njbkhc8d129a058g0j49kgd47c7v"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiveam))
+ (inputs
+ (list libfixposix
+ sbcl-binary-types
+ sbcl-cffi
+ sbcl-osicat
+ sbcl-trivial-utf-8))
+ (synopsis "Common Lisp interface to the Linux inotify API")
+ (description
+ "@code{cl-inotify} uses @code{cl-cffi} to provide a Common Lisp
+interface to the Linux inotify API.")
+ (home-page "https://github.com/Ferada/cl-inotify/";)
+ (license license:bsd-2))))
-(define-public cl-syntax
- (sbcl-package->cl-source-package sbcl-cl-syntax))
+(define-public cl-inotify
+ (sbcl-package->cl-source-package sbcl-cl-inotify))
-(define-public ecl-cl-syntax
- (sbcl-package->ecl-package sbcl-cl-syntax))
+(define-public ecl-cl-inotify
+ (sbcl-package->ecl-package sbcl-cl-inotify))
-(define-public sbcl-cl-utilities
- (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
+(define-public sbcl-cl-interpol
+ (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa")
(revision "1"))
(package
- (name "sbcl-cl-utilities")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-interpol")
+ (version (git-version "0.2.7" revision commit))
(source
(origin
- (method url-fetch)
- (uri
- (string-append
- "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/";
- "archive/" commit "/cl-utilities-" commit ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-interpol";)
+ (commit commit)))
+ (file-name (git-file-name "cl-interpol" version))
(sha256
- (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
+ (base32
+ "1kr00zf62m7la7rxa2m5w49r9cyzamc106hvjcc8ffmi7a4jw490"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "rotate-byte.lisp"
- (("in-package :cl-utilities)" all)
- "in-package :cl-utilities)\n\n#+sbcl\n(require
:sb-rotate-byte)")))))))
- (home-page "https://common-lisp.net/project/cl-utilities";)
- (synopsis "Collection of semi-standard utilities")
+ (inputs
+ (list sbcl-cl-unicode sbcl-named-readtables))
+ (native-inputs
+ (list sbcl-flexi-streams))
+ (synopsis "String interpolation for Common Lisp")
(description
- "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
-is a collection of Common Lisp Utilities, things that everybody writes since
-they're not part of the official standard. There are some very useful things
-there; the only problems are that they aren't implemented as well as you'd
-like (some aren't implemented at all) and they aren't conveniently packaged
-and maintained. It takes quite a bit of work to carefully implement utilities
-for common use, commented and documented, with error checking placed
-everywhere some dumb user might make a mistake.")
- (license license:public-domain))))
+ "CL-INTERPOL is a library for Common Lisp which modifies the
+reader so that you can have interpolation within strings similar to
+Perl or Unix Shell scripts. It also provides various ways to insert
+arbitrary characters into literal strings even if your editor/IDE
+doesn't support them.")
+ (home-page "https://edicl.github.io/cl-interpol/";)
+ (license license:bsd-3))))
-(define-public cl-utilities
- (sbcl-package->cl-source-package sbcl-cl-utilities))
+(define-public cl-interpol
+ (sbcl-package->cl-source-package sbcl-cl-interpol))
-(define-public ecl-cl-utilities
- (sbcl-package->ecl-package sbcl-cl-utilities))
+(define-public ecl-cl-interpol
+ (sbcl-package->ecl-package sbcl-cl-interpol))
-(define-public sbcl-map-set
- (let ((commit "7b4b545b68b8")
- (revision "1"))
+(define-public sbcl-cl-ipfs-api2
+ (let ((commit "3ee52c80023bcc662f7d01276ea0a5814bd0011b")
+ (revision "0"))
(package
- (name "sbcl-map-set")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-ipfs-api2")
+ (version (git-version "0.51" revision commit))
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://bitbucket.org/tarballs_are_good/map-set/get/";
- commit ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/JadedCtrl/cl-ipfs-api2";)
+ (commit commit)))
+ (file-name (git-file-name "cl-ipfs-api2" version))
(sha256
- (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+ (base32 "1h0csxk4db1hid793mk5kz3nbjyl7z4ic1zk2wy46k1vz5lnnsph"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://bitbucket.org/tarballs_are_good/map-set";)
- (synopsis "Set-like data structure")
+ (arguments
+ '(#:tests? #f)) ; There are no tests.
+ (inputs
+ (list sbcl-arnesi
+ sbcl-drakma
+ sbcl-yason))
+ (home-page "https://github.com/JadedCtrl/cl-ipfs-api2/";)
+ (synopsis "Bindings for the IPFS HTTP API")
(description
- "Implementation of a set-like data structure with constant time
-addition, removal, and random selection.")
- (license license:bsd-3))))
-
-(define-public cl-map-set
- (sbcl-package->cl-source-package sbcl-map-set))
-
-(define-public ecl-map-set
- (sbcl-package->ecl-package sbcl-map-set))
+ "@code{cl-sbcl-cl-ipfs-api2} is a pretty simple set of IPFS bindings
+for Common Lisp, using the HTTP API for (almost) everything, except for pubsub
+(which uses the locally installed go-ipfs program).")
+ (license license:lgpl3))))
-(define-public sbcl-quri
- (package
- (name "sbcl-quri")
- (version "0.7.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/quri";)
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0l1jnvvkyaxbf08lnqfdbv6lrkq02iqr3y3rwvqxm4fvnzp7mnpz"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-prove))
- (inputs (list sbcl-babel sbcl-split-sequence sbcl-cl-utilities
- sbcl-alexandria))
- (home-page "https://github.com/fukamachi/quri";)
- (synopsis "Yet another URI library for Common Lisp")
- (description
- "QURI (pronounced \"Q-ree\") is yet another URI library for Common
-Lisp. It is intended to be a replacement of PURI.")
- (license license:bsd-3)))
+(define-public cl-ipfs-api2
+ (sbcl-package->cl-source-package sbcl-cl-ipfs-api2))
-(define-public cl-quri
- (sbcl-package->cl-source-package sbcl-quri))
+(define-public ecl-cl-ipfs-api2
+ (sbcl-package->ecl-package sbcl-cl-ipfs-api2))
-(define-public ecl-quri
- (sbcl-package->ecl-package sbcl-quri))
-
-(define-public sbcl-myway
- (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
- (revision "1"))
+(define-public sbcl-cl-irc
+ (let ((commit "963823537c7bfcda2edd4c44d172192da6722175")
+ (revision "0"))
(package
- (name "sbcl-myway")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/myway";)
- (commit commit)))
- (file-name (git-file-name "myway" version))
- (sha256
- (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("myway-test" "myway")))
- (native-inputs
- (list sbcl-prove))
- (inputs
- (list sbcl-cl-ppcre sbcl-quri sbcl-map-set))
- (home-page "https://github.com/fukamachi/myway";)
- (synopsis "Sinatra-compatible URL routing library for Common Lisp")
- (description "My Way is a Sinatra-compatible URL routing library.")
- (license license:llgpl))))
-
-(define-public cl-myway
- (sbcl-package->cl-source-package sbcl-myway))
-
-(define-public ecl-myway
- (sbcl-package->ecl-package sbcl-myway))
+ (name "sbcl-cl-irc")
+ (version (git-version "0.9.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://salsa.debian.org/common-lisp-team/cl-irc.git";)
+ (commit commit)))
+ (file-name (git-file-name "cl-irc" version))
+ (sha256
+ (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-rt))
+ (inputs
+ `(("cl+ssl" ,sbcl-cl+ssl)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("usocket" ,sbcl-usocket)))
+ (arguments
+ `(#:asd-test-systems '("cl-irc-test")))
+ (synopsis "IRC client library for Common Lisp")
+ (description "@code{cl-irc} is a Common Lisp IRC client library that
+features (partial) DCC, CTCP and all relevant commands from the IRC
+RFCs (RFC2810, RFC2811 and RFC2812).
-(define-public sbcl-xsubseq
- (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
- (revision "1"))
- (package
- (name "sbcl-xsubseq")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/xsubseq";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("xsubseq-test" "xsubseq")))
- (native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/fukamachi/xsubseq";)
- (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
- (description
- "XSubseq provides functions to be able to handle \"subseq\"s more
-effieiently.")
- (license license:bsd-2))))
+Features:
+@itemize
+@item implements all commands in the RFCs
+@item extra convenience commands such as op/deop, ban, ignore, etc.
+@item partial DCC SEND/CHAT support
+@item event driven model with hooks makes interfacing easy
+@item the user can keep multiple connections
+@item all CTCP commands
+@end itemize\n")
+ (home-page "https://common-lisp.net/project/cl-irc/";)
+ (license license:bsd-2))))
-(define-public cl-xsubseq
- (sbcl-package->cl-source-package sbcl-xsubseq))
+(define-public cl-irc
+ (sbcl-package->cl-source-package sbcl-cl-irc))
-(define-public ecl-xsubseq
- (sbcl-package->ecl-package sbcl-xsubseq))
+(define-public ecl-cl-irc
+ (sbcl-package->ecl-package sbcl-cl-irc))
-(define-public sbcl-smart-buffer
- (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
- (revision "1"))
+(define-public sbcl-cl-isaac
+ (let ((commit "9cd88f39733be753facbf361cb0e08b9e42ff8d5")
+ (revision "0"))
(package
- (name "sbcl-smart-buffer")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-isaac")
+ (version (git-version "1.0.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/smart-buffer";)
+ (url "https://github.com/thephoeron/cl-isaac";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-isaac" version))
(sha256
- (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
+ (base32 "0ig1mf8iridfr7vci9gy499194h0hda0xki5s6g0y04g85ibnpw9"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("smart-buffer-test" "smart-buffer")))
- (native-inputs
- (list sbcl-prove
- sbcl-babel))
- (inputs
- (list sbcl-xsubseq sbcl-flexi-streams))
- (home-page "https://github.com/fukamachi/smart-buffer";)
- (synopsis "Smart octets buffer")
- (description
- "Smart-buffer provides an output buffer which changes the destination
-depending on content size.")
- (license license:bsd-3))))
+ (native-inputs (list sbcl-prove))
+ (home-page "https://github.com/thephoeron/cl-isaac/";)
+ (synopsis "Fast cryptographic random number generators")
+ (description "This is an optimized Common Lisp library of Bob Jenkins'
+ISAAC-32 and ISAAC-64 algorithms, which are fast cryptographic random number
+generators: Indirection, Shift, Accumulate, Add, and Count.")
+ (license license:bsd-0))))
-(define-public cl-smart-buffer
- (sbcl-package->cl-source-package sbcl-smart-buffer))
+(define-public cl-isaac
+ (sbcl-package->cl-source-package sbcl-cl-isaac))
-(define-public ecl-smart-buffer
- (sbcl-package->ecl-package sbcl-smart-buffer))
+(define-public ecl-cl-isaac
+ (sbcl-package->ecl-package sbcl-cl-isaac))
-(define-public sbcl-fast-http
- (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
- (revision "2"))
+(define-public sbcl-cl-jpeg
+ (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
+ (revision "1"))
(package
- (name "sbcl-fast-http")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-cl-jpeg")
+ (version (git-version "2.8" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/fast-http";)
+ (url "https://github.com/sharplispers/cl-jpeg";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
+ (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("fast-http-test" "fast-http")))
- (native-inputs
- `(("sbcl-prove" ,sbcl-prove)
- ("cl-syntax" ,sbcl-cl-syntax)))
- (inputs
- (list sbcl-alexandria sbcl-proc-parse sbcl-xsubseq
- sbcl-smart-buffer sbcl-cl-utilities))
- (home-page "https://github.com/fukamachi/fast-http";)
- (synopsis "HTTP request/response parser for Common Lisp")
+ (synopsis "JPEG image library for Common Lisp")
(description
- "@code{fast-http} is a HTTP request/response protocol parser for Common
-Lisp.")
- ;; Author specified the MIT license
- (license license:expat))))
+ "This is a baseline JPEG codec written in Common Lisp. It can be used
+for reading and writing JPEG image files.")
+ (home-page "https://github.com/sharplispers/cl-jpeg";)
+ (license license:bsd-3))))
-(define-public cl-fast-http
- (sbcl-package->cl-source-package sbcl-fast-http))
+(define-public cl-jpeg
+ (sbcl-package->cl-source-package sbcl-cl-jpeg))
-(define-public ecl-fast-http
- (sbcl-package->ecl-package sbcl-fast-http))
+(define-public ecl-cl-jpeg
+ (sbcl-package->ecl-package sbcl-cl-jpeg))
-(define-public sbcl-static-vectors
+(define-public sbcl-cl-json
(package
- (name "sbcl-static-vectors")
- (version "1.8.9")
+ (name "sbcl-cl-json")
+ (version "0.6.0")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sionescu/static-vectors";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "079qa20lhanzsz1qf4iags91n0ziylbjgbcymm5a5qj7yryas4fw"))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/cl-json";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-json" version))
+ (sha256
+ (base32 "12vakz47d1i7pywgb9cm2364fzykidc9m7l7b6n9lx0gn2qx9ar5"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
- (inputs
- (list sbcl-alexandria 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.")
+ (home-page "https://github.com/sharplispers/cl-json";)
+ (synopsis "JSON encoder and decoder for Common-Lisp")
+ (description "@command{cl-json} provides an encoder of Lisp objects
+to JSON format and a corresponding decoder of JSON data to Lisp
+objects. Both the encoder and the decoder are highly customizable; at the
+same time, the default settings ensure a very simple mode of operation,
+similar to that provided by @command{yason} or @command{st-json}.")
(license license:expat)))
-(define-public cl-static-vectors
- (sbcl-package->cl-source-package sbcl-static-vectors))
+(define-public cl-json
+ (sbcl-package->cl-source-package sbcl-cl-json))
-(define-public ecl-static-vectors
- (sbcl-package->ecl-package sbcl-static-vectors))
+(define-public ecl-cl-json
+ (sbcl-package->ecl-package sbcl-cl-json))
-(define-public sbcl-marshal
- (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
- (revision "1"))
+(define-public sbcl-cl-json-pointer
+ (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c")
+ (revision "0"))
(package
- (name "sbcl-marshal")
- (version (git-version "1.3.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/wlbr/cl-marshal";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/wlbr/cl-marshal";)
- (synopsis "Simple (de)serialization of Lisp datastructures")
- (description
- "Simple and fast marshalling of Lisp datastructures. Convert any object
-into a string representation, put it on a stream an revive it from there.
-Only minimal changes required to make your CLOS objects serializable.")
- (license license:expat))))
-
-(define-public cl-marshal
- (sbcl-package->cl-source-package sbcl-marshal))
-
-(define-public ecl-marshal
- (sbcl-package->ecl-package sbcl-marshal))
-
-(define-public sbcl-fast-io
- (let ((commit "a4c5ad600425842e8b6233b1fa22610ffcd874c3")
- (revision "3"))
- (package
- (name "sbcl-fast-io")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rpav/fast-io";)
- (commit commit)))
- (file-name (git-file-name "cl-fast-io" version))
- (sha256
- (base32 "0wh02yagbqahy9z6787jz5ggpagvr18qd0z13wvwq1vjf8xd2530"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam sbcl-checkl))
- (inputs
- (list sbcl-alexandria sbcl-trivial-gray-streams sbcl-static-vectors))
- (home-page "https://github.com/rpav/fast-io";)
- (synopsis "Fast octet-vector/stream I/O for Common Lisp")
- (description
- "Fast-io is about improving performance to octet-vectors and octet
-streams (though primarily the former, while wrapping the latter).")
- ;; Author specifies this as NewBSD which is an alias
- (license license:bsd-3))))
+ (name "sbcl-cl-json-pointer")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/y2q-actionman/cl-json-pointer";)
+ (commit commit)))
+ (file-name (git-file-name "cl-json-pointer" version))
+ (sha256
+ (base32 "0b7a755wc2ghsd1pv7d32877b21h4nssp41xs017anbmj55czb2h"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; FIXME: Component "cl-json-pointer/test" not found.
+ `(#:tests? #f
+ #:asd-systems '("cl-json-pointer" "cl-json-pointer/synonyms")))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-boost-json
+ sbcl-cl-json
+ sbcl-closer-mop
+ sbcl-st-json))
+ (home-page "https://github.com/y2q-actionman/cl-json-pointer";)
+ (synopsis "JSON Pointer processor for Common Lisp")
+ (description "
+This package provides a JSON
+Pointer (@url{https://tools.ietf.org/html/rfc6901,RFC6901}) implementation for
+Common Lisp. This libary aims to be independent from any JSON libraries (as
much
+as possible).")
+ (license license:expat))))
-(define-public cl-fast-io
- (sbcl-package->cl-source-package sbcl-fast-io))
+(define-public cl-json-pointer
+ (sbcl-package->cl-source-package sbcl-cl-json-pointer))
-(define-public ecl-fast-io
- (sbcl-package->ecl-package sbcl-fast-io))
+(define-public ecl-cl-json-pointer
+ (sbcl-package->ecl-package sbcl-cl-json-pointer))
-(define-public sbcl-legion
- (let ((commit "599cca19f0e34246814621f7fe90322221c2e263")
+(define-public sbcl-cl-ledger
+ (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
(revision "1"))
(package
- (name "sbcl-legion")
- (version (git-version "0.1.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/legion/";)
- (commit commit)))
- (file-name (git-file-name "cl-legion" version))
- (sha256
- (base32 "0583pw0mf8bd4dj42w2xrlzcwfkl8q28n1bh8dpxxfg93crx4si6"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove sbcl-local-time))
- (inputs
- (list
- sbcl-bordeaux-threads
- sbcl-cl-speedy-queue
- sbcl-vom))
- (home-page "https://github.com/fukamachi/legion";)
- (synopsis "Simple multithreading worker mechanism for Common Lisp")
- (description
- "This library provides a simple multithreading worker mechanism.")
- (license license:bsd-3))))
+ (name "sbcl-cl-ledger")
+ (version (git-version "4.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ledger/cl-ledger";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cambl" ,sbcl-cambl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)
+ ("periods" ,sbcl-periods)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-system-definition
+ (lambda _
+ (substitute* "cl-ledger.asd"
+ ((" :build-operation program-op") "")
+ ((" :build-pathname \"cl-ledger\"") "")
+ ((" :entry-point \"ledger::main\"") ""))
+ #t)))))
+ (synopsis "Common Lisp port of the Ledger accounting system")
+ (description
+ "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
+system.")
+ (home-page "https://github.com/ledger/cl-ledger";)
+ (license license:bsd-3))))
-(define-public cl-legion
- (sbcl-package->cl-source-package sbcl-legion))
+(define-public cl-ledger
+ (sbcl-package->cl-source-package sbcl-cl-ledger))
-(define-public ecl-legion
- (package
- (inherit (sbcl-package->ecl-package sbcl-legion))
- (arguments
- ;; Tests get stuck forever
- (list #:tests? #f))))
+(define-public ecl-cl-ledger
+ (sbcl-package->ecl-package sbcl-cl-ledger))
-(define-public sbcl-jonathan
- (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
+(define-public sbcl-cl-lex
+ (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
(revision "1"))
(package
- (name "sbcl-jonathan")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Rudolph-Miller/jonathan";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove sbcl-legion))
- (inputs
- (list sbcl-cl-syntax sbcl-fast-io sbcl-proc-parse sbcl-cl-ppcre))
- (home-page "https://rudolph-miller.github.io/jonathan/overview.html";)
- (synopsis "JSON encoder and decoder")
- (description
- "High performance JSON encoder and decoder. Currently support: SBCL,
-CCL.")
- ;; Author specifies the MIT license
- (license license:expat))))
-
-(define-public cl-jonathan
- (sbcl-package->cl-source-package sbcl-jonathan))
-
-(define-public ecl-jonathan
- (sbcl-package->ecl-package sbcl-jonathan))
-
-(define-public sbcl-http-body
- (let ((commit "3e4bedd6a9d9bc4e1dc0a45e5b55360ae30fd388")
- (revision "2"))
- (package
- (name "sbcl-http-body")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/http-body";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0kcg43l5674drzid9cj938q0ki5z25glx296rl239dm7yfmxlzz2"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("http-body-test" "http-body")))
- (native-inputs
- (list sbcl-assoc-utils sbcl-prove sbcl-trivial-utf-8))
- (inputs
- (list sbcl-babel
- sbcl-cl-ppcre
- sbcl-fast-http
- sbcl-flexi-streams
- sbcl-jonathan
- sbcl-trivial-gray-streams
- sbcl-cl-utilities
- sbcl-quri))
- (home-page "https://github.com/fukamachi/http-body";)
- (synopsis "HTTP POST data parser")
- (description
- "HTTP-Body parses HTTP POST data and returns POST parameters. It
-supports application/x-www-form-urlencoded, application/json, and
-multipart/form-data.")
- (license license:bsd-2))))
-
-(define-public cl-http-body
- (sbcl-package->cl-source-package sbcl-http-body))
-
-(define-public ecl-http-body
- (sbcl-package->ecl-package sbcl-http-body))
-
-(define-public sbcl-ciel
- (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a")
- (revision "0"))
- (package
- (name "sbcl-ciel")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-cl-lex")
+ (version (git-version "1.1.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ciel-lang/CIEL";)
+ (url "https://github.com/djr7C4/cl-lex";)
(commit commit)))
- (file-name (git-file-name "ciel" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1bwafbbsppxqvijf43dii55mpzrklh6faj2m5dhajg2f2m8qckgi"))))
+ (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-access
- sbcl-alexandria
- sbcl-arrow-macros
- sbcl-bordeaux-threads
- sbcl-cl-ansi-text
- sbcl-cl-ansi-text
- sbcl-cl-cron
- sbcl-cl-csv
- sbcl-cl-json-pointer
- sbcl-cl-ppcre
- sbcl-cl-punch
- sbcl-cl-reexport
- sbcl-cl-str
- sbcl-clesh
- sbcl-clingon
- sbcl-closer-mop
- sbcl-cmd
- sbcl-dbi
- sbcl-defstar
- sbcl-deploy
- sbcl-dexador
- sbcl-dissect
- sbcl-easy-routes
- sbcl-file-notify
- sbcl-fn
- sbcl-for
- sbcl-fset
- sbcl-generic-cl
- sbcl-hunchentoot
- sbcl-local-time
- sbcl-log4cl
- sbcl-lparallel
- sbcl-lquery
- sbcl-metabang-bind
- sbcl-modf
- sbcl-named-readtables
- sbcl-nodgui
- sbcl-parse-float
- sbcl-parse-number
- sbcl-printv
- sbcl-pythonic-string-reader
- sbcl-quicksearch
- sbcl-quri
- sbcl-repl-utilities
- sbcl-serapeum
- sbcl-shasht
- sbcl-shlex
- sbcl-spinneret
- sbcl-sxql
- sbcl-trivia
- sbcl-trivial-arguments
- sbcl-trivial-do
- sbcl-trivial-monitored-thread
- sbcl-trivial-package-local-nicknames
- sbcl-trivial-types
- sbcl-vgplot
- sbcl-which))
- (home-page "http://ciel-lang.org/";)
- (synopsis "CIEL Is an Extended Lisp")
+ (list sbcl-cl-ppcre))
+ (synopsis "Common Lisp macros for generating lexical analyzers")
(description
- "CIEL is a ready-to-use collection of libraries providing: a binary, to
-run CIEL scripts; a simple full-featured REPL for the terminal; a Lisp library
-and a core image .")
- (license license:expat))))
+ "This is a Common Lisp library providing a set of macros for generating
+lexical analyzers automatically. The lexers generated using @code{cl-lex} can
+be used with @code{cl-yacc}.")
+ (home-page "https://github.com/djr7C4/cl-lex";)
+ (license license:gpl3))))
-(define-public cl-ciel
- (sbcl-package->cl-source-package sbcl-ciel))
+(define-public cl-lex
+ (sbcl-package->cl-source-package sbcl-cl-lex))
-(define-public ecl-ciel
- (sbcl-package->ecl-package sbcl-ciel))
+(define-public ecl-cl-lex
+ (sbcl-package->ecl-package sbcl-cl-lex))
-(define-public sbcl-circular-streams
- (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
+(define-public sbcl-cl-liballegro
+ (let ((commit "49f632ce97fc4f835bf5d450588793234b980a64")
(revision "1"))
(package
- (name "sbcl-circular-streams")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/circular-streams";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; The tests depend on cl-test-more which is now prove. Prove
- ;; tests aren't working for some reason.
- `(#:tests? #f))
- (inputs
- (list sbcl-fast-io sbcl-trivial-gray-streams))
- (home-page "https://github.com/fukamachi/circular-streams";)
- (synopsis "Circularly readable streams for Common Lisp")
- (description
- "Circular-Streams allows you to read streams circularly by wrapping real
-streams. Once you reach end-of-file of a stream, it's file position will be
-reset to 0 and you're able to read it again.")
- (license license:llgpl))))
-
-(define-public cl-circular-streams
- (sbcl-package->cl-source-package sbcl-circular-streams))
-
-(define-public ecl-circular-streams
- (sbcl-package->ecl-package sbcl-circular-streams))
-
-(define-public sbcl-trivial-rfc-1123
- (let ((commit "9ef59c3fdec08b0e3c9ed02d39533887b6d1b8e3")
- (revision "0"))
- (package
- (name "sbcl-trivial-rfc-1123")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-liballegro")
+ (version (git-version "0.2.15" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/stacksmith/trivial-rfc-1123";)
+ (url "https://github.com/resttime/cl-liballegro";)
(commit commit)))
- (file-name (git-file-name "cl-trivial-rfc-1123" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1w4ywpj10fnp7cya62dzlxlg8nyk4lppn2pnmfixsndwr4ib1h6x"))))
+ (base32 "0brbr7i342s0gadlnzd3a61w2b9ihhx60l19ararnc2asvyhmz7x"))))
(build-system asdf-build-system/sbcl)
- (arguments `(#:asd-systems '("trivial-rfc-1123")))
- (inputs (list sbcl-cl-ppcre))
- (home-page "https://github.com/stacksmith/trivial-rfc-1123";)
- (synopsis "Parse and print RFC-1123 timestamps")
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-allegro-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((allegro-lib-path (string-append
+ (assoc-ref inputs "allegro") "/lib/")))
+ (substitute* "src/library.lisp"
+ (("lib \".so\"" all)
+ (string-append "\"" allegro-lib-path "\"" " lib
\".so\"")))))))))
+ (inputs
+ `(("allegro" ,allegro)
+ ("cffi" ,sbcl-cffi)
+ ("float-features" ,sbcl-float-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("trivial-main-thread" ,sbcl-trivial-main-thread)))
+ (home-page "https://github.com/resttime/cl-liballegro";)
+ (synopsis "Allegro 5 game programming library bindings for Common Lisp")
(description
- "This package parses and prints dates in RFC-1123 format.")
- (license license:bsd-3))))
+ "This package provides CFFI bindings and interface to Allegro 5 game
+developing library for Common Lisp.")
+ (license license:zlib))))
-(define-public cl-trivial-rfc-1123
- (sbcl-package->cl-source-package sbcl-trivial-rfc-1123))
+(define-public cl-liballegro
+ (sbcl-package->cl-source-package sbcl-cl-liballegro))
-(define-public ecl-trivial-rfc-1123
- (sbcl-package->ecl-package sbcl-trivial-rfc-1123))
+(define-public ecl-cl-liballegro
+ (sbcl-package->ecl-package sbcl-cl-liballegro))
-(define-public sbcl-lack
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
- (revision "1"))
+(define-public sbcl-cl-libsvm-format
+ (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
+ (revision "0"))
(package
- (name "sbcl-lack")
+ (name "sbcl-cl-libsvm-format")
(version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/lack";)
+ (url "https://github.com/masatoi/cl-libsvm-format";)
(commit commit)))
- (file-name (git-file-name "lack" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (base32
+ "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-prove))
(inputs
- `(("circular-streams" ,sbcl-circular-streams)
- ("http-body" ,sbcl-http-body)
- ("ironclad" ,sbcl-ironclad)
- ("local-time" ,sbcl-local-time)
- ("quri" ,sbcl-quri)
- ("trivial-mimes" ,sbcl-trivial-mimes)))
- (arguments
- '(#:asd-systems '("lack"
- "lack-request"
- "lack-response"
- "lack-component"
- "lack-util"
- "lack-middleware-backtrace"
- "lack-middleware-static")
- ;; XXX: Component :CLACK not found
- #:tests? #f))
- (home-page "https://github.com/fukamachi/lack";)
- (synopsis "Lack, the core of Clack")
+ (list sbcl-alexandria))
+ (synopsis "LibSVM data format reader for Common Lisp")
(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))))
+ "This Common Lisp library provides a fast reader for data in LibSVM
+format.")
+ (home-page "https://github.com/masatoi/cl-libsvm-format";)
+ (license license:expat))))
-(define-public cl-lack
- (sbcl-package->cl-source-package sbcl-lack))
+(define-public cl-libsvm-format
+ (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
-(define-public ecl-lack
- (sbcl-package->ecl-package sbcl-lack))
+(define-public ecl-cl-libsvm-format
+ (sbcl-package->ecl-package sbcl-cl-libsvm-format))
-(define-public sbcl-cl-isaac
- (let ((commit "9cd88f39733be753facbf361cb0e08b9e42ff8d5")
- (revision "0"))
+(define-public sbcl-cl-libuv
+ (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
+ (revision "1"))
(package
- (name "sbcl-cl-isaac")
- (version (git-version "1.0.7" revision commit))
+ (name "sbcl-cl-libuv")
+ (version (git-version "0.1.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/thephoeron/cl-isaac";)
+ (url "https://github.com/orthecreedence/cl-libuv";)
(commit commit)))
- (file-name (git-file-name "cl-isaac" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0ig1mf8iridfr7vci9gy499194h0hda0xki5s6g0y04g85ibnpw9"))))
+ (base32
+ "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-prove))
- (home-page "https://github.com/thephoeron/cl-isaac/";)
- (synopsis "Fast cryptographic random number generators")
- (description "This is an optimized Common Lisp library of Bob Jenkins'
-ISAAC-32 and ISAAC-64 algorithms, which are fast cryptographic random number
-generators: Indirection, Shift, Accumulate, Add, and Count.")
- (license license:bsd-0))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("libuv" ,libuv)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "lib.lisp"
+ (("/usr/lib/libuv.so")
+ (search-input-file inputs "/lib/libuv.so")))))
+ (add-after 'fix-paths 'fix-system-definition
+ (lambda _
+ (substitute* "cl-libuv.asd"
+ (("#:cffi #:alexandria")
+ "#:cffi #:cffi-grovel #:alexandria"))
+ #t)))))
+ (synopsis "Common Lisp bindings to libuv")
+ (description
+ "This library provides low-level libuv bindings for Common Lisp.")
+ (home-page "https://github.com/orthecreedence/cl-libuv";)
+ (license license:expat))))
-(define-public cl-isaac
- (sbcl-package->cl-source-package sbcl-cl-isaac))
+(define-public cl-libuv
+ (sbcl-package->cl-source-package sbcl-cl-libuv))
-(define-public ecl-cl-isaac
- (sbcl-package->ecl-package sbcl-cl-isaac))
+(define-public ecl-cl-libuv
+ (sbcl-package->ecl-package sbcl-cl-libuv))
-(define-public sbcl-local-time
- (let ((commit "40169fe26d9639f3d9560ec0255789bf00b30036")
- (revision "4"))
+(define-public sbcl-cl-libxml2
+ (let ((commit "8d03110c532c1a3fe15503fdfefe82f60669e4bd"))
(package
- (name "sbcl-local-time")
- (version (git-version "1.0.6" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/dlowe-net/local-time";)
- (commit commit)))
- (file-name (git-file-name "cl-local-time" version))
- (sha256
- (base32 "1dbp33zmkqzzshmf5k76pxqgli285wvy0p0dhcz816fdikpwn2jg"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
+ (name "sbcl-cl-libxml2")
+ (version (git-version "0.3.4" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/archimag/cl-libxml2";)
+ (commit commit)))
+ (file-name (git-file-name "cl-libxml2" version))
+ (sha256
+ (base32 "09049c13cfp5sc6x9lrw762jd7a9qkfq5jgngqgrzn4kn9qscarw"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("garbage-pools" ,sbcl-garbage-pools)
+ ("iterate" ,sbcl-iterate)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("puri" ,sbcl-puri)
+ ;; Non-Lisp inputs:
+ ("libxml2" ,libxml2)
+ ("libxslt" ,libxslt)))
+ (native-inputs
+ (list sbcl-lift))
+ (arguments
+ `(#:tests? #f ; FIXME: Tests get stuck indefinitly
+ #:phases
(modify-phases %standard-phases
- ;; Delete the extension provided by sbcl-cl-postgres+local-time
- (add-after 'unpack 'delete-local-time
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (substitute* "tree/xtree.lisp"
+ (("libxml2.so.2")
+ (string-append (assoc-ref inputs "libxml2")
"/lib/libxml2.so")))
+ (let ((libxslt (assoc-ref inputs "libxslt")))
+ (substitute* "xslt/xslt.lisp"
+ (("libxslt.so.1")
+ (string-append libxslt "/lib/libxslt.so"))
+ (("libexslt.so.0")
+ (string-append libxslt "/lib/libexslt.so"))
+ (("cllibxml2.so")
+ (string-append (assoc-ref outputs "out")
"/lib/cllibxml2.so"))))
+ #t))
+ (add-before 'build 'build-helper-library
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let ((prefix-dir (string-append (assoc-ref outputs "out"))))
+ (mkdir-p (string-append prefix-dir "/lib"))
+ (invoke "make" "-C" "foreign" "install"
+ "INSOPTS="
+ (string-append "PREFIX=" prefix-dir))
+ #t)))
+ (add-after 'unpack 'fix-tests
(lambda _
- (delete-file "cl-postgres+local-time.asd")
- (delete-file "src/integration/cl-postgres.lisp"))))))
- (native-inputs
- (list sbcl-hu.dwim.stefil))
- (home-page "https://common-lisp.net/project/local-time/";)
- (synopsis "Time manipulation library for Common Lisp")
- (description
- "The LOCAL-TIME library is a Common Lisp library for the manipulation of
-dates and times. It is based almost entirely upon Erik Naggum's paper \"The
-Long Painful History of Time\".")
- (license license:expat))))
-
-(define-public cl-local-time
- (sbcl-package->cl-source-package sbcl-local-time))
-
-(define-public ecl-local-time
- (sbcl-package->ecl-package sbcl-local-time))
-
-(define-public sbcl-cl-postgres+local-time
- (package
- (inherit sbcl-local-time)
- (name "sbcl-cl-postgres+local-time")
- (inputs (list sbcl-local-time sbcl-postmodern))
- (arguments
- `(#:asd-systems '("cl-postgres+local-time")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'delete-local-time
- (lambda _
- (delete-file "local-time.asd")
- (delete-file "src/package.lisp")
- (delete-file "src/local-time.lisp")
- (delete-file-recursively "doc")
- (delete-file-recursively "test")
- (delete-file-recursively "zoneinfo"))))))
- (synopsis "Integration between cl-postgres and local-time")
- (description
- "This package provides the LOCAL-TIME extensions for the cl-postgres
-ASDF system of postmodern.")
- (license license:expat)))
-
-(define-public cl-postgres+local-time
- (sbcl-package->cl-source-package sbcl-cl-postgres+local-time))
-
-(define-public ecl-cl-postgres+local-time
- (sbcl-package->ecl-package sbcl-cl-postgres+local-time))
+ (substitute* '("cl-libxml2.asd" "cl-libxslt.asd" "xfactory.asd")
+ ((" :force t") ""))
+ #t)))))
+ (home-page
"https://web.archive.org/web/20160121073421/http://cl-libxml2.googlecode.com/svn/doc/index.html";)
+ (synopsis "High-level wrapper around libxml2 and libxslt libraries")
+ (description
+ "cl-libxml2 is high-level Common Lisp wrapper around the @code{libxml2}
+and @code{libxslt} libraries.
-(define-public sbcl-chronicity
- (package
- (name "sbcl-chronicity")
- (version "0.4.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/chaitanyagupta/chronicity";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "chronicity" version))
- (sha256
- (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
- (inputs
- (list sbcl-cl-interpol sbcl-cl-ppcre sbcl-local-time))
- (home-page "https://github.com/chaitanyagupta/chronicity";)
- (synopsis "Natural language date and time parser for Common Lisp")
- (description
- "CHRONICITY is Common Lisp natural language date and time parser inspired
-by Ruby's @code{Chronic}.")
- (license license:bsd-3)))
+@itemize
+@item Interfaces for tree manipulation (like @code{cxml-stp}).
+@item Interface for HTML 4.0 non-validating parsers.
+@item Specific APIs to process HTML trees, especially serialization.
+@item XPath API.
+@item XSLT API.
+@item Custom URL resolvers.
+@item XPath extension functions.
+@item XSLT extension elements.
+@item Translates @code{libxml2} and @code{libxslt} errors to Lisp conditions.
+@item Extends the Common Lisp @code{iterate} library with custom drivers for
+child nodes enumeration, etc.
+@item The @code{XFACTORY} system provides a simple and compact syntax for XML
generation.
+@end itemize\n")
+ (license license:llgpl))))
-(define-public ecl-chronicity
- (sbcl-package->ecl-package sbcl-chronicity))
+(define-public cl-libxml2
+ (sbcl-package->cl-source-package sbcl-cl-libxml2))
-(define-public cl-chronicity
- (sbcl-package->cl-source-package sbcl-chronicity))
+(define-public ecl-cl-libxml2
+ (sbcl-package->ecl-package sbcl-cl-libxml2))
-(define-public sbcl-trivial-mimes
- (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9")
- (revision "2"))
+(define-public sbcl-cl-libyaml
+ (let ((commit "a7fe9f68bddfd00b7ca467b65b3b41b276336843")
+ (revision "1"))
(package
- (name "sbcl-trivial-mimes")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-cl-libyaml")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/trivial-mimes";)
+ (url "https://github.com/eudoxia0/cl-libyaml";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-libyaml" version))
(sha256
- (base32 "00kcm17q5plpzdj1qwg83ldhxksilgpcdkf3m9azxcdr968xs9di"))))
+ (base32
+ "06pvmackyhq03rjmihpx6w63m6cy8wx78ll5xpwwvd85bgrqq817"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-hu.dwim.stefil))
+ (list sbcl-fiveam))
(inputs
- (list sbcl-cl-fad))
- (home-page "https://shinmera.github.io/trivial-mimes/";)
- (synopsis "Tiny Common Lisp library to detect mime types in files")
+ `(("cffi" ,sbcl-cffi)
+ ("libyaml" ,libyaml)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libyaml.so")
+ (string-append (assoc-ref inputs "libyaml")
+ "/lib/libyaml.so"))))))))
+ (home-page "https://github.com/eudoxia0/cl-libyaml";)
+ (synopsis "Libyaml bindings for Common Lisp")
(description
- "This is a teensy library that provides some functions to determine the
-mime-type of a file.")
- (license license:zlib))))
+ "This is a binding to the libyaml library. It's not meant as
+a full library for YAML, just a bare binding with a couple of utility macros.
+For a YAML parser and emitter using this, check out cl-yaml.")
+ (license license:expat))))
-(define-public cl-trivial-mimes
- (sbcl-package->cl-source-package sbcl-trivial-mimes))
+(define-public cl-libyaml
+ (sbcl-package->cl-source-package sbcl-cl-libyaml))
-(define-public ecl-trivial-mimes
- (sbcl-package->ecl-package sbcl-trivial-mimes))
+(define-public ecl-cl-libyaml
+ (sbcl-package->ecl-package sbcl-cl-libyaml))
-(define-public sbcl-ningle
- (let ((commit "2e85675bbb668d6ef341514fc9f22391a0f506b1")
- (revision "2"))
+(define-public sbcl-cl-locale
+ (let ((commit "0a36cc0dcf5e0a8c8bf97869cd6199980ca25eec")
+ (revision "1"))
(package
- (name "sbcl-ningle")
- (version (git-version "0.3.0" revision commit))
+ (name "sbcl-cl-locale")
+ (version (git-version "0.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/ningle";)
+ (url "https://github.com/fukamachi/cl-locale";)
(commit commit)))
- (file-name (git-file-name "cl-ningle" version))
+ (file-name (git-file-name "cl-locale" version))
(sha256
- (base32 "0s9nn8ml1j4839rycvdjcbsynkqnhxw1zmrgpjz48smscwdf1f8p"))))
+ (base32 "1rhannhpsw1yg1fpflam483a3w9qb1izgyvmnmiddv3dn4qsmn9p"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:tests? #f)) ; TODO: pull in clack-test
+ '(#:asd-systems '("cl-locale-test" "cl-locale")))
(native-inputs
- (list sbcl-prove))
+ `(("prove" ,sbcl-prove)
+ ("flexi-streams" ,sbcl-flexi-streams)))
(inputs
- (list sbcl-cl-syntax sbcl-myway sbcl-lack sbcl-alexandria
- sbcl-babel))
- (home-page "https://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 ecl-ningle
- (sbcl-package->ecl-package sbcl-ningle))
-
-(define-public sbcl-cl-fastcgi
- (let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20")
- (revision "2"))
- (package
- (name "sbcl-cl-fastcgi")
- (version (git-version "0.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/KDr2/cl-fastcgi/";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0xgmhx766q4nmrvn5z7ag3ikpr9phlh8ypi8b14azshq9lqbq0m7"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("usocket" ,sbcl-usocket)
- ("cffi" ,sbcl-cffi)
- ("fcgi" ,fcgi)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "cl-fastcgi.lisp"
- (("\"libfcgi.so\"")
- (string-append
- "\""
- (assoc-ref inputs "fcgi") "/lib/libfcgi.so\""))))))))
- (home-page "https://kdr2.com/project/cl-fastcgi.html";)
- (synopsis "FastCGI wrapper for Common Lisp")
- (description
- "CL-FastCGI is a generic version of SB-FastCGI, targeting to run on
-mostly Common Lisp implementation.")
- (license license:bsd-2))))
-
-(define-public cl-fastcgi
- (sbcl-package->cl-source-package sbcl-cl-fastcgi))
-
-(define-public ecl-cl-fastcgi
- (sbcl-package->ecl-package sbcl-cl-fastcgi))
-
-(define-public sbcl-cl-fast-ecs
- (package
- (name "sbcl-cl-fast-ecs")
- (version "0.2.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.com/lockie/cl-fast-ecs";)
- (commit version)))
- (file-name (git-file-name "cl-fast-ecs" version))
- (sha256
- (base32 "00nw5nwzcz8x1x1lycmjik8pcqzxrl896j0xjjl33rjljsmj45sx"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-chlorophyll sbcl-cl-mock sbcl-parachute))
- (inputs
- (list sbcl-alexandria sbcl-trivial-garbage))
- (home-page "https://lockie.gitlab.io/cl-fast-ecs/";)
- (synopsis "Blazingly fast Entity-Component-System microframework")
- (description
- "CL-FAST-ECS is a Common Lisp library providing an implementation of the
-@acronym{ECS, Entity-Component-System} pattern, primarily focused on speed and
-interactive development.
-
-ECS is an architectural data-oriented design pattern that allows for the
-effective processing of a large number of in-game objects while keeping the
code
-and data separated. This provides flexibility in the way that game objects are
-built at runtime.")
- (license license:expat)))
-
-(define-public cl-fast-ecs
- (sbcl-package->cl-source-package sbcl-cl-fast-ecs))
-
-(define-public ecl-cl-fast-ecs
- (sbcl-package->ecl-package sbcl-cl-fast-ecs))
-
-(define-public sbcl-cl-flac
- (let ((commit "d094d33d3cc2cf263263b917798d338eded3c532")
- (revision "0"))
- (package
- (name "sbcl-cl-flac")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shirakumo/cl-flac";)
- (commit commit)))
- (file-name (git-file-name "cl-flac" version))
- (sha256
- (base32 "1dgr5xqf175hzq3sxpbixxia2k2g3rz0pn6msch4dnvk7a1naqlc"))
- (modules '((guix build utils)))
- (snippet
- ;; Delete bundled libraries.
- `(begin
- (delete-file-recursively "static")))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "low-level.lisp"
- (("libflac.so")
- (search-input-file inputs "/lib/libFLAC.so"))))))))
- (inputs
- (list flac
- sbcl-cffi
- sbcl-documentation-utils
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (home-page "https://shirakumo.github.io/cl-flac";)
- (synopsis "CFFI bindings to libflac for Common Lisp")
- (description "This package provides CFFI bindings to the @code{libflac}
-audio library for Common Lisp.")
- (license license:zlib))))
-
-(define-public ecl-cl-flac
- (sbcl-package->ecl-package sbcl-cl-flac))
-
-(define-public cl-flac
- (sbcl-package->cl-source-package sbcl-cl-flac))
-
-(define-public sbcl-clack
- (let ((commit "6fd0279424f7ba5fd4f92d69a1970846b0b11222")
- (revision "2"))
- (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";)
- (commit commit)))
- (file-name (git-file-name "cl-clack" version))
- (sha256
- (base32 "0sfmvqmsg9z13x0v77448rpdqgyprdq739nsbrjw9a28hv9jmkg9"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("clack"
- "clack-handler-fcgi"
- "clack-socket"
- "clack-handler-hunchentoot")))
- (inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cl-fastcgi
- sbcl-flexi-streams
- sbcl-hunchentoot
- sbcl-lack
- sbcl-quri
- sbcl-split-sequence
- sbcl-usocket))
- (home-page "https://github.com/fukamachi/clack";)
- (synopsis "Web Application Environment for Common Lisp")
+ `(("anaphora" ,sbcl-anaphora)
+ ("arnesi" ,sbcl-arnesi)
+ ("cl-annot" ,sbcl-cl-annot)
+ ("cl-syntax" ,sbcl-cl-syntax)))
+ (home-page "https://github.com/fukamachi/cl-locale";)
+ (synopsis "Internalization library for Common Lisp")
(description
- "Clack is a web application environment for Common Lisp inspired by
-Python's WSGI and Ruby's Rack.")
+ "This package provides a Common Lisp translation library similar to
+CL-I18N and CL-L10N.")
(license license:llgpl))))
-(define-public cl-clack
- (sbcl-package->cl-source-package sbcl-clack))
+(define-public cl-locale
+ (sbcl-package->cl-source-package sbcl-cl-locale))
-(define-public ecl-clack
- (sbcl-package->ecl-package sbcl-clack))
+(define-public ecl-cl-locale
+ (sbcl-package->ecl-package sbcl-cl-locale))
(define-public sbcl-cl-log
(let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837")
@@ -7807,1028 +6981,1153 @@ theory accurate to internal-time-units-per-second.")
(define-public ecl-cl-log
(sbcl-package->ecl-package sbcl-cl-log))
-(define-public sbcl-log4cl
- (let ((commit "fe3da517147d023029782ced7cd989ba24f1e62d")
- (revision "2"))
+(define-public sbcl-cl-markdown
+ ;; The latest changes with fixes are not released yet, see
+ ;; https://github.com/hraban/cl-markdown/issues/9
+ (let ((commit "3788802199228b49d0e06c3feb80c1c22af05cfc")
+ (revision "0"))
(package
- (name "sbcl-log4cl")
- (version (git-version "1.1.4" revision commit))
+ (name "sbcl-cl-markdown")
+ (version (git-version "0.10.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/log4cl";)
+ (url "https://github.com/hraban/cl-markdown";)
(commit commit)))
- (file-name (git-file-name "cl-log4cl" version))
+ (file-name (git-file-name "cl-markdown" version))
(sha256
- (base32 "0n119sy35k9yl4n18az1sw9a7saa5jh3v44863b305by1p5xdy7k"))))
+ (base32 "1algqwmafipyf194cx9wfhg0pdx1ppx6s444p1pm8yaycbsyla1v"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-stefil))
+ (list sbcl-lift sbcl-trivial-shell))
(inputs
- (list sbcl-bordeaux-threads))
- (home-page "https://github.com/7max/log4cl";)
- (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (list sbcl-anaphora
+ sbcl-cl-containers
+ sbcl-cl-ppcre
+ sbcl-dynamic-classes
+ sbcl-metabang-bind
+ sbcl-metatilities-base))
+ (home-page "https://common-lisp.net/project/cl-markdown/";)
+ (synopsis "Common Lisp rewrite of Markdown")
(description
- "This is a Common Lisp logging framework that can log at various levels
-and mix text with expressions.")
- (license license:asl2.0))))
+ "This is an implementation of a Markdown parser in Common Lisp.")
+ (license license:expat))))
-(define-public cl-log4cl
- (sbcl-package->cl-source-package sbcl-log4cl))
+(define-public cl-markdown
+ (sbcl-package->cl-source-package sbcl-cl-markdown))
-(define-public ecl-log4cl
- (sbcl-package->ecl-package sbcl-log4cl))
+(define-public ecl-cl-markdown
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-markdown)))
+ (package
+ (inherit pkg)
+ (arguments
+ ;; XXX: Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is
+ ;; undefined" on ECL.
+ ;; See https://github.com/hraban/cl-markdown/issues/11
+ '(#:tests? #f)))))
-(define-public sbcl-printv
- (let ((commit "e717a7fe076dae861a96117b2f9af29db8d2294d")
- (revision "2"))
+(define-public sbcl-cl-markless
+ (let ((commit "a0e145c03103bd3bf7e275d5ac0e19e8381eb844")
+ (revision "1"))
(package
- (name "sbcl-printv")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-cl-markless")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/danlentz/printv";)
+ (url "https://github.com/Shirakumo/cl-markless";)
(commit commit)))
- (file-name (git-file-name "cl-printv" version))
+ (file-name (git-file-name "cl-markless" version))
(sha256
- (base32 "07agyzkwp3w2r4d2anrmr8h00yngpr5dq9mjd3m4kzhn1jcmilfb"))))
+ (base32 "154ax1yk0b1035yij29c5pgfn7ifghrxy821mk68wyljg8afgvh5"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list figlet))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-figlet-executable
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "printv.lisp"
- (("\"figlet")
- (string-append "\"" (search-input-file inputs
- "/bin/figlet")))))))))
- (home-page "https://github.com/danlentz/printv";)
- (synopsis "Common Lisp tracing and debug-logging macro")
- (description
- "@code{PRINTV} is a \"batteries-included\" tracing and debug-logging
-macro for Common Lisp.")
- (license license:asl2.0))))
+ (list sbcl-3bmd
+ sbcl-babel
+ sbcl-command-line-arguments
+ sbcl-documentation-utils
+ sbcl-plump
+ sbcl-trivial-gray-streams
+ sbcl-trivial-indent
+ sbcl-trivial-mimes
+ sbcl-zip))
+ (arguments
+ '(#:asd-systems '("cl-markless"
+ "cl-markless-plump"
+ "cl-markless-epub"
+ "cl-markless-markdown"
+ "cl-markless-standalone")))
+ (home-page "https://shirakumo.github.io/cl-markless/";)
+ (synopsis "Parser implementation for Markless")
+ (description "This is an implementation of the \"Markless
+standard\" (@url{https://github.com/shirakumo/markless}) at version 1.0. It
+handles the parsing of plaintext from a stream into an abstract syntax tree
+composed out of strings and component objects. From there the AST can be
+easily compiled into a target markup language like HTML.")
+ (license license:zlib))))
-(define-public ecl-printv
- (sbcl-package->ecl-package sbcl-printv))
+(define-public cl-markless
+ (sbcl-package->cl-source-package sbcl-cl-markless))
-(define-public cl-printv
- (sbcl-package->cl-source-package sbcl-printv))
+(define-public ecl-cl-markless
+ (sbcl-package->ecl-package sbcl-cl-markless))
-(define-public sbcl-cl-debug
- (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31")
- (revision "1"))
+(define-public sbcl-cl-markup
+ (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
(package
- (name "sbcl-cl-debug")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/kmx-io/cl-debug";)
- (commit commit)))
- (file-name (git-file-name "cl-debug" version))
- (sha256
- (base32 "0w5vxbjsgr3zfpivdmghmhzxskfdvm1p34c8whwps2xlhypxsa78"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/kmx-io/cl-debug";)
- (synopsis "Common Lisp cross-package debugging facility")
- (description
- "CL-DEBUG provides a unified way to enable or disable debug-specific
code.
-Debugging code can be enabled or disabled relative to program features denoted
-by either a symbol or a keyword.")
- (license license:isc))))
+ (name "sbcl-cl-markup")
+ (version (git-version "0.1" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/arielnetworks/cl-markup/";)
+ (commit commit)))
+ (file-name (git-file-name "cl-markup" version))
+ (sha256
+ (base32
+ "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/arielnetworks/cl-markup/";)
+ (synopsis "Markup generation library for Common Lisp")
+ (description
+ "A modern markup generation library for Common Lisp that features:
-(define-public ecl-cl-debug
- (sbcl-package->ecl-package sbcl-cl-debug))
+@itemize
+@item Fast (even faster through compiling the code)
+@item Safety
+@item Support for multiple document types (markup, xml, html, html5, xhtml)
+@item Output with doctype
+@item Direct output to stream
+@end itemize\n")
+ (license license:lgpl3+))))
-(define-public cl-debug
- (sbcl-package->cl-source-package sbcl-cl-debug))
+(define-public cl-markup
+ (sbcl-package->cl-source-package sbcl-cl-markup))
-(define-public sbcl-verbose
- (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174")
+(define-public ecl-cl-markup
+ (sbcl-package->ecl-package sbcl-cl-markup))
+
+(define-public sbcl-cl-mathstats
+ (let ((commit "4df38ea1b9de069cf939919253565a9ca9538eca")
(revision "1"))
(package
- (name "sbcl-verbose")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-cl-mathstats")
+ (version (git-version "0.8.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/verbose/";)
+ (url "https://github.com/hraban/cl-mathstats";)
(commit commit)))
- (file-name (git-file-name "verbose" version))
+ (file-name (git-file-name "cl-mathstats" version))
(sha256
- (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6"))))
+ (base32 "0gsjvmkmnxc4hp5z9mkm5vsllywqyg7kx8jgz88vnx47yj3va1s8"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lift))
(inputs
- (list sbcl-bordeaux-threads sbcl-dissect sbcl-documentation-utils
- sbcl-local-time sbcl-piping))
- (home-page "https://shinmera.github.io/verbose/";)
- (synopsis "Logging framework using the piping library")
+ (list sbcl-cl-containers sbcl-metatilities-base))
+ (home-page "https://github.com/hraban/cl-mathstats";)
+ (synopsis "Common Lisp collection of mathematical routines")
(description
- "This is a Common Lisp library providing logging faciltiy similar to
-@code{CL-LOG} and @code{LOG4CL}.")
- (license license:zlib))))
+ "This package provides Common Lisp math and statistics routines.")
+ (license license:expat))))
-(define-public ecl-verbose
- (sbcl-package->ecl-package sbcl-verbose))
+(define-public cl-mathstats
+ (sbcl-package->cl-source-package sbcl-cl-mathstats))
-(define-public cl-verbose
- (sbcl-package->cl-source-package sbcl-verbose))
+(define-public ecl-cl-mathstats
+ (sbcl-package->ecl-package sbcl-cl-mathstats))
-(define-public sbcl-vgplot
- (let ((commit "76329928a3709387c0779175af56ec49d16bcd35")
+(define-public sbcl-cl-messagepack
+ (let ((commit "8ff2060ed20677feef8ac01558690df0aeac30b6")
(revision "0"))
(package
- (name "sbcl-vgplot")
+ (name "sbcl-cl-messagepack")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/volkers/vgplot";)
+ (url "https://github.com/mbrezu/cl-messagepack";)
(commit commit)))
- (file-name (git-file-name "vgplot" version))
+ (file-name (git-file-name "cl-messagepack" version))
(sha256
- (base32 "1vc5fd787xa8831wjbmwrpg17f9isi5k8dmb85fsysz47plbvi1y"))))
+ (base32 "1hjd1q18lz46k46afz94ljflp76mfr30d6z4jrsgd26y2lc4gchc"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
- (inputs
- (list sbcl-cl-fad sbcl-cl-ppcre sbcl-ltk))
- (home-page "https://github.com/volkers/vgplot";)
- (synopsis "Common lisp library interfacing to the gnuplot utility")
+ (native-inputs (list sbcl-cl-json sbcl-fiveam))
+ (inputs (list sbcl-babel sbcl-closer-mop sbcl-flexi-streams))
+ (synopsis "Common Lisp implementation of MessagePack")
(description
- "This package provides an interface to the @code{gnuplot} plotting
-utility. The intention of the API is to resemble to some of the plot commands
-of octave or matlab.")
- (license license:gpl3+))))
+ "This is a Common Lisp implementation of the MessagePack
+(@url{http://msgpack.org/}) serialization/deserialization format,
+implemented according to
+@url{http://wiki.msgpack.org/display/MSGPACK/Format+specification}.";)
+ (home-page "https://github.com/mbrezu/cl-messagepack";)
+ (license license:bsd-2))))
-(define-public cl-vgplot
- (sbcl-package->cl-source-package sbcl-vgplot))
+(define-public cl-messagepack
+ (sbcl-package->cl-source-package sbcl-cl-messagepack))
-(define-public ecl-vgplot
- (sbcl-package->ecl-package sbcl-vgplot))
+(define-public ecl-cl-messagepack
+ (sbcl-package->ecl-package sbcl-cl-messagepack))
-(define-public sbcl-find-port
- (let ((commit "811727f88d7f000623bf92fdb0e64678a7112a28")
- (revision "2"))
+(define-public sbcl-cl-mime
+ (let ((commit "d30a28e0a40393bd3af7d138daa05319ed2e9d07")
+ (revision "1"))
(package
- (name "sbcl-find-port")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/eudoxia0/find-port";)
+ (name "sbcl-cl-mime")
+ ;; One commit says "update to cl-mime-0.5.3", even though the .asd is at
0.5.1.
+ (version (git-version "0.5.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ ;; Maintained fork according to http://www.cliki.net/CL-MIME:
+ (url "https://github.com/40ants/cl-mime";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1fw6q7d2bxxb7fqk548ylq8mx4sz95yc0q5h0rwd0mnqjrbwbari"))))
- (native-inputs
- (list sbcl-fiveam))
+ (base32 "0qn8if0fj6vzc897pqqqs0m1y107gmzqngpqhqmwrcsp1ckj5k0v"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- (list 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))))
+ (list sbcl-cl-ppcre sbcl-cl-base64 sbcl-cl-qprint))
+ (native-inputs
+ (list sbcl-rove))
+ (home-page "https://github.com/40ants/cl-mime/";)
+ (synopsis "Read and print MIME content in Common Lisp")
+ (description
+ "This is a Common Lisp library for reading and printing MIME content.
+It supports automatic conversion between 7-bit, quoted-printable and base64
+encodings.")
+ (license license:lgpl2.1))))
-(define-public cl-find-port
- (sbcl-package->cl-source-package sbcl-find-port))
+(define-public cl-mime
+ (sbcl-package->cl-source-package sbcl-cl-mime))
-(define-public ecl-find-port
- (sbcl-package->ecl-package sbcl-find-port))
+(define-public ecl-cl-mime
+ (sbcl-package->ecl-package sbcl-cl-mime))
-(define-public sbcl-numpy-file-format
- (let ((commit "e440c7bbc0d86b9abf73acb0fa665b77b82a6c98")
- (revision "2"))
+(define-public sbcl-cl-mimeparse
+ (let ((commit "93cbdf6f6fe8a2eb5f652f8adec453eb98ea0547")
+ (revision "0"))
(package
- (name "sbcl-numpy-file-format")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-mimeparse")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/numpy-file-format";)
+ (url "https://github.com/mmontone/cl-mimeparse";)
(commit commit)))
- (file-name (git-file-name "cl-numpy-file-format" version))
+ (file-name (git-file-name "cl-mimeparse" version))
(sha256
- (base32 "1n0nixc44z1cymm20wif0l2100ydv0h69l6i6xz5bmwcb2zc4gqr"))))
+ (base32 "0gdkpi3620va0a3q56svcn1q9f5w0pqfhx30lnldg8fjnrdfiwkk"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-test-systems '("cl-mimeparse-tests")))
+ (native-inputs
+ (list sbcl-rt))
(inputs
- (list sbcl-ieee-floats sbcl-trivial-features))
- (home-page "https://github.com/marcoheisig/numpy-file-format";)
- (synopsis "Read and write NumPy .npy and .npz files")
+ (list sbcl-cl-ppcre sbcl-parse-number))
+ (home-page "https://github.com/mmontone/cl-mimeparse/";)
+ (synopsis "Common Lisp library for parsing MIME types")
(description
- "The NUMPY-FILE-FORMAT library is a Common Lisp library for reading and
-writing NumPy @file{.npy} and @file{.npz} files.")
+ "This package provides a library for parsing MIME types, in the spirit
+of http://code.google.com/p/mimeparse/, with a Common Lisp flavor.")
(license license:expat))))
-(define-public cl-numpy-file-format
- (sbcl-package->cl-source-package sbcl-numpy-file-format))
+(define-public cl-mimeparse
+ (sbcl-package->cl-source-package sbcl-cl-mimeparse))
-(define-public ecl-numpy-file-format
- (sbcl-package->ecl-package sbcl-numpy-file-format))
+(define-public ecl-cl-mimeparse
+ (sbcl-package->ecl-package sbcl-cl-mimeparse))
-(define-public sbcl-py4cl
- (let ((commit "2f2a008dd6162d4446803971292fe1b323fe0dd5")
- (revision "2"))
+(define-public sbcl-cl-mixed
+ (let ((commit "4aaff134d3902d93a2a8605c10de4bcfc62d7afa")
+ (revision "0"))
(package
- (name "sbcl-py4cl")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-mixed")
+ (version (git-version "2.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bendudson/py4cl";)
+ (url "https://github.com/Shirakumo/cl-mixed";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mixed" version))
(sha256
- (base32
- "1zx1kpfpd8mi1qaa7gr32mki6nvl6pqcs3437fvn4xa3yf7ybsha"))
- (modules '((guix build utils)))))
+ (base32 "1mrj95lxb1gbxxm89x8gy1ifw2ic1p5wwpapkxcd2jr8abw7zny0"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Delete bundled libraries.
+ `(begin
+ (delete-file-recursively "static")))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-clunit))
- (inputs
- (list python sbcl-trivial-garbage))
- (propagated-inputs
- (list ;; For multi-dimensional array support
- python-numpy))
(arguments
- '(#:phases
+ '(#:asd-systems '("cl-mixed"
+ "cl-mixed-examples"
+ "cl-mixed-flac"
+ "cl-mixed-vorbis"
+ "cl-mixed-alsa"
+ "cl-mixed-jack"
+ "cl-mixed-mpg123"
+ "cl-mixed-mpt"
+ "cl-mixed-out123"
+ "cl-mixed-pulse"
+ "cl-mixed-sdl2"
+ "cl-mixed-wav")
+ #:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-python3-path
+ (add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/python-process.lisp"
- (("\\*python-command\\* \"python\"")
- (string-append "*python-command* "
- "\""
- (search-input-file inputs "/bin/python3")
- "\"")))))
- (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/python-process.lisp"
- (("py4cl/config:\\*base-directory\\*")
- (string-append
- "\""
- (assoc-ref outputs "out")
- "/share/common-lisp/"
- (%lisp-type)
- "/py4cl/"
- "\""))))))))
- (synopsis "Call python from Common Lisp")
+ (substitute* "low-level.lisp"
+ (("libmixed.so.2")
+ (search-input-file inputs "/lib/libmixed.so.2"))))))))
+ (inputs
+ (list libmixed
+ sbcl-alexandria
+ sbcl-cffi
+ sbcl-cl-flac
+ sbcl-cl-mpg123
+ sbcl-cl-out123
+ sbcl-cl-vorbis
+ sbcl-documentation-utils
+ sbcl-sdl2
+ sbcl-static-vectors
+ sbcl-trivial-features))
+ (home-page "https://shirakumo.github.io/cl-mixed/";)
+ (synopsis "Extended audio library for 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))))
+ "This package provides CFFI binding to @code{libmixed} audio library for
+Common Lisp with support of other audio formats available on GNU/Linux systems:
-(define-public cl-py4cl
- (sbcl-package->cl-source-package sbcl-py4cl))
+@itemize
-(define-public ecl-py4cl
- (sbcl-package->ecl-package sbcl-py4cl))
+@item @acronym{Alsa, Advanced Linux Sound Architecture}
+@item @acronym{Jack, JackAudio toolkit}
+@item @acronym{Openmpt, Libopenmpt playback drain for tracker files}
+@item @acronym{PulseAudio, PulseAudio based playback drain}
+@item Flac (via CL-FLAC)
+@item Mpg123 (via CL-MPG123)
+@item Ogg/vorbis (via CL-VORBIS)
+@item Out123 (via CL-OUT123)
+@item WAV
-(define-public sbcl-schemeish
- (let ((commit "dff57bafae5d0cffa104c8fdc4146502f32d7f85")
+@end itemize")
+ (license license:zlib))))
+
+(define-public cl-mixed
+ (sbcl-package->cl-source-package sbcl-cl-mixed))
+
+(define-public ecl-cl-mixed
+ (sbcl-package->ecl-package sbcl-cl-mixed))
+
+(define-public sbcl-cl-modio
+ (let ((commit "2fd288af27b574f448357fa6de4b42acf44e2f11")
(revision "1"))
(package
- (name "sbcl-schemeish")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-modio")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/chebert/schemeish";)
+ (url "https://github.com/Shinmera/cl-modio/";)
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32 "0q9b07spmhg1b576cnnacvkf7zr3mab2rdydfylbn92y9mms9vyj"))))
+ (base32 "0hz87v81pi8kr2c7az30czpdf7v757lkzlsmdcc59p94pipca7m9"))
+ (file-name (git-file-name "cl-modio" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-trivial-arguments))
- (synopsis "Scheme style syntax/macros/functions for Common Lisp")
- (description
- "Schemeish implements several useful Scheme constructs for Common Lisp.
-These include named-let, define, scheme argument lists, and a shortcut to
-FUNCALL with [] instead of ().")
- (home-page "https://github.com/chebert/schemeish";)
- ;; MIT License
- (license license:expat))))
+ (list sbcl-alexandria
+ sbcl-zippy
+ sbcl-jzon
+ sbcl-cl-ppcre
+ sbcl-drakma
+ sbcl-documentation-utils
+ sbcl-language-codes))
+ (synopsis "Client library for the mod.io API")
+ (description "This is a client library to interact with the
+\"mod.io\" (@url{https://mod.io}) platform to manage \"mods\" or extensions
+for games and other applications. It covers the full v1 API and includes
+convenience methods to make interacting with the API as well as syncing mods
+and so on easy.")
+ (home-page "https://shinmera.github.io/cl-modio/";)
+ (license license:zlib))))
-(define-public cl-schemeish
- (sbcl-package->cl-source-package sbcl-schemeish))
+(define-public cl-modio
+ (sbcl-package->cl-source-package sbcl-cl-modio))
-(define-public ecl-schemeish
- (sbcl-package->ecl-package sbcl-schemeish))
+(define-public ecl-cl-modio
+ (sbcl-package->ecl-package sbcl-cl-modio))
-(define-public sbcl-parse-declarations
- (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
+(define-public sbcl-cl-morse
+ (package
+ (name "sbcl-cl-morse")
+ (version "1.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/em7/cl-morse";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-morse" version))
+ (sha256
+ (base32 "01sh34nhbsx2dsrb2r1vkd4j8lzm9gjd5jfi8a4cs4m3djjwhh5i"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs (list sbcl-cl-ppcre))
+ (native-inputs (list sbcl-fiveam))
+ (home-page "https://github.com/em7/cl-morse";)
+ (synopsis "Morse code translation library for Common Lisp")
+ (description
+ "@code{cl-morse} is a Morse code translation library for Common Lisp.")
+ (license license:bsd-3)))
+
+(define-public cl-morse
+ (sbcl-package->cl-source-package sbcl-cl-morse))
+
+(define-public ecl-cl-morse
+ (sbcl-package->ecl-package sbcl-cl-morse))
+
+(define-public sbcl-cl-mount-info
+ (let ((commit "2024f5037a7f63db3e3587dc9972cd7b9318f06b")
(revision "1"))
(package
- (name "sbcl-parse-declarations")
+ (name "sbcl-cl-mount-info")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://notabug.org/cage/cl-mount-info.git";)
+ (commit commit)))
+ (file-name (git-file-name "cl-mount-info" version))
+ (sha256
+ (base32 "0vza9gj9q42nzb5v8aj22lmn4aqx9vrddsb5a343nbwfz89hbh9x"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria sbcl-cffi sbcl-cl-ppcre))
+ (home-page "https://notabug.org/cage/cl-mount-info.git";)
+ (synopsis "Library to get information about mounted filesystems")
+ (description
+ "CL-MOUNT-INFO is a Common Lisp wrapper around @code{getmntent(3)} and
+related C functions to get information about the mounted file system.")
+ (license license:lgpl3))))
+
+(define-public cl-mount-info
+ (sbcl-package->cl-source-package sbcl-cl-mount-info))
+
+(define-public ecl-cl-mount-info
+ (sbcl-package->ecl-package sbcl-cl-mount-info))
+
+(define-public sbcl-cl-mpg123
+ (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-mpg123")
(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"))
+ (url "https://github.com/Shirakumo/cl-mpg123";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mpg123" version))
(sha256
- (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
+ (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; Remove bundled pre-compiled libraries.
+ (delete-file-recursively "static")
+ #t))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("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-burgled-batteries3
- (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
- (revision "2"))
- (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";)
- (commit commit)))
- (file-name (git-file-name "cl-burgled-batteries3" version))
- (sha256
- (base32
- "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))
- (patches
- (search-patches "sbcl-burgled-batteries3-fix-signals.patch"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f
- #:modules (((guix build python-build-system) #:select
(python-version))
- ,@%asdf-build-system-modules)
- #:imported-modules ((guix build python-build-system)
- ,@%asdf-build-system-modules)
+ `(#:asd-systems '("cl-mpg123" "cl-mpg123-example")
#:phases
- (modify-phases (@ (guix build asdf-build-system) %standard-phases)
- (add-after 'unpack 'set-*cpython-include-dir*-var
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (let ((python (assoc-ref inputs "python")))
- (setenv "BB_PYTHON3_INCLUDE_DIR"
- (string-append python "/include/python"
- (python-version python)))
- (setenv "BB_PYTHON3_DYLIB"
- (string-append python "/lib/libpython3.so"))
- #t)))
- (add-after 'unpack 'adjust-for-python-3.10
- (lambda _
- ;; These methods are no longer part of the public API.
- (substitute* "ffi-interface.lisp"
- ((".*PyEval_ReInitThreads.*") "")
- ((".*\"PyErr_Warn\".*") "")
- ((".*\"PyFloat_ClearFreeList\".*") "")
- ((".*\"PyParser_SimpleParseString\".*") "")
- ((".*\"PyParser_SimpleParseStringFlags\".*") "")
- ((".*\"PyParser_SimpleParseStringFlagsFilename\".*") "")
- ((".*\"PyParser_SimpleParseFile\".*") "")
- ((".*\"PyParser_SimpleParseFileFlags\".*") "")
- ((".*\"PyLong_FromUnicode\".*") "")))))))
- (native-inputs
- (list sbcl-cl-fad sbcl-lift sbcl-cl-quickcheck))
+ (substitute* "low-level.lisp"
+ (("libmpg123.so" all)
+ (string-append (assoc-ref inputs "libmpg123")
+ "/lib/" all))))))))
(inputs
- (list python
- sbcl-alexandria
- sbcl-cffi
- sbcl-parse-declarations
- sbcl-trivial-garbage))
- (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)")
+ `(("cffi" ,sbcl-cffi)
+ ("cl-out123" ,sbcl-cl-out123)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("libmpg123" ,mpg123)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("verbose" ,sbcl-verbose)))
+ (home-page "https://shirakumo.github.io/cl-mpg123/";)
+ (synopsis "Common Lisp bindings to libmpg123")
(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";)
- (license license:expat))))
+ "This is a bindings and wrapper library to @code{libmpg123} allowing for
+convenient, extensive, and fast decoding of MPEG1/2/3 (most prominently mp3)
+files.")
+ (license license:zlib))))
-(define-public cl-burgled-batteries3
- (sbcl-package->cl-source-package sbcl-burgled-batteries3))
+(define-public cl-mpg123
+ (sbcl-package->cl-source-package sbcl-cl-mpg123))
-(define-public ecl-burgled-batteries3
- (sbcl-package->ecl-package sbcl-burgled-batteries3))
+(define-public ecl-cl-mpg123
+ (sbcl-package->ecl-package sbcl-cl-mpg123))
-(define-public sbcl-metabang-bind
- (let ((commit "08196426cb099db0623e6cae2aeca566e0b788b2")
- (revision "2"))
+(define-public sbcl-cl-murmurhash
+ ;; No release.
+ (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364")
+ (revision "1"))
(package
- (name "sbcl-metabang-bind")
- (version (git-version "0.8.0" revision commit))
+ (name "sbcl-cl-murmurhash")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/cl-murmurhash/";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/metabang-bind";)
+ (url home-page)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "14g7k3zhm8cd6bssc5mm5h6iq1dv5lfhiq33aimcmj5a6vbiq47d"))))
+ "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws"))))
(build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-babel))
(native-inputs
- (list sbcl-lift))
- (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
+ (list sbcl-fiveam))
+ (synopsis "32-bit version of Murmurhash3 for Common Lisp")
(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
+ "This Common Lisp package offers an implementation of the 32-bit
+variant of MurmurHash3 (@url{https://github.com/aappleby/smhasher}), a fast
+non-crytographic hashing algorithm.")
(license license:expat))))
-(define-public cl-metabang-bind
- (sbcl-package->cl-source-package sbcl-metabang-bind))
+(define-public cl-murmurhash
+ (sbcl-package->cl-source-package sbcl-cl-murmurhash))
-(define-public ecl-metabang-bind
- (sbcl-package->ecl-package sbcl-metabang-bind))
+(define-public ecl-cl-murmurhash
+ (sbcl-package->ecl-package sbcl-cl-murmurhash))
-(define-public sbcl-fare-csv
- (let ((commit "f877a238dcbf587a89359cccf2128919a94a348c")
- (revision "0"))
- (package
- (name "sbcl-fare-csv")
- (version (git-version "1.0.4" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/frideau/fare-csv";)
- (commit commit)))
- (file-name (git-file-name "cl-fare-csv" version))
- (sha256
- (base32 "0k3mf968w94m4yff1k2jh7xlnpsm016qs4448bvklacjrr72vk8x"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-hu.dwim.stefil))
- (home-page "https://gitlab.common-lisp.net/frideau/fare-csv/";)
- (synopsis "Robust CSV parser and printer")
- (description
- "This package provides a robust CSV parser and printer that tries to
-follow the fine print of de facto standards. It can be configured to choose
-which standard exactly.")
- (license license:expat))))
+(define-public sbcl-cl-mustache
+ (package
+ (name "sbcl-cl-mustache")
+ (version "0.12.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/kanru/cl-mustache";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-mustache" version))
+ (sha256
+ (base32 "149xbb6wxq1napliwm9cv729hwcgfnjli6y8hingfixz7f10lhks"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/kanru/cl-mustache";)
+ (synopsis "Common Lisp Mustache template renderer")
+ (description "This is a Common Lisp implementation for the Mustache
+template system. More details on the standard are available at
+@url{https://mustache.github.io}.";)
+ (license license:expat)))
-(define-public cl-fare-csv
- (sbcl-package->cl-source-package sbcl-fare-csv))
+(define-public cl-mustache
+ (sbcl-package->cl-source-package sbcl-cl-mustache))
-(define-public ecl-fare-csv
- (sbcl-package->ecl-package sbcl-fare-csv))
+(define-public ecl-cl-mustache
+ (sbcl-package->ecl-package sbcl-cl-mustache))
-(define-public sbcl-fare-utils
- (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
+(define-public sbcl-cl-mysql
+ (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
(revision "1"))
(package
- (name "sbcl-fare-utils")
- (version (git-version "1.0.0.5" revision commit))
+ (name "sbcl-cl-mysql")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url
- "https://gitlab.common-lisp.net/frideau/fare-utils.git";)
- (commit commit)))
+ (uri (git-reference
+ (url "https://github.com/hackinghat/cl-mysql";)
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
+ (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-hu.dwim.stefil))
- (synopsis "Collection of utilities and data structures")
+ (list 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
- "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
+ "@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-fare-utils
- (sbcl-package->cl-source-package sbcl-fare-utils))
+(define-public cl-mysql
+ (sbcl-package->cl-source-package sbcl-cl-mysql))
-(define-public ecl-fare-utils
- (sbcl-package->ecl-package sbcl-fare-utils))
+(define-public ecl-cl-mysql
+ (sbcl-package->ecl-package sbcl-cl-mysql))
-(define-public sbcl-fare-mop
- (let ((commit "538aa94590a0354f382eddd9238934763434af30")
+(define-public sbcl-cl-num-utils
+ (let ((commit "97a88cd34540acf52e872a82ebfef3da0a34fa12")
(revision "1"))
(package
- (name "sbcl-fare-mop")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-cl-num-utils")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fare/fare-mop";)
+ (url "https://github.com/tpapp/cl-num-utils";)
(commit commit)))
- (file-name (git-file-name "fare-mop" version))
+ (file-name (git-file-name "cl-num-utils" version))
(sha256
- (base32
- "0maxs8392953fhnaa6zwnm2mdbhxjxipp4g4rvypm06ixr6pyv1c"))))
+ (base32 "15ihsxxs76xnldmqfsbxybckqjwrxwcpphgghiwzr2mnbqjpdqkh"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-closer-mop sbcl-fare-utils))
- (home-page "https://github.com/fare/fare-mop";)
- (synopsis "General purpose Common Lisp utilities using the MOP")
+ (list sbcl-anaphora sbcl-alexandria sbcl-array-operations
+ sbcl-cl-slice sbcl-let-plus))
+ (native-inputs
+ (list sbcl-clunit))
+ (home-page "https://github.com/tpapp/cl-num-utils";)
+ (synopsis "Numerical utilities for Common Lisp")
(description
- "FARE-MOP is a small collection of utilities using the MetaObject
-Protocol. It notably contains a SIMPLE-PRINT-OBJECT method, and
-a SIMPLE-PRINT-OBJECT-MIXIN mixin that allow you to trivially define
-PRINT-OBJECT methods that print the interesting slots in your objects, which is
-great for REPL interaction and debugging.")
- (license license:unlicense))))
+ "@code{cl-num-utils} implements simple numerical functions for Common
+Lisp, including:
+@itemize
+@item @code{num=}, a comparison operator for floats
+@item simple arithmeric functions, like @code{sum} and @code{l2norm}
+@item elementwise operations for arrays
+@item intervals
+@item special matrices and shorthand for their input
+@item sample statistics
+@item Chebyshev polynomials
+@item univariate rootfinding
+@end itemize")
+ (license license:boost1.0))))
-(define-public ecl-fare-mop
- (sbcl-package->ecl-package sbcl-fare-mop))
+(define-public cl-num-utils
+ (sbcl-package->cl-source-package sbcl-cl-num-utils))
-(define-public cl-fare-mop
- (sbcl-package->cl-source-package sbcl-fare-mop))
+(define-public ecl-cl-num-utils
+ (sbcl-package->ecl-package sbcl-cl-num-utils))
-(define-public sbcl-inferior-shell
- (let ((commit "15c2d04a7398db965ea1c3ba2d49efa7c851f2c2")
+(define-public sbcl-cl-octet-streams
+ (package
+ (name "sbcl-cl-octet-streams")
+ (version "1.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://codeberg.org/glv/cl-octet-streams";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-trivial-gray-streams))
+ (synopsis "In-memory octet streams for Common Lisp")
+ (description
+ "CL-octet-streams is a library implementing in-memory octet
+streams for Common Lisp. It was inspired by the trivial-octet-streams and
+cl-plumbing libraries.")
+ (home-page "https://codeberg.org/glv/cl-octet-streams";)
+ (license license:gpl3+)))
+
+(define-public cl-octet-streams
+ (sbcl-package->cl-source-package sbcl-cl-octet-streams))
+
+(define-public ecl-cl-octet-streams
+ (sbcl-package->ecl-package sbcl-cl-octet-streams))
+
+(define-public sbcl-cl-online-learning
+ (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964")
(revision "1"))
(package
- (name "sbcl-inferior-shell")
- (version (git-version "2.0.5" revision commit))
+ (name "sbcl-cl-online-learning")
+ (version (git-version "0.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fare/inferior-shell";)
+ (url "https://github.com/masatoi/cl-online-learning";)
(commit commit)))
- (file-name (git-file-name "inferior-shell" version))
+ (file-name (git-file-name "cl-online-learning" version))
(sha256
- (base32 "02qx37zzk5j4xmwh77k2qa2wvnzvaj6qml5dh2q7b6b1ljvgcj4m"))))
+ (base32
+ "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-hu.dwim.stefil))
+ (list sbcl-prove))
(inputs
- (list sbcl-alexandria sbcl-fare-mop sbcl-fare-quasiquote
- sbcl-fare-utils sbcl-trivia))
- (home-page "https://github.com/fare/inferior-shell";)
- (synopsis "Spawn local or remote processes and shell pipes")
+ `(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
+ ("cl-store" ,sbcl-cl-store)))
+ (home-page "https://github.com/masatoi/cl-online-learning";)
+ (synopsis "Online Machine Learning for Common Lisp")
(description
- "This package provides a Common Lisp system helping in scripting, it
-uses @code{uiop:run-program} as a backend.")
+ "This library contains a collection of machine learning algorithms for
+online linear classification written in Common Lisp.")
(license license:expat))))
-(define-public ecl-inferior-shell
- (sbcl-package->ecl-package sbcl-inferior-shell))
+(define-public cl-online-learning
+ (sbcl-package->cl-source-package sbcl-cl-online-learning))
-(define-public cl-inferior-shell
- (sbcl-package->cl-source-package sbcl-inferior-shell))
+(define-public ecl-cl-online-learning
+ (sbcl-package->ecl-package sbcl-cl-online-learning))
-(define-public sbcl-cl-gss
- (let ((commit "60086f4fd3b82316352e7f2288edbd58f03e08c5")
+(define-public sbcl-cl-opengl
+ (let ((commit "e2d83e0977b7e7ac3f3d348d8ccc7ccd04e74d59")
(revision "1"))
(package
- (name "sbcl-cl-gss")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-opengl")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lokedhs/cl-gss";)
+ (url "https://github.com/3b/cl-opengl";)
(commit commit)))
- (file-name (git-file-name "cl-gss" version))
+ (file-name (git-file-name "cl-opengl" version))
(sha256
- (base32 "0zhxxn3zarird255s9i56bz0fm6dkv00mn8bbsjrhskg3wpcg4pb"))))
+ (base32 "0mhqmll09f079pnd6mgswz9nvr6h5n27d4q7zpmm2igf1v460id7"))))
(build-system asdf-build-system/sbcl)
(arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'patch-gss-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/functions.lisp"
- (("libgssapi_krb5.so")
- (search-input-file inputs "/lib/libgssapi_krb5.so"))))))))
+ `(#:asd-systems '("cl-opengl" "cl-glu" "cl-glut")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gl/library.lisp"
+ (("libGL.so" all)
+ (search-input-file inputs "/lib/libGL.so")))
+ (substitute* "glu/library.lisp"
+ (("libGLU.so" all)
+ (search-input-file inputs "/lib/libGLU.so")))
+ (substitute* "glut/library.lisp"
+ (("libglut.so" all)
+ (search-input-file inputs "/lib/libglut.so"))))))))
(inputs
- (list mit-krb5
- sbcl-cffi
- sbcl-trivial-garbage
- sbcl-trivial-utf-8))
- (home-page "https://github.com/lokedhs/cl-gss";)
- (synopsis "Common Lisp CFFI bindings to Generic Security Service (GSS)")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("float-features" ,sbcl-float-features)
+ ("freeglut" ,freeglut)
+ ("glu" ,glu)
+ ("mesa" ,mesa)))
+ (home-page "https://github.com/3b/cl-opengl";)
+ (synopsis "Common Lisp bindings to OpenGL, GLU and GLUT APIs")
(description
- "This package provides Common Lisp bindings to GSSAPI, which is
-designed to provide a standard API to authentication services. The API itself
-is generic, and the system can provide different underlying implementations.
-The most common one is Kerberos, which has several implementations, the most
-common of which is probably Active Directory.")
+ "This package provides a set of bindings and utilities for accessing the
+OpenGL (Mesa), GLU and GLUT (FreeGLUT) APIs using CFFI.")
(license license:bsd-3))))
-(define-public ecl-cl-gss
- (sbcl-package->ecl-package sbcl-cl-gss))
+(define-public cl-opengl
+ (sbcl-package->cl-source-package sbcl-cl-opengl))
-(define-public cl-gss
- (sbcl-package->cl-source-package sbcl-cl-gss))
+(define-public ecl-cl-opengl
+ (sbcl-package->ecl-package sbcl-cl-opengl))
-(define-public sbcl-trivial-utf-8
- (let ((commit "6ca9943588cbc61ad22a3c1ff81beb371e122394")
+(define-public sbcl-cl-out123
+ (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7")
(revision "2"))
(package
- (name "sbcl-trivial-utf-8")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-out123")
+ (version (git-version "1.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 "cl-trivial-utf-8" version))
+ (uri (git-reference
+ (url "https://github.com/Shirakumo/cl-out123";)
+ (commit commit)))
+ (file-name (git-file-name "cl-out123" version))
(sha256
- (base32 "0gzgbyzbbhny5y1lq2x82vfy4b4p1snq1sy9lj82hdq7lkyj03ss"))))
- (arguments
- ;; Guix incorrectly assumes the "8" is part of the version
- ;; number and lobs it off.
- `(#:asd-systems '("trivial-utf-8")))
+ (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; Remove bundled pre-compiled libraries.
+ (delete-file-recursively "static")))))
(build-system asdf-build-system/sbcl)
- (synopsis "UTF-8 input/output library")
+ (arguments
+ `(#:tests? #f ; No tests
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "low-level.lisp"
+ (("libout123.so")
+ (search-input-file inputs "/lib/libout123.so"))))))))
+ (inputs
+ (list mpg123
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (home-page "https://shirakumo.github.io/cl-out123/";)
+ (synopsis "Common Lisp bindings to libout123")
(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))))
+ "This is a bindings library to @code{libout123} which allows easy
+cross-platform audio playback.")
+ (license license:zlib))))
-(define-public cl-trivial-utf-8
- (sbcl-package->cl-source-package sbcl-trivial-utf-8))
+(define-public cl-out123
+ (sbcl-package->cl-source-package sbcl-cl-out123))
-(define-public ecl-trivial-utf-8
- (sbcl-package->ecl-package sbcl-trivial-utf-8))
+(define-public ecl-cl-out123
+ (sbcl-package->ecl-package sbcl-cl-out123))
-(define-public sbcl-trivial-utilities
- (let ((commit "279ff255562628196942632c543d91c357067221")
- (revision "0"))
+(define-public sbcl-cl-package-locks
+ (let ((commit "96a358ede7cef416d61d2f699e724fe1d9de602c")
+ (revision "1"))
(package
- (name "sbcl-trivial-utilities")
- (version (git-version "0.4.0" revision commit))
+ (name "sbcl-cl-package-locks")
+ (version (git-version "0.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/ediethelm/trivial-utilities";)
+ (url "https://github.com/elliottjohnson/cl-package-locks";)
(commit commit)))
- (file-name (git-file-name "trivial-utilities" version))
+ (file-name (git-file-name "cl-package-locks" version))
(sha256
- (base32 "0k1xmn5f5dik7scadw0vyy67mik4ypnfqbhlv2vsg9afxzbpx2dz"))))
+ (base32 "0g3gfljnvpgd66ccd2sqawlkwqx4a0wsdrg5180va61w869cgxqq"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-iterate sbcl-closer-mop))
- (home-page "https://gitlab.com/ediethelm/trivial-utilities";)
- (synopsis "Collection of useful types, functions and macros for Common
Lisp")
- (description
- "This package provides a collection of types, functions and macros.
Some
- of the functionality is implemented from Graham's On Lisp and Seibel's
Practical
- Common Lisp.")
+ (home-page "https://github.com/elliottjohnson/cl-package-locks";)
+ (synopsis "Compatibility layer for dealing with package locks")
+ (description
+ "This is a Common Lisp library providing a unified way to work with
+package locks across supported Common Lisp implementations.")
(license license:expat))))
-(define-public cl-trivial-utilities
- (sbcl-package->cl-source-package sbcl-trivial-utilities))
-
-(define-public ecl-trivial-utilities
- (sbcl-package->ecl-package sbcl-trivial-utilities))
-
-(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
- (list 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.2")
- (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
- "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
- (inputs
- (list sbcl-trivial-features))
- (native-inputs
- (list sbcl-fiveam))
- (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 cl-package-locks
+ (sbcl-package->cl-source-package sbcl-cl-package-locks))
-(define-public ecl-swap-bytes
- (sbcl-package->ecl-package sbcl-swap-bytes))
+(define-public ecl-cl-package-locks
+ (sbcl-package->ecl-package sbcl-cl-package-locks))
-(define-public sbcl-iolib
- (let ((commit "010b7a6bdd2e918ebf2ec85edd3853179f01cb30")
- (revision "0"))
+(define-public sbcl-cl-pass
+ (let ((commit "e58e97c0c0588dc742c061208afb9bc31e4dbd34")
+ (revision "1"))
(package
- (name "sbcl-iolib")
- (version (git-version "0.8.4" revision commit))
- (home-page "https://github.com/sionescu/iolib";)
+ (name "sbcl-cl-pass")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/eudoxia0/cl-pass";)
(commit commit)))
- (file-name (git-file-name "cl-iolib" version))
+ (file-name (git-file-name "cl-pass" version))
(sha256
- (base32 "1qqy2yhprkmdn2vmi69akf818q3n99gv8cacv6456af0wjm5p1ga"))))
+ (base32 "05qx4jrkxqbqi72cxgswbpnifbdvp9mh7apc7566v522899bh0hb"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list pkg-config sbcl-fiveam))
(inputs
- (list libfixposix
- sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-idna
- sbcl-split-sequence
- sbcl-swap-bytes))
- (arguments
- '(#:asd-systems '("iolib"
- "iolib/os")
- #: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.asd"
- (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\"
\"defsuites\"\\)\\)")
- "")))))))
- (synopsis "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.")
+ (list sbcl-ironclad sbcl-trivial-utf-8 sbcl-split-sequence))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/eudoxia0/cl-pass";)
+ (synopsis "Password hashing and verification library")
+ (description
+ "@code{cl-pass} is a password hashing and verification library.")
(license license:expat))))
-(define-public cl-iolib
- (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
- (package
- (inherit parent)
- (propagated-inputs
- ;; Need header to compile.
- (modify-inputs (package-propagated-inputs parent)
- (prepend libfixposix))))))
+(define-public cl-pass
+ (sbcl-package->cl-source-package sbcl-cl-pass))
-(define-public ecl-iolib
- (sbcl-package->ecl-package sbcl-iolib))
+(define-public ecl-cl-pass
+ (sbcl-package->ecl-package sbcl-cl-pass))
-(define-public sbcl-ieee-floats
- (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
+(define-public sbcl-cl-pcg
+ (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f")
(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/";)
+ (name "sbcl-cl-pcg")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/sjl/cl-pcg";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-pcg" version))
(sha256
- (base32
- "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
+ (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
- (synopsis "IEEE 754 binary representation for floats in Common Lisp")
- (description "This is a Common Lisp library that converts
-floating point values to IEEE 754 binary representation.")
- (license license:bsd-3))))
+ (list sbcl-1am))
+ (home-page "https://github.com/sjl/cl-pcg";)
+ (synopsis "Permuted congruential generators in Common Lisp")
+ (description
+ "This is a bare-bones Permuted Congruential Generator implementation in
+pure Common Lisp.")
+ (license license:expat))))
-(define-public cl-ieee-floats
- (sbcl-package->cl-source-package sbcl-ieee-floats))
+(define-public cl-pcg
+ (sbcl-package->cl-source-package sbcl-cl-pcg))
-(define-public ecl-ieee-floats
- (sbcl-package->ecl-package sbcl-ieee-floats))
+(define-public ecl-cl-pcg
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-pcg)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; Tests are failing on ECL with:
+ ;; PCG.TEST::TEST-REWINDAn error occurred during initialization:
+ ;; 40502229875678917802724098623316930025 is not of type
+ ;; (INTEGER 0 2305843009213693951)
+ ((#:tests? _ #f) #f))))))
-(define sbcl-closure-common
- (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
- (revision "1"))
+(define-public sbcl-cl-pdf
+ (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213")
+ (revision "3"))
(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/";)
+ (name "sbcl-cl-pdf")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/closure-common";)
+ (url "https://github.com/mbattyani/cl-pdf";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-pdf" version))
(sha256
- (base32
- "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
+ (base32 "0j7hbqv6yzrgx0inqinpw8h22728l53ccciw6iymzz4g92j9fzlq"))))
+ (build-system asdf-build-system/sbcl)
(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))))
+ (list sbcl-iterate sbcl-zpb-ttf))
+ (arguments
+ `(#:asd-systems '("cl-pdf" "cl-pdf-parser")))
+ (home-page "https://github.com/mbattyani/cl-pdf";)
+ (synopsis "Common Lisp library for generating PDF files")
+ (description
+ "CL-PDF is a cross-platform Common Lisp library for generating PDF
+files.")
+ (license license:bsd-2))))
-(define-public sbcl-cxml
- (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
- (revision "1"))
+(define-public cl-pdf
+ (sbcl-package->cl-source-package sbcl-cl-pdf))
+
+(define-public ecl-cl-pdf
+ (sbcl-package->ecl-package sbcl-cl-pdf))
+
+(define-public sbcl-cl-permutation
+ (let ((commit "20c10e9ca56452d2fafc3ec0984dcdf78b4f4b19")
+ (revision "0"))
(package
- (name "sbcl-cxml")
+ (name "sbcl-cl-permutation")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/cxml";)
+ (url "https://github.com/stylewarning/cl-permutation";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-permutation" version))
(sha256
- (base32
- "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
+ (base32 "0i932g0k50y24hxizni6zfya4kcw77yk3b0llivm9g50s7fxj9dk"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-closure-common sbcl-puri sbcl-trivial-gray-streams))
- (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.")
- (home-page "https://common-lisp.net/project/cxml/";)
- (license license:llgpl))))
+ (native-inputs (list sbcl-fiasco))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-bordeaux-fft
+ sbcl-cl-algebraic-data-type
+ sbcl-cl-cont
+ sbcl-closer-mop
+ sbcl-iterate
+ sbcl-priority-queue))
+ (synopsis "Permutations and permutation groups in Common Lisp")
+ (description
+ "This is a Commin Lisp library for operating on permutations and
+permutation groups.")
+ (home-page "https://github.com/stylewarning/cl-permutation";)
+ (license license:bsd-3))))
-(define-public cl-cxml
- (sbcl-package->cl-source-package sbcl-cxml))
+(define-public cl-permutation
+ (sbcl-package->cl-source-package sbcl-cl-permutation))
-(define-public ecl-cxml
- (sbcl-package->ecl-package sbcl-cxml))
+(define-public ecl-cl-permutation
+ (sbcl-package->ecl-package sbcl-cl-permutation))
-(define-public sbcl-cxml-rng
- (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b")
+(define-public sbcl-cl-portaudio
+ (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f")
(revision "1"))
(package
- (name "sbcl-cxml-rng")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-portaudio")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://www.lichteblau.com/git/cxml-rng.git";)
+ (url "https://github.com/filonenko-mikhail/cl-portaudio";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-portaudio" version))
(sha256
- (base32
- "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql"))))
+ (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cxml sbcl-cl-ppcre sbcl-cl-yacc sbcl-parse-number
- sbcl-cl-base64))
- (synopsis "Relax NG for Closure XML (CXML)")
- (description "An implementation of Relax NG schema validation written in
-Common Lisp, including support for compact syntax, DTD Compatibility, and the
-XSD type library.")
- (home-page "http://www.lichteblau.com/cxml-rng/";)
- (license license:bsd-2))))
+ (inputs
+ (list portaudio sbcl-cffi sbcl-ffa))
+ (arguments
+ (list #:tests? #f ; Tests need access to sound cards
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/portaudio.lisp"
+ (("libportaudio\\.so")
+ (search-input-file inputs
"/lib/libportaudio.so"))))))))
+ (synopsis "Common Lisp bindings to portaudio")
+ (description
+ "This package provides audio input and output functions to Common Lisp
+using bindings to the portaudio library.")
+ (home-page "https://github.com/filonenko-mikhail/cl-portaudio";)
+ (license license:expat))))
-(define-public cl-cxml-rng
- (sbcl-package->cl-source-package sbcl-cxml-rng))
+(define-public cl-portaudio
+ (sbcl-package->cl-source-package sbcl-cl-portaudio))
-;; FIXME: Fails on ECL with
-;; In function STRUCTURE-SET, the value of the first argument is
-;; #<empty 0x7fffeb0fd440>
-;; which is not of the expected type %TYPED-PATTERN.
-;; (define-public ecl-cxml-rng
-;; (sbcl-package->ecl-package sbcl-cxml-rng))
+(define-public ecl-cl-portaudio
+ (sbcl-package->ecl-package sbcl-cl-portaudio))
-(define-public sbcl-cl-reexport
- (let ((commit "03ad7a0e7307e510b3b25a622d3c5f8a077879b4")
- (revision "2"))
+(define-public sbcl-cl-posix-mqueue
+ (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f")
+ (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";)
+ (name "sbcl-cl-posix-mqueue")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/takagi/cl-reexport";)
+ (url "https://github.com/xFA25E/cl-posix-mqueue";)
(commit commit)))
- (file-name (git-file-name "cl-reexport" version))
+ (file-name (git-file-name "cl-posix-mqueue" version))
(sha256
- (base32
- "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc"))))
- (inputs
- (list sbcl-alexandria))
+ (base32 "04519rg8vc782z097dzlb8nx0skab2fy2zd0m60r6mz2nw8xdvh6"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-librt-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/spec.lisp"
+ (("librt.so" all)
+ (string-append (assoc-ref inputs "glibc") "/lib/" all))))))))
(native-inputs
- (list sbcl-prove))
- (synopsis "Reexport external symbols in other Common Lisp packages")
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("rove" ,sbcl-rove)))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("cffi" ,sbcl-cffi)
+ ("glibc" ,glibc)
+ ("local-time" ,sbcl-local-time)))
+ (home-page "https://github.com/xFA25E/cl-posix-mqueue";)
+ (synopsis "Common Lisp binding to POSIX mqueue")
(description
- "Cl-reexport makes a package reexport symbols which are external
-symbols in other Common Lisp packages. This functionality is intended to be
-used with (virtual) hierarchical packages.")
- (license license:llgpl))))
+ "This package provides Common Lisp bindings to POSIX message queue, an
+@acronym{IPC, Inter-Process Communication} method that is easy to use and quick
+to setup.")
+ (license license:gpl3))))
-(define-public cl-reexport
- (sbcl-package->cl-source-package sbcl-cl-reexport))
+(define-public cl-posix-mqueue
+ (sbcl-package->cl-source-package sbcl-cl-posix-mqueue))
-(define-public ecl-cl-reexport
- (sbcl-package->ecl-package sbcl-cl-reexport))
+(define-public ecl-cl-posix-mqueue
+ (sbcl-package->ecl-package sbcl-cl-posix-mqueue))
-(define-public sbcl-cl-cookie
- (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
- (revision "1"))
+(define-public sbcl-cl-ppcre
+ (package
+ (name "sbcl-cl-ppcre")
+ (version "2.1.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-ppcre";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-ppcre" version))
+ (sha256
+ (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-flexi-streams))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-ppcre-unicode
+ ;; cl-ppcre and cl-ppcre-unicode are put in different packages
+ ;; to work around the circular dependency between edicl/cl-ppcre
+ ;; and edicl/cl-unicode.
+ (lambda _
+ (delete-file "cl-ppcre-unicode.asd")
+ #t)))))
+ (synopsis "Portable regular expression library for Common Lisp")
+ (description "CL-PPCRE is a portable regular expression library for Common
+Lisp, which is compatible with perl. It is pretty fast, thread-safe, and
+compatible with ANSI-compliant Common Lisp implementations.")
+ (home-page "http://weitz.de/cl-ppcre/";)
+ (license license:bsd-2)))
+
+(define-public cl-ppcre
+ (sbcl-package->cl-source-package sbcl-cl-ppcre))
+
+(define-public ecl-cl-ppcre
+ (sbcl-package->ecl-package sbcl-cl-ppcre))
+
+(define-public sbcl-cl-ppcre-unicode
+ (package (inherit sbcl-cl-ppcre)
+ (name "sbcl-cl-ppcre-unicode")
+ (inputs
+ (list sbcl-cl-ppcre sbcl-cl-unicode))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'disable-ppcre
+ ;; cl-ppcre and cl-ppcre-unicode are put in different packages
+ ;; to work around the circular dependency between edicl/cl-ppcre
+ ;; and edicl/cl-unicode.
+ (lambda _
+ (delete-file "cl-ppcre.asd")
+ #t)))))))
+
+(define-public cl-ppcre-unicode
+ (sbcl-package->cl-source-package sbcl-cl-ppcre-unicode))
+
+(define-public ecl-cl-ppcre-unicode
+ (sbcl-package->ecl-package sbcl-cl-ppcre-unicode))
+
+(define-public sbcl-cl-prevalence
+ (let ((commit "e6b27640ce89ae5f8af38beb740e319bb6cd2368")
+ (revision "6"))
(package
- (name "sbcl-cl-cookie")
+ (name "sbcl-cl-prevalence")
(build-system asdf-build-system/sbcl)
- (version (git-version "0.9.10" revision commit))
- (home-page "https://github.com/fukamachi/cl-cookie";)
+ (version (git-version "5" revision commit))
+ (home-page "https://github.com/40ants/cl-prevalence";)
(source
(origin
(method git-fetch)
@@ -8838,5785 +8137,5795 @@ used with (virtual) hierarchical packages.")
(file-name (git-file-name name version))
(sha256
(base32
- "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
+ "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0"))))
(inputs
- `(("proc-parse" ,sbcl-proc-parse)
- ("alexandria" ,sbcl-alexandria)
- ("quri" ,sbcl-quri)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)))
+ (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml))
(native-inputs
- (list sbcl-prove))
- (arguments
- '(#:asd-systems '("cl-cookie-test" "cl-cookie")))
- (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))))
+ (list sbcl-fiveam sbcl-find-port))
+ (synopsis "Implementation of object prevalence for Common Lisp")
+ (description "This Common Lisp library implements object prevalence (see
+@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
+for (de)serializing to and from s-exps as well as XML. Serialization of
arbitrary
+classes and cyclic data structures are supported.")
+ (license license:llgpl))))
-(define-public cl-cookie
- (sbcl-package->cl-source-package sbcl-cl-cookie))
+(define-public cl-prevalence
+ (sbcl-package->cl-source-package sbcl-cl-prevalence))
-(define-public ecl-cl-cookie
- (sbcl-package->ecl-package sbcl-cl-cookie))
+(define-public ecl-cl-prevalence
+ (sbcl-package->ecl-package sbcl-cl-prevalence))
-(define-public sbcl-dexador
- (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5")
- (revision "2"))
+(define-public sbcl-cl-progress-bar
+ (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae"))
(package
- (name "sbcl-dexador")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.9.15" revision commit))
- (home-page "https://github.com/fukamachi/dexador";)
+ (name "sbcl-cl-progress-bar")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/sirherrbatka/cl-progress-bar/";)
(commit commit)))
- (file-name (git-file-name "cl-dexador" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1sggpi43la8dai102fmkzysh7760hvk6q68f0pkbb9187vz8nd3y"))))
- (inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-chipz
- sbcl-chunga
- sbcl-cl+ssl
- sbcl-cl-base64
- sbcl-cl-cookie
- sbcl-cl-ppcre
- sbcl-fast-http
- sbcl-fast-io
- sbcl-quri
- sbcl-trivial-garbage
- sbcl-trivial-gray-streams
- sbcl-trivial-mimes
- sbcl-usocket))
- ;; These native-inputs are for tests only, which are disabled.
- ;; Leave them commented since they add a lot to the closure size.
- ;; (native-inputs
- ;; (list sbcl-clack
- ;; sbcl-lack
- ;; sbcl-rove))
- (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.")
+ (base32 "1ldb4qhmx431n3lsq71ynwb9ybazbfqd55icjbhi06mj52ngndir"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-bordeaux-threads sbcl-documentation-utils-extensions))
+ (home-page "https://github.com/sirherrbatka/cl-progress-bar/";)
+ (synopsis "Progress bars in Common Lisp")
+ (description
+ "This library provides almost the same code as used inside Quicklisp
+for drawning progress bars")
(license license:expat))))
-(define-public cl-dexador
- (package
- (inherit (sbcl-package->cl-source-package sbcl-dexador))
- (arguments
- `(#:phases
- ;; asdf-build-system/source has its own phases and does not inherit
- ;; from asdf-build-system/sbcl phases.
- (modify-phases %standard-phases/source
- ;; Already done in SBCL package.
- (delete 'reset-gzip-timestamps))))))
+(define-public cl-progress-bar
+ (sbcl-package->cl-source-package sbcl-cl-progress-bar))
-(define-public ecl-dexador
- (sbcl-package->ecl-package sbcl-dexador))
+(define-public ecl-cl-progress-bar
+ (sbcl-package->ecl-package sbcl-cl-progress-bar))
-(define-public sbcl-lisp-namespace
- (let ((commit "699fccb6727027343bb5fca69162a3113996edfc")
- (revision "2"))
+(define-public sbcl-cl-project
+ (let ((commit "151107014e534fc4666222d57fec2cc8549c8814")
+ (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";)
+ (name "sbcl-cl-project")
+ (version (git-version "0.3.1" revision commit))
+ (home-page "https://github.com/fukamachi/cl-project";)
(source
(origin
(method git-fetch)
(uri (git-reference
(url home-page)
(commit commit)))
- (file-name (git-file-name "cl-lisp-namespace" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1p5db9mab4whapy1pl38ajw5fkrrdw266n05mnhf4xx2fb9sbx6p"))))
+ (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (native-inputs
- (list sbcl-fiveam))
- (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.")
+ `(("cl-emb" ,sbcl-cl-emb)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)
+ ("prove" ,sbcl-prove)))
+ (arguments
+ ;; Tests depend on caveman, which in turns depends on cl-project.
+ '(#:tests? #f))
+ (synopsis "Generate a skeleton for modern Common Lisp projects")
+ (description "This library provides a modern project skeleton generator.
+In contract with other generators, CL-Project generates one package per file
+and encourages unit testing by generating a system for unit testing, so you
+can begin writing unit tests as soon as the project is generated.")
(license license:llgpl))))
-(define-public cl-lisp-namespace
- (sbcl-package->cl-source-package sbcl-lisp-namespace))
+(define-public cl-project
+ (sbcl-package->cl-source-package sbcl-cl-project))
-(define-public ecl-lisp-namespace
- (sbcl-package->ecl-package sbcl-lisp-namespace))
+(define-public ecl-cl-project
+ (sbcl-package->ecl-package sbcl-cl-project))
-(define-public sbcl-trivial-cltl2
- (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
- (revision "2"))
+(define-public sbcl-cl-punch
+ (package
+ (name "sbcl-cl-punch")
+ (version "0.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/windymelt/cl-punch";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-punch" version))
+ (sha256
+ (base32 "1vmbaz9y9lq4wvi8mfbyif8vc9yfk2i0qd3ysbzl152wx32dbzs3"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove))
+ (inputs
+ (list sbcl-cl-syntax))
+ (home-page "https://github.com/windymelt/cl-punch";)
+ (synopsis "Anonymous lambda literal in Common Lisp, respecting Scala")
+ (description
+ "CL-PUNCH is a Scala-like anonymous lambda literal.")
+ (license license:expat )))
+
+(define-public cl-punch
+ (sbcl-package->cl-source-package sbcl-cl-punch))
+
+(define-public ecl-cl-punch
+ (sbcl-package->ecl-package sbcl-cl-punch))
+
+(define-public sbcl-cl-qprint
+ (let ((commit "bfe398551cbfb7ca84a9ba59a26a1116ac5c06eb")
+ (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";)
+ (name "sbcl-cl-qprint")
+ (version (git-version "0.9.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/eugeneia/cl-qprint/";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
- (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))))
+ (base32 "099h0rrdzxnlmn8avi72mg2dl0kccp7w01b2p9nwyy4b8yr32cir"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-flexi-streams))
+ (home-page "https://github.com/eugeneia/cl-qprint/";)
+ (synopsis "Implementation of the quoted-printable encoding")
+ (description
+ "This Common Lisp library implements the quoted-printable encoding as
+described in RFC 2045 (see @url{http://tools.ietf.org/html/rfc2045}).")
+ (license license:lgpl2.1))))
-(define-public cl-trivial-cltl2
- (sbcl-package->cl-source-package sbcl-trivial-cltl2))
+(define-public cl-qprint
+ (sbcl-package->cl-source-package sbcl-cl-qprint))
-(define-public ecl-trivial-cltl2
- (sbcl-package->ecl-package sbcl-trivial-cltl2))
+(define-public ecl-cl-qprint
+ (sbcl-package->ecl-package sbcl-cl-qprint))
-(define-public sbcl-introspect-environment
- (let ((commit "8fb20a1a33d29637a22943243d1482a20c32d6ae")
- (revision "2"))
+(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";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lisp-unit))
+ (inputs
+ (list 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-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";)
+ (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
+ `(#: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-cl-random
+ (let ((commit "5bb65911037f95a4260bd29a594a09df3849f4ea")
+ (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";)
+ (name "sbcl-cl-random")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/tpapp/cl-random";)
(commit commit)))
- (file-name (git-file-name "cl-introspect-environment" version))
+ (file-name (git-file-name "cl-random" version))
(sha256
- (base32 "1p48jnr1im47529w0ciyar4hfwbivqi57zgllkmfrav09ffigk9s"))))
- (native-inputs
- (list 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 cl-introspect-environment
- (sbcl-package->cl-source-package sbcl-introspect-environment))
-
-(define-public ecl-introspect-environment
- (sbcl-package->ecl-package sbcl-introspect-environment))
-
-(define-public sbcl-compiler-macro
- (let ((commit "7796bda64aec5af3ca175170ad3565167868789c")
- (revision "0"))
- (package
- (name "sbcl-compiler-macro")
- (version (git-version "0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Bike/compiler-macro";)
- (commit commit)))
- (file-name (git-file-name "cl-compiler-macro" version))
- (sha256
- (base32 "13sswps7s0qy6939mvj8q57hkx0qkga6rl6xjhjr7pk7by0xdsjq"))))
+ (base32 "0jn80xphyvyp2v72acr6b8a2f6dw06myr5vrjfl14brsvks7wr89"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-introspect-environment))
- (home-page "https://github.com/Bike/compiler-macro";)
- (synopsis "Common Lisp compiler macro utilities")
- (description "This library is a collection of utilities for writing
-compiler macros. It is intended to make it possible to make compiler macros
-much more useful, by granting them access to lexical type information, making
-the protocol for declining expansion more convenient, and establishing some
-information for signaling optimization advice to programmers. Some utilities
-to support this, especially for reasoning on types, are also included.")
- (license license:cc0))))
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-array-operations
+ sbcl-cl-num-utils
+ sbcl-cl-rmath
+ sbcl-cl-slice
+ sbcl-gsll
+ sbcl-let-plus
+ sbcl-lla))
+ (native-inputs
+ (list sbcl-clunit))
+ (home-page "https://github.com/tpapp/cl-random";)
+ (synopsis "Random variates for Common Lisp")
+ (description
+ "@code{cl-random} is a library for generating random draws from various
+commonly used distributions, and for calculating statistical functions, such as
+density, distribution and quantiles for these distributions.")
+ (license license:expat))))
-(define-public cl-compiler-macro
- (sbcl-package->cl-source-package sbcl-compiler-macro))
+(define-public cl-random
+ (sbcl-package->cl-source-package sbcl-cl-random))
-(define-public ecl-compiler-macro
- (sbcl-package->ecl-package sbcl-compiler-macro))
+(define-public ecl-cl-random
+ (sbcl-package->ecl-package sbcl-cl-random))
-(define-public sbcl-type-i
- (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
- (revision "2"))
+(define-public sbcl-cl-random-forest
+ (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
+ (revision "1"))
(package
- (name "sbcl-type-i")
- (build-system asdf-build-system/sbcl)
+ (name "sbcl-cl-random-forest")
(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)
+ (url "https://github.com/masatoi/cl-random-forest";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
+ "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
(inputs
`(("alexandria" ,sbcl-alexandria)
- ("introspect-environment" ,sbcl-introspect-environment)
- ("trivia.trivial" ,sbcl-trivia.trivial)))
- (native-inputs
- (list sbcl-fiveam))
- (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))))
+ ("cl-libsvm-format" ,sbcl-cl-libsvm-format)
+ ("cl-online-learning" ,sbcl-cl-online-learning)
+ ("lparallel" ,sbcl-lparallel)))
+ (arguments
+ `(#:tests? #f)) ; The tests download data from the Internet
+ (synopsis "Random Forest and Global Refinement for Common Lisp")
+ (description
+ "CL-random-forest is an implementation of Random Forest for multiclass
+classification and univariate regression written in Common Lisp. It also
+includes an implementation of Global Refinement of Random Forest.")
+ (home-page "https://github.com/masatoi/cl-random-forest";)
+ (license license:expat))))
-(define-public cl-type-i
- (sbcl-package->cl-source-package sbcl-type-i))
+(define-public cl-random-forest
+ (sbcl-package->cl-source-package sbcl-cl-random-forest))
-(define-public ecl-type-i
- (package
- (inherit (sbcl-package->ecl-package sbcl-type-i))
- (arguments
- ;; The tests get stuck indefinitly
- '(#:tests? #f))))
+(define-public ecl-cl-random-forest
+ (sbcl-package->ecl-package sbcl-cl-random-forest))
-(define-public sbcl-simplified-types
- (let ((commit "8fd0727a70a9de76289ac62c1567b8d278e7434e")
+(define-public sbcl-cl-raylib
+ (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d")
(revision "0"))
(package
- (name "sbcl-simplified-types")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-raylib")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/simplified-types";)
+ (url "https://github.com/longlene/cl-raylib";)
(commit commit)))
- (file-name (git-file-name "cl-simplified-types" version))
+ (file-name (git-file-name "cl-raylib" version))
(sha256
- (base32 "1hdwmn5lz717aj6qdqmfmr3cbjl8l3giwn0fb5ca9pj83cx7fg8y"))))
+ (base32 "1kighj35g6dn426mhr2ppz3gm49v1q4n42ydn619pclrqwyrnc2z"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; no tests https://github.com/longlene/cl-raylib/issues/40
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libraylib\\.so")
+ (search-input-file inputs "/lib/libraylib.so"))))))))
(inputs
- (list sbcl-alexandria
- sbcl-introspect-environment
- sbcl-trivia))
- (home-page "https://github.com/marcoheisig/simplified-types";)
- (synopsis "Simplify Common Lisp type specifiers")
- (description
- "Simplified-Types is a library that provides functions for simplifying
-Common Lisp type specifiers. The API consists of two functions:
-
-@itemize
-@item @code{simplify-type} takes a type specifier and, optionally, an
-environment, and returns the corresponding simplified type.
-@item @code{simplified-type-of} takes an object and returns the simplified
-type of that object.
-@end itemize")
+ (list raylib
+ sbcl-3d-matrices
+ sbcl-3d-vectors
+ sbcl-alexandria
+ sbcl-cffi))
+ (home-page "https://github.com/longlene/cl-raylib";)
+ (synopsis "Common Lisp bindings to raylib")
+ (description "This package provides Common Lisp CFFI bindings to the
+Raylib game development library.")
(license license:expat))))
-(define-public cl-simplified-types
- (sbcl-package->cl-source-package sbcl-simplified-types))
+(define-public cl-raylib
+ (sbcl-package->cl-source-package sbcl-cl-raylib))
-(define-public ecl-simplified-types
- (sbcl-package->ecl-package sbcl-simplified-types))
+(define-public ecl-cl-raylib
+ (sbcl-package->ecl-package sbcl-cl-raylib))
-(define-public sbcl-typo
- (let ((commit "0e883490f81edf2a1be4e5b101d1caec78d7853b")
- (revision "0"))
+(define-public sbcl-cl-rdkafka
+ (package
+ (name "sbcl-cl-rdkafka")
+ (version "1.1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/SahilKang/cl-rdkafka";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; Attempts to connect to locally running Kafka
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/low-level/librdkafka-bindings.lisp"
+ (("librdkafka" all)
+ (string-append (assoc-ref inputs "librdkafka") "/lib/"
+ all))))))))
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("librdkafka" ,librdkafka)
+ ("lparallel" ,sbcl-lparallel)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (home-page "https://github.com/SahilKang/cl-rdkafka";)
+ (synopsis "Common Lisp client library for Apache Kafka")
+ (description "A Common Lisp client library for Apache Kafka.")
+ (license license:gpl3)))
+
+(define-public cl-rdkafka
+ (sbcl-package->cl-source-package sbcl-cl-rdkafka))
+
+(define-public ecl-cl-rdkafka
+ (sbcl-package->ecl-package sbcl-cl-rdkafka))
+
+(define-public sbcl-cl-readline
+ (let ((commit "8438c9ebd92ccc95ebab9cc9cbe6c72d44fccc58")
+ (revision "1"))
(package
- (name "sbcl-typo")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-readline")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/Typo";)
+ (url "https://github.com/vindarel/cl-readline";)
(commit commit)))
- (file-name (git-file-name "cl-typo" version))
+ (file-name (git-file-name "cl-readline" version))
(sha256
- (base32 "08cmkjl3f77rfhxbjyd6f3kinhzak30mdfphnpf73sh1vw4v0vym"))))
+ (base32 "14iskvqfw71ssaav483vmqw62lrpznysjs800gjjppxs785p1fa0"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-introspect-environment
- sbcl-trivia
- sbcl-trivial-arguments
- sbcl-trivial-garbage))
- (home-page "https://github.com/marcoheisig/Typo";)
- (synopsis "Portable type inference library for Common Lisp")
- (description
- "Typo is a portable library for Common Lisp that does approximate
-reasoning about types, but without consing.")
- (license license:expat))))
-
-(define-public cl-typo
- (sbcl-package->cl-source-package sbcl-typo))
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("readline" ,readline)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "cl-readline.lisp"
+ (("libreadline.so")
+ (string-append (assoc-ref inputs "readline")
+ "/lib/libreadline.so"))))))))
+ (home-page "https://github.com/vindarel/cl-readline";)
+ (synopsis "Common Lisp bindings to the GNU Readline library")
+ (description
+ "The Readline library provides a set of functions for use by
+applications that allow users to edit command lines as they are typed in.
+Both Emacs and vi editing modes are available. The Readline library includes
+additional functions to maintain a list of previously-entered command lines, to
+recall and perhaps reedit those lines, and perform csh-like history expansion
on
+previous commands.")
+ (license license:gpl3+))))
-(define-public ecl-typo
- (sbcl-package->ecl-package sbcl-typo))
+(define-public cl-readline
+ (sbcl-package->cl-source-package sbcl-cl-readline))
-(define-public sbcl-optima
- (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
- (revision "1"))
+(define-public ecl-cl-readline
+ (sbcl-package->ecl-package sbcl-cl-readline))
+
+(define-public sbcl-cl-redis
+ (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d")
+ (revision "0"))
(package
- (name "sbcl-optima")
+ (name "sbcl-cl-redis")
+ (version (git-version "2.3.8" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/vseloved/cl-redis";)
+ (commit commit)))
+ (file-name (git-file-name "cl-redis" version))
+ (sha256
+ (base32 "0x5ahxb5cx37biyn3cjycshhm1rr9p5cf1a9l5hd1n1xjxm2f8vi"))))
(build-system asdf-build-system/sbcl)
- (version (git-version "1.0" revision commit))
- (home-page "https://github.com/m2ym/optima";)
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-before 'check 'start-redis
+ (lambda _
+ (system "redis-server --port 6379 &"))))))
+ (native-inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("redis" ,redis)
+ ("should-test" ,sbcl-should-test)))
+ (inputs
+ `(("babel" ,sbcl-babel)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("flexi-streams" ,sbcl-flexi-streams)
+ ("rutils" ,sbcl-rutils)
+ ("usocket" ,sbcl-usocket)))
+ (home-page "https://github.com/vseloved/cl-redis";)
+ (synopsis "Common Lisp client for Redis")
+ (description "This is a Common Lisp wrapper for interacting with the
+Redis data structure store.")
+ (license license:expat))))
+
+(define-public cl-redis
+ (sbcl-package->cl-source-package sbcl-cl-redis))
+
+(define-public ecl-cl-redis
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-redis)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; Tests are failing on ECL with:
+ ;; Test L-COMMANDS: An error occurred during initialization:
+ ;; Protocol not found: "tcp".
+ ((#:tests? _ #f) #f))))))
+
+(define-public sbcl-cl-reexport
+ (let ((commit "03ad7a0e7307e510b3b25a622d3c5f8a077879b4")
+ (revision "2"))
+ (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)
+ (url "https://github.com/takagi/cl-reexport";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-reexport" version))
(sha256
(base32
- "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
+ "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc"))))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("closer-mop" ,sbcl-closer-mop)))
+ (list sbcl-alexandria))
(native-inputs
- (list sbcl-eos))
- (arguments
- ;; XXX: Circular dependencies: tests depend on optima.ppcre which
depends on optima.
- `(#:tests? #f))
- (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))))
+ (list sbcl-prove))
+ (synopsis "Reexport external symbols in other Common Lisp packages")
+ (description
+ "Cl-reexport makes a package reexport symbols which are external
+symbols in other Common Lisp packages. This functionality is intended to be
+used with (virtual) hierarchical packages.")
+ (license license:llgpl))))
-(define-public cl-optima
- (sbcl-package->cl-source-package sbcl-optima))
+(define-public cl-reexport
+ (sbcl-package->cl-source-package sbcl-cl-reexport))
-(define-public ecl-optima
- (sbcl-package->ecl-package sbcl-optima))
+(define-public ecl-cl-reexport
+ (sbcl-package->ecl-package sbcl-cl-reexport))
-(define-public sbcl-fare-quasiquote
- (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
+(define-public sbcl-cl-rmath
+ (let ((commit "f6add1edda31547691d08e36ccf6c17305161aca")
(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";)
+ (name "sbcl-cl-rmath")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url (string-append "https://gitlab.common-lisp.net/frideau/";
- "fare-quasiquote.git"))
+ (url "https://github.com/tpapp/cl-rmath";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-rmath" version))
(sha256
- (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
- (inputs
- `(("fare-utils" ,sbcl-fare-utils)
- ("named-readtables" ,sbcl-named-readtables)
- ("optima" ,sbcl-optima)))
+ (base32 "1ld8vbpy10paymx2hn0mcgd21i7cjhdrayln1jx0kayqxm12mmk4"))))
+ (build-system asdf-build-system/sbcl)
(arguments
- ;; XXX: Circular dependencies: Tests depend on subsystems,
- ;; which depend on the main systems.
- `(#:tests? #f
- #:asd-systems '("fare-quasiquote"
- "fare-quasiquote-extras")
- #:phases
+ `(#: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\""))
- (substitute* "fare-quasiquote-optima.asd"
- (("\\(:version \"optima\" \"1\\.0\"\\)")
- "\"optima\""))
- #t)))))
- (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))))
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "cl-rmath.lisp"
+ (("\\(cffi:define-foreign-library librmath" all)
+ (string-append all "\n"
+ " (:unix \""
+ (assoc-ref inputs "librmath")
+ "/lib/libRmath.so\")"))))))))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("librmath" ,rmath-standalone)))
+ (home-page "https://github.com/tpapp/cl-rmath";)
+ (synopsis "Common Lisp wrapper for libRmath")
+ (description
+ "@code{cl-rmath} is a simple, autogenerated foreign interface for the
+standalone R API @code{libRmath}. There has been no effort to provide a
+high-level interface for the original library, instead, this library is meant
+to serve as a building block for such an interface.")
+ (license license:boost1.0))))
-(define-public cl-fare-quasiquote
- (sbcl-package->cl-source-package sbcl-fare-quasiquote))
+(define-public cl-rmath
+ (sbcl-package->cl-source-package sbcl-cl-rmath))
-(define-public ecl-fare-quasiquote
- (sbcl-package->ecl-package sbcl-fare-quasiquote))
+(define-public ecl-cl-rmath
+ (sbcl-package->ecl-package sbcl-cl-rmath))
-;;; Split the trivia package in two to work around the circular dependency
-;;; between guicho271828/trivia and guicho271828/type-i.
-(define-public sbcl-trivia.trivial
- (let ((commit "8b406c3f83521d290e97bb787d3f6c1eb3b716af")
- (revision "0"))
+(define-public sbcl-cl-slice
+ (let ((commit "c531683f287216aebbb0affbe090611fa1b5d697")
+ (revision "1"))
(package
- (name "sbcl-trivia.trivial")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-cl-slice")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/trivia";)
+ (url "https://github.com/tpapp/cl-slice";)
(commit commit)))
- (file-name (git-file-name "cl-trivia" version))
+ (file-name (git-file-name "cl-slice" version))
(sha256
- (base32
- "0fnnjnba07qrsf82jm4q6dini7z72xabcssy5y2bqy082r07l8l7"))))
+ (base32 "1ybznf4y5lda6bn163jcvj281qzhm24dfcwhbgxmm5n6f27gdccl"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-clunit))
(inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-lisp-namespace
- sbcl-trivial-cltl2))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (for-each delete-file
- '("trivia.balland2006.asd"
- "trivia.ppcre.asd"
- "trivia.quasiquote.asd"
- "trivia.cffi.asd"
- "trivia.fset.asd"
- "trivia.asd"
- "trivia.test.asd")))))))
- (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.")
- (home-page "https://github.com/guicho271828/trivia";)
- (license license:llgpl))))
+ (list sbcl-alexandria sbcl-anaphora sbcl-let-plus))
+ (home-page "https://github.com/tpapp/cl-slice";)
+ (synopsis "Array slices for Common Lisp")
+ (description
+ "This package provides a DSL for array slices in Common Lisp.")
+ (license license:expat))))
-(define-public cl-trivia.trivial
- (sbcl-package->cl-source-package sbcl-trivia.trivial))
+(define-public cl-slice
+ (sbcl-package->cl-source-package sbcl-cl-slice))
-(define-public ecl-trivia.trivial
- (sbcl-package->ecl-package sbcl-trivia.trivial))
-
-(define-public sbcl-trivia
- (package
- (inherit sbcl-trivia.trivial)
- (name "sbcl-trivia")
- (native-inputs
- (list sbcl-fiveam
- sbcl-optima))
- (inputs
- (list sbcl-alexandria
- sbcl-cffi
- sbcl-cl-ppcre
- sbcl-fare-quasiquote
- sbcl-fset
- sbcl-iterate
- sbcl-trivia.trivial
- sbcl-type-i))
- (arguments
- '(#:asd-systems '("trivia"
- "trivia.ppcre"
- "trivia.quasiquote"
- "trivia.cffi"
- "trivia.fset")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (for-each delete-file
- '("trivia.level0.asd"
- "trivia.level1.asd"
- "trivia.level2.asd"
- "trivia.trivial.asd")))))))))
-
-(define-public cl-trivia
- (sbcl-package->cl-source-package sbcl-trivia))
-
-(define-public ecl-trivia
- (sbcl-package->ecl-package sbcl-trivia))
-
-(define-public sbcl-mk-string-metrics
- (package
- (name "sbcl-mk-string-metrics")
- (version "0.1.2")
- (home-page "https://github.com/cbaggers/mk-string-metrics/";)
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit version)))
- (sha256
- (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Calculate various string metrics efficiently in Common Lisp")
- (description "This library implements efficient algorithms that calculate
-various string metrics in Common Lisp:
-
-@itemize
-@item Damerau-Levenshtein distance
-@item Hamming distance
-@item Jaccard similarity coefficient
-@item Jaro distance
-@item Jaro-Winkler distance
-@item Levenshtein distance
-@item Normalized Damerau-Levenshtein distance
-@item Normalized Levenshtein distance
-@item Overlap coefficient
-@end itemize\n")
- (license license:x11)))
-
-(define-public cl-mk-string-metrics
- (sbcl-package->cl-source-package sbcl-mk-string-metrics))
-
-(define-public ecl-mk-string-metrics
- (sbcl-package->ecl-package sbcl-mk-string-metrics))
-
-(define-public sbcl-cl-str
- (package
- (name "sbcl-cl-str")
- (version "0.19")
- (home-page "https://github.com/vindarel/cl-str";)
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit version)))
- (sha256
- (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839"))
- (file-name (git-file-name name version))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
- ("cl-change-case" ,sbcl-cl-change-case)))
- (native-inputs
- (list sbcl-prove))
- (arguments
- `(#:asd-systems '("str")))
- (synopsis "Modern, consistent and terse Common Lisp string manipulation
library")
- (description "A modern and consistent Common Lisp string manipulation
-library that focuses on modernity, simplicity and discoverability:
-@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
-@code{str:concat strings} instead of an unusual format construct; one
-discoverable library instead of many; consistency and composability, where
-@code{s} is always the last argument, which makes it easier to feed pipes and
-arrows.")
- (license license:expat)))
-
-(define-public cl-str
- (sbcl-package->cl-source-package sbcl-cl-str))
-
-(define-public ecl-cl-str
- (sbcl-package->ecl-package sbcl-cl-str))
+(define-public ecl-cl-slice
+ (sbcl-package->ecl-package sbcl-cl-slice))
-(define-public sbcl-cl-xmlspam
- (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
+(define-public sbcl-cl-slug
+ (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749")
+ (revision "1"))
(package
- (name "sbcl-cl-xmlspam")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.0.0" "1" commit))
- (home-page "https://github.com/rogpeppe/cl-xmlspam";)
+ (name "sbcl-cl-slug")
+ (version (git-version "0.4.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/EuAndreh/cl-slug";)
(commit commit)))
- (file-name (string-append name "-" version))
+ (file-name (git-file-name "cl-slug" version))
(sha256
- (base32
- "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
+ (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove))
(inputs
- (list sbcl-cxml sbcl-cl-ppcre))
- (synopsis "Concise, regexp-like pattern matching on streaming XML for
Common Lisp")
- (description "CXML does an excellent job at parsing XML elements, but
what
-do you do when you have a XML file that's larger than you want to fit in
-memory, and you want to extract some information from it? Writing code to deal
-with SAX events, or even using Klacks, quickly becomes tedious.
-@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
-to write code that mirrors the structure of the XML that it's parsing. It
-also makes it easy to shift paradigms when necessary - the usual Lisp control
-constructs can be used interchangeably with pattern matching, and the full
-power of CXML is available when necessary.")
- (license license:bsd-3))))
+ `(("ppcre" ,sbcl-cl-ppcre)))
+ (home-page "https://github.com/EuAndreh/cl-slug";)
+ (synopsis "Multi-language slug formatter")
+ (description
+ "This is a small Common Lisp library to make slugs, mainly for URIs,
+from English and beyond.")
+ (license license:llgpl))))
-(define-public cl-xmlspam
- (sbcl-package->cl-source-package sbcl-cl-xmlspam))
+(define-public cl-slug
+ (sbcl-package->cl-source-package sbcl-cl-slug))
-(define-public ecl-cl-xmlspam
- (sbcl-package->ecl-package sbcl-cl-xmlspam))
+(define-public ecl-cl-slug
+ (sbcl-package->ecl-package sbcl-cl-slug))
-(define-public sbcl-dbus
- (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
- (revision "1"))
+(define-public sbcl-cl-smtp
+ (let ((commit "ed47d326fad867ee11323fa3a0f307b5d40e8f2b")
+ (revision "0"))
(package
- (name "sbcl-dbus")
- (version (git-version "20190408" revision commit))
- (home-page "https://github.com/death/dbus";)
+ (name "sbcl-cl-smtp")
+ (version (git-version "20191031.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-smtp" version))
(sha256
- (base32
- "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
+ (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-trivial-garbage
- sbcl-babel
- sbcl-iolib
- sbcl-ieee-floats
+ (list sbcl-cl+ssl
+ sbcl-cl-base64
sbcl-flexi-streams
- sbcl-cl-xmlspam
- sbcl-ironclad))
- (synopsis "D-Bus client library for Common Lisp")
- (description "This is a Common Lisp library that publishes D-Bus
-objects as well as send and notify other objects connected to a bus.")
- (license license:bsd-2))))
+ sbcl-trivial-gray-streams
+ sbcl-usocket))
+ (home-page "https://gitlab.common-lisp.net/cl-smtp/cl-smtp";)
+ (synopsis "Simple Common Lisp SMTP client")
+ (description "This package provides a client for SMTP.")
+ (license license:llgpl))))
-(define-public cl-dbus
- (sbcl-package->cl-source-package sbcl-dbus))
+(define-public cl-smtp
+ (sbcl-package->cl-source-package sbcl-cl-smtp))
-(define-public ecl-dbus
- (sbcl-package->ecl-package sbcl-dbus))
+(define-public ecl-cl-smtp
+ (sbcl-package->ecl-package sbcl-cl-smtp))
-(define-public sbcl-cl-hooks
- (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
+(define-public sbcl-cl-spark
+ (let ((commit "4e34bcebdcf8e45265986eb43ad4ad03bb41a581")
(revision "1"))
(package
- (name "sbcl-cl-hooks")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.2.1" revision commit))
- (home-page "https://github.com/scymtym/architecture.hooks";)
+ (name "sbcl-cl-spark")
+ (version (git-version "0.1.13" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/tkych/cl-spark";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-spark" version))
(sha256
- (base32
- "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
- (inputs
- (list sbcl-alexandria sbcl-let-plus sbcl-trivial-garbage
- sbcl-closer-mop))
+ (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
- (synopsis "Hooks extension point mechanism (as in Emacs) for Common
Lisp")
- (description "A hook, in the present context, is a certain kind of
-extension point in a program that allows interleaving the execution of
-arbitrary code with the execution of a the program without introducing any
-coupling between the two. Hooks are used extensively in the extensible editor
-Emacs.
+ (synopsis "Common Lisp library to make histograms")
+ (description "This is a Common Lisp library to make histograms using
+UTF-8 block characters.")
+ (home-page "https://github.com/tkych/cl-spark";)
+ (license license:expat))))
-In the Common LISP Object System (CLOS), a similar kind of extensibility is
-possible using the flexible multi-method dispatch mechanism. It may even seem
-that the concept of hooks does not provide any benefits over the possibilities
-of CLOS. However, there are some differences:
+(define-public cl-spark
+ (sbcl-package->cl-source-package sbcl-cl-spark))
-@itemize
+(define-public ecl-cl-spark
+ (sbcl-package->ecl-package sbcl-cl-spark))
-@item There can be only one method for each combination of specializers and
-qualifiers. As a result this kind of extension point cannot be used by
-multiple extensions independently.
-@item Removing code previously attached via a @code{:before}, @code{:after} or
-@code{:around} method can be cumbersome.
-@item There could be other or even multiple extension points besides
@code{:before}
-and @code{:after} in a single method.
-@item Attaching codes to individual objects using eql specializers can be
-cumbersome.
-@item Introspection of code attached a particular extension point is
-cumbersome since this requires enumerating and inspecting the methods of a
-generic function.
-@end itemize
+(define-public sbcl-cl-speedy-queue
+ (let ((commit "0425c7c62ad3b898a5ec58cd1b3e74f7d91eec4b")
+ (revision "1"))
+ (package
+ (name "sbcl-cl-speedy-queue")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/zkat/cl-speedy-queue";)
+ (commit commit)))
+ (file-name (git-file-name "cl-speedy-queue" version))
+ (sha256
+ (base32 "0czhnvxn9lvbjz9h1lb7y18nqrsq3drq5icd3lqdaa07362alriq"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/zkat/cl-speedy-queue";)
+ (synopsis "Lightweight optimized queue for Common Lisp")
+ (description
+ "This is a lightweight, non-consing, optimized queue implementation for
+Common Lisp.")
+ (license license:expat))))
-This library tries to complement some of these weaknesses of method-based
-extension-points via the concept of hooks.")
- (license license:llgpl))))
+(define-public cl-speedy-queue
+ (sbcl-package->cl-source-package sbcl-cl-speedy-queue))
-(define-public cl-hooks
- (sbcl-package->cl-source-package sbcl-cl-hooks))
+(define-public ecl-cl-speedy-queue
+ (sbcl-package->ecl-package sbcl-cl-speedy-queue))
-(define-public ecl-cl-hooks
- (sbcl-package->ecl-package sbcl-cl-hooks))
+(define-public sbcl-cl-sqlite
+ (package
+ (name "sbcl-cl-sqlite")
+ (version "0.2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dmitryvk/cl-sqlite";)
+ (commit version)))
+ (file-name (git-file-name "cl-sqlite" version))
+ (sha256
+ (base32
+ "08iv7b4m0hh7qx2cvq4f510nrgdld0vicnvmqsh9w0fgrcgmyg4k"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("iterate" ,sbcl-iterate)
+ ("cffi" ,sbcl-cffi)
+ ("sqlite" ,sqlite)))
+ (native-inputs
+ `(("fiveam" ,sbcl-fiveam)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ `(#:asd-systems '("sqlite")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "sqlite-ffi.lisp"
+ (("libsqlite3" all) (string-append
+ (assoc-ref inputs "sqlite")"/lib/"
all))))))))
+ (home-page "https://common-lisp.net/project/cl-sqlite/";)
+ (synopsis "Common Lisp binding for SQLite")
+ (description
+ "The @command{cl-sqlite} package is an interface to the SQLite embedded
+relational database engine.")
+ (license license:public-domain)))
-(define-public sbcl-cl-autowrap
- (let ((revision "2")
- (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4"))
- ;; no taged branches
+(define-public cl-sqlite
+ (sbcl-package->cl-source-package sbcl-cl-sqlite))
+
+(define-public ecl-cl-sqlite
+ (sbcl-package->ecl-package sbcl-cl-sqlite))
+
+(define-public sbcl-cl+ssl
+ (let ((commit "17d5cdd65405f1d26e26f3e875e70027d0c8eedb")
+ (revision "6"))
(package
- (name "sbcl-cl-autowrap")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cl+ssl")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/cl-autowrap";)
+ (url "https://github.com/cl-plus-ssl/cl-plus-ssl";)
(commit commit)))
- (file-name (git-file-name "cl-autowrap" version))
+ (file-name (git-file-name "cl+ssl" version))
(sha256
- (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw"))))
+ (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("cl-plus-c" "cl-autowrap")))
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/reload.lisp"
+ (("libssl.so" all)
+ (string-append
+ (assoc-ref inputs "openssl") "/lib/" all))
+ (("libcrypto.so" all)
+ (string-append
+ (assoc-ref inputs "openssl") "/lib/" all)))))
+ (add-after 'fix-paths 'fix-tests
+ (lambda _
+ ;; Disable coverall support in tests because of a circular
+ ;; dependency: cl+ssl -> cl-coverall -> dexador
+ ;; -> clack -> hunchentoot -> cl+ssl
+ (substitute* "cl+ssl.test.asd"
+ (("\\(:feature \\(:or :sbcl :ccl\\) :cl-coveralls\\)")
+ "")))))))
+ (native-inputs
+ (list ;sbcl-cl-coveralls
+ sbcl-fiveam
+ sbcl-trivial-sockets))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-json" ,sbcl-cl-json)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("defpackage-plus" ,sbcl-defpackage-plus)
- ("trivial-features" ,sbcl-trivial-features)))
- (home-page "https://github.com/rpav/cl-autowrap";)
- (synopsis "FFI wrapper generator for Common Lisp")
- (description "This is a c2ffi-based wrapper generator for Common Lisp.")
- (license license:bsd-2))))
+ (list openssl
+ sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-flexi-streams
+ sbcl-trivial-features
+ sbcl-trivial-garbage
+ sbcl-trivial-gray-streams
+ sbcl-usocket))
+ (home-page "https://common-lisp.net/project/cl-plus-ssl/";)
+ (synopsis "Common Lisp bindings to OpenSSL")
+ (description
+ "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
+code was written by Eric Marsden and includes contributions by Jochen Schmidt.
+Development into CL+SSL was done by David Lichteblau.")
+ (license license:expat))))
-(define-public cl-autowrap
- (sbcl-package->cl-source-package sbcl-cl-autowrap))
+(define-public cl-cl+ssl
+ (sbcl-package->cl-source-package sbcl-cl+ssl))
-(define-public ecl-cl-autowrap
- (sbcl-package->ecl-package sbcl-cl-autowrap))
+(define-public ecl-cl+ssl
+ ;; The trivial-sockets system used for the tests doesn't support ECL, so we
+ ;; remove it from native-inputs and disable the tests.
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl+ssl)))
+ (package
+ (inherit pkg)
+ (native-inputs
+ (modify-inputs (package-native-inputs pkg)
+ (delete "sbcl-trivial-sockets")))
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:tests? _ #f) #f))))))
-(define-public sbcl-s-sysdeps
- ;; No release since 2013.
- (let ((commit "7f8de283b7fbd8b038fdf08493063a736db36ce7")
- (revision "3"))
+(define-public sbcl-cl-steamworks
+ (let ((commit "9d6a4de653a8cc256ae35e0298912b518aa92ba3")
+ (revision "1"))
(package
- (name "sbcl-s-sysdeps")
- (build-system asdf-build-system/sbcl)
- (version (git-version "1" revision commit))
- (home-page "https://github.com/svenvc/s-sysdeps";)
+ (name "sbcl-cl-steamworks")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/Shinmera/cl-steamworks/";)
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32
- "0rp81iq0rgl48qdwbmfy89glga81hmry2lp8adjbr5h5ybr92b4n"))))
+ (base32 "1fzj3rlqw1kwdlmh0ga0y71p2n1adflcamzx4yp9kga552c1db5j"))
+ (file-name (git-file-name "cl-steamworks" version))))
+ (build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-bordeaux-threads sbcl-usocket))
- (synopsis "Common Lisp abstraction layer over platform dependent
functionality")
- (description "@code{s-sysdeps} is an abstraction layer over platform
-dependent functionality. This simple package is used as a building block in a
-number of other projects.
-
-@code{s-sysdeps} abstracts:
-
-@itemize
-@item managing processes,
-@item implementing a standard TCP/IP server,
-@item opening a client TCP/IP socket stream,
-@item working with process locks.
-@end itemize\n")
- (license license:llgpl))))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-float-features
+ sbcl-trivial-features
+ sbcl-trivial-garbage
+ sbcl-trivial-gray-streams))
+ (synopsis "Wrapper for the Valve SteamWorks API")
+ (description "This is a wrapper library to allow you to interface with
+the Valve SteamWorks API.")
+ (home-page "https://shinmera.github.io/cl-steamworks/";)
+ (license license:zlib))))
-(define-public cl-s-sysdeps
- (sbcl-package->cl-source-package sbcl-s-sysdeps))
+(define-public cl-steamworks
+ (sbcl-package->cl-source-package sbcl-cl-steamworks))
-(define-public ecl-s-sysdeps
- (sbcl-package->ecl-package sbcl-s-sysdeps))
+(define-public ecl-cl-steamworks
+ (sbcl-package->ecl-package sbcl-cl-steamworks))
-(define-public sbcl-cl-prevalence
- (let ((commit "e6b27640ce89ae5f8af38beb740e319bb6cd2368")
- (revision "6"))
+(define-public sbcl-cl-store
+ (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
+ (revision "1"))
(package
- (name "sbcl-cl-prevalence")
- (build-system asdf-build-system/sbcl)
- (version (git-version "5" revision commit))
- (home-page "https://github.com/40ants/cl-prevalence";)
+ (name "sbcl-cl-store")
+ (version (git-version "0.8.11" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/skypher/cl-store";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0"))))
- (inputs
- (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml))
+ "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam sbcl-find-port))
- (synopsis "Implementation of object prevalence for Common Lisp")
- (description "This Common Lisp library implements object prevalence (see
-@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
-for (de)serializing to and from s-exps as well as XML. Serialization of
arbitrary
-classes and cyclic data structures are supported.")
- (license license:llgpl))))
-
-(define-public cl-prevalence
- (sbcl-package->cl-source-package sbcl-cl-prevalence))
-
-(define-public ecl-cl-prevalence
- (sbcl-package->ecl-package sbcl-cl-prevalence))
+ (list sbcl-rt))
+ (synopsis "Common Lisp library to serialize data")
+ (description
+ "CL-STORE is a portable serialization package which should give you the
+ability to store all Common Lisp data types into streams.")
+ (home-page "https://www.common-lisp.net/project/cl-store/";)
+ (license license:expat))))
-(define-public sbcl-series
- (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
- (revision "1"))
+(define-public cl-store
+ (sbcl-package->cl-source-package sbcl-cl-store))
+
+(define-public ecl-cl-store
+ (sbcl-package->ecl-package sbcl-cl-store))
+
+(define-public sbcl-cl-str
+ (package
+ (name "sbcl-cl-str")
+ (version "0.19")
+ (home-page "https://github.com/vindarel/cl-str";)
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (sha256
+ (base32 "1jyza2jhn7w6fl4w87pv0m87z5ia48m6dqw12k0mdh7l3mgjq839"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-ppcre-unicode" ,sbcl-cl-ppcre-unicode)
+ ("cl-change-case" ,sbcl-cl-change-case)))
+ (native-inputs
+ (list sbcl-prove))
+ (arguments
+ `(#:asd-systems '("str")))
+ (synopsis "Modern, consistent and terse Common Lisp string manipulation
library")
+ (description "A modern and consistent Common Lisp string manipulation
+library that focuses on modernity, simplicity and discoverability:
+@code{(str:trim s)} instead of @code{(string-trim '(#\\Space ...) s)}), or
+@code{str:concat strings} instead of an unusual format construct; one
+discoverable library instead of many; consistency and composability, where
+@code{s} is always the last argument, which makes it easier to feed pipes and
+arrows.")
+ (license license:expat)))
+
+(define-public cl-str
+ (sbcl-package->cl-source-package sbcl-cl-str))
+
+(define-public ecl-cl-str
+ (sbcl-package->ecl-package sbcl-cl-str))
+
+(define-public sbcl-cl-strftime
+ ;; No release.
+ (let ((commit "21cb57f2595faa26d687893963f24ec41822b63c"))
(package
- (name "sbcl-series")
- (version (git-version "2.2.11" revision commit))
+ (name "sbcl-cl-strftime")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "git://git.code.sf.net/p/series/series")
+ (url "https://github.com/ruricolist/cl-strftime/";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
+ (base32 "00c8hq7vzgb89ab3q7mrp60x743kiqmsk1g51ynhxlqhph2bnslf"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; Disable the tests, they are apparently buggy and I didn't find
- ;; a simple way to make them run and pass.
- '(#:tests? #f))
- (synopsis "Series data structure for Common Lisp")
+ (inputs
+ (list sbcl-alexandria sbcl-local-time sbcl-cl-ppcre sbcl-serapeum))
+ (native-inputs
+ (list sbcl-fiveam sbcl-cffi))
+ (home-page "https://github.com/ruricolist/cl-strftime";)
+ (synopsis "Common Lisp compiler for the strftime language")
(description
- "This Common Lisp library provides a series data structure much like
-a sequence, with similar kinds of operations. The difference is that in many
-situations, operations on series may be composed functionally and yet execute
-iteratively, without the need to construct intermediate series values
-explicitly. In this manner, series provide both the clarity of a functional
-programming style and the efficiency of an iterative programming style.")
- (home-page "https://series.sourceforge.net/";)
+ "CL-STRFTIME is a Common Lisp compiler for the strftime “language.”")
(license license:expat))))
-(define-public cl-series
- (sbcl-package->cl-source-package sbcl-series))
+(define-public cl-strftime
+ (sbcl-package->cl-source-package sbcl-cl-strftime))
-(define-public ecl-series
- (sbcl-package->ecl-package sbcl-series))
+(define-public ecl-cl-strftime
+ (sbcl-package->ecl-package sbcl-cl-strftime))
-(define-public sbcl-periods
- (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949")
- (revision "2"))
+(define-public sbcl-cl-string-match
+ (let ((revision "1")
+ (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
(package
- (name "sbcl-periods")
- (version (git-version "0.0.2" revision commit))
+ (name "sbcl-cl-string-match")
+ (version (git-version "0" revision changeset))
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jwiegley/periods";)
- (commit commit)))
- (file-name (git-file-name name version))
+ (method hg-fetch)
+ (uri (hg-reference
+ (url "https://github.com/vityok/cl-string-match";)
+ (changeset changeset)))
(sha256
(base32
- "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk"))))
+ "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
+ (file-name (git-file-name "cl-string-match" version))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("local-time" ,sbcl-local-time)
- ("series" ,sbcl-series)))
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)
+ ("iterate" ,sbcl-iterate)
+ ("jpl-queues" ,sbcl-jpl-queues)
+ ("jpl-util" ,sbcl-jpl-util)
+ ("mgl-pax" ,sbcl-mgl-pax)
+ ("parse-float" ,sbcl-parse-float)
+ ("proc-parse" ,sbcl-proc-parse)
+ ("yacc" ,sbcl-cl-yacc)))
+ ;; TODO: Tests are not evaluated properly.
+ (native-inputs
+ ;; For testing:
+ (list sbcl-lisp-unit))
(arguments
- '(#:asd-systems '("periods"
- "periods-series")))
- (synopsis "Common Lisp library for manipulating date/time objects")
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-dependency
+ (lambda _
+ (substitute* "cl-string-match.asd"
+ ((":mgl-pax")
+ ":mgl-pax/document")))))))
+ (synopsis "Set of utilities to manipulate strings in Common Lisp")
(description
- "Periods is a Common Lisp library providing a set of utilities for
-manipulating times, distances between times, and both contiguous and
-discontiguous ranges of time.")
- (home-page "https://github.com/jwiegley/periods";)
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
+ (home-page "https://github.com/vityok/cl-string-match";)
(license license:bsd-3))))
-(define-public cl-periods
- (sbcl-package->cl-source-package sbcl-periods))
+(define-public cl-string-match
+ (sbcl-package->cl-source-package sbcl-cl-string-match))
-(define-public ecl-periods
- (sbcl-package->ecl-package sbcl-periods))
+(define-public ecl-cl-string-match
+ (sbcl-package->ecl-package sbcl-cl-string-match))
-(define-public sbcl-metatilities-base
- (let ((commit "ef04337759972fd622c9b27b53149f3d594a841f")
- (revision "2"))
+(define-public sbcl-cl-strings
+ (let ((revision "1")
+ (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140"))
(package
- (name "sbcl-metatilities-base")
- (version (git-version "0.6.6" revision commit))
+ (name "sbcl-cl-strings")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/metatilities-base";)
+ (url "https://github.com/diogoalexandrefranco/cl-strings";)
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32
- "069rk5ncwvjnnzvvky6xiriynl72yzvjpnzl6jw9jf3b8na14zrk"))))
+ (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj"))
+ (file-name (git-file-name "cl-strings" version))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lift))
- (synopsis "Core of the metatilities Common Lisp library")
+ (synopsis "Set of utilities to manipulate strings in Common Lisp")
(description
- "Metatilities-base is the core of the metatilities Common Lisp library
-which implements a set of utilities.")
- (home-page "https://common-lisp.net/project/metatilities-base/";)
+ "@command{cl-strings} is a small, portable, dependency-free set of
+utilities that make it even easier to manipulate text in Common Lisp. It has
+100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
+ (home-page "https://github.com/diogoalexandrefranco/cl-strings";)
(license license:expat))))
-(define-public cl-metatilities-base
- (sbcl-package->cl-source-package sbcl-metatilities-base))
+(define-public cl-strings
+ (sbcl-package->cl-source-package sbcl-cl-strings))
-(define-public ecl-metatilities-base
- (sbcl-package->ecl-package sbcl-metatilities-base))
+(define-public ecl-cl-strings
+ (sbcl-package->ecl-package sbcl-cl-strings))
-(define-public sbcl-cl-containers
- (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f")
- (revision "4"))
+(define-public sbcl-cl-svg
+ (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc")
+ (revision "1"))
(package
- (name "sbcl-cl-containers")
- (version (git-version "0.12.1" revision commit))
+ (name "sbcl-cl-svg")
+ (version (git-version "0.0.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/cl-containers";)
+ (url "https://github.com/wmannis/cl-svg";)
(commit commit)))
- (file-name (git-file-name "cl-containers" version))
+ (file-name (git-file-name "cl-svg" version))
(sha256
- (base32
- "1nrql8s1j123v5gscy99lxvhlzp0ijig9x94w30v3lwfa58hf90l"))))
+ (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lift))
- (inputs
- (list sbcl-asdf-system-connections
- sbcl-metatilities-base
- sbcl-moptilities))
- (arguments
- '(#:asd-systems '("cl-containers"
- "cl-containers/with-moptilities"
- "cl-containers/with-utilities")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'relax-version-checks
- (lambda _
- (substitute* "cl-containers.asd"
- (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
- "\"metatilities-base\""))
- (substitute* "cl-containers-test.asd"
- (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
- "\"lift\""))
- #t)))))
- (synopsis "Container library for Common Lisp")
+ (home-page "https://github.com/wmannis/cl-svg";)
+ (synopsis "Write SVG file format")
(description
- "Common Lisp ships with a set of powerful built in data structures
-including the venerable list, full featured arrays, and hash-tables.
-CL-containers enhances and builds on these structures by adding containers
-that are not available in native Lisp (for example: binary search trees,
-red-black trees, sparse arrays and so on), and by providing a standard
-interface so that they are simpler to use and so that changing design
-decisions becomes significantly easier.")
- (home-page "https://common-lisp.net/project/cl-containers/";)
+ "This package provides the @code{CL-SVG} Common Lisp system to produce
+Scalable Vector Graphics files.")
(license license:expat))))
-(define-public cl-containers
- (sbcl-package->cl-source-package sbcl-cl-containers))
+(define-public cl-svg
+ (sbcl-package->cl-source-package sbcl-cl-svg))
-(define-public ecl-cl-containers
- (sbcl-package->ecl-package sbcl-cl-containers))
+(define-public ecl-cl-svg
+ (sbcl-package->ecl-package sbcl-cl-svg))
-(define-public sbcl-cambl
- (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
- (revision "1"))
+(define-public sbcl-cl-sxml
+ (let ((commit "e5542b1d9bd6cee03ae27547d00660ccfbb60109")
+ (revision "1"))
(package
- (name "sbcl-cambl")
- (version (git-version "4.0.0" revision commit))
+ (name "sbcl-cl-sxml")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jwiegley/cambl";)
+ (url "https://github.com/eadmund/cl-sxml";)
(commit commit)))
- (file-name (git-file-name "cambl" version))
+ (file-name (git-file-name "cl-sxml" version))
(sha256
- (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
+ (base32 "1105s9whidq1lf0lli2wdhcfcs5gwzxa0h1x3izx4mp2p7psvciz"))))
(build-system asdf-build-system/sbcl)
+ (inputs (list sbcl-cxml))
(native-inputs
- (list sbcl-xlunit))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-containers" ,sbcl-cl-containers)
- ("local-time" ,sbcl-local-time)
- ("periods" ,sbcl-periods)))
- (synopsis "Commoditized amounts and balances for Common Lisp")
+ (list sbcl-fiveam
+ sbcl-flexi-streams))
+ (home-page "https://github.com/eadmund/cl-sxml";)
+ (synopsis "SXML parsing for Common Lisp")
(description
- "CAMBL is a Common Lisp library providing a convenient facility for
-working with commoditized values. It does not allow compound units (and so is
-not suited for scientific operations) but does work rather nicely for the
-purpose of financial calculations.")
- (home-page "https://github.com/jwiegley/cambl";)
- (license license:bsd-3))))
+ "@code{CL-SXML} implements Oleg Kiselyov’s SXML, an S-expression-based
+rendering of the XML Infoset.")
+ (license license:gpl3+))))
-(define-public cl-cambl
- (sbcl-package->cl-source-package sbcl-cambl))
+(define-public cl-sxml
+ (sbcl-package->cl-source-package sbcl-cl-sxml))
-(define-public ecl-cambl
- (sbcl-package->ecl-package sbcl-cambl))
+(define-public ecl-cl-sxml
+ (sbcl-package->ecl-package sbcl-cl-sxml))
-(define-public sbcl-cl-ledger
- (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
- (revision "1"))
+(define-public sbcl-cl-syntax
+ (package
+ (name "sbcl-cl-syntax")
+ (version "0.0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/m2ym/cl-syntax";)
+ (commit "03f0c329bbd55b8622c37161e6278366525e2ccc")))
+ (file-name (git-file-name "cl-syntax" version))
+ (sha256
+ (base32 "17ran8xp77asagl31xv8w819wafh6whwfc9p6dgx22ca537gyl4y"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-annot" ,sbcl-cl-annot)
+ ("cl-interpol" ,sbcl-cl-interpol)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("trivial-types" ,sbcl-trivial-types)))
+ (arguments
+ '(#:asd-systems '("cl-syntax"
+ "cl-syntax-annot"
+ "cl-syntax-interpol")))
+ (home-page "https://github.com/m2ym/cl-syntax";)
+ (synopsis "Reader Syntax Coventions for Common Lisp and SLIME")
+ (description
+ "CL-SYNTAX provides Reader Syntax Coventions for Common Lisp and SLIME.")
+ (license license:llgpl)))
+
+(define-public cl-syntax
+ (sbcl-package->cl-source-package sbcl-cl-syntax))
+
+(define-public ecl-cl-syntax
+ (sbcl-package->ecl-package sbcl-cl-syntax))
+
+(define-public sbcl-cl-syslog
+ (let ((commit "d5d46f777f0735938e6f650cf17d814b88b70305")
+ (revision "0"))
(package
- (name "sbcl-cl-ledger")
- (version (git-version "4.0.0" revision commit))
+ (name "sbcl-cl-syslog")
+ (version (git-version "0.2.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ledger/cl-ledger";)
+ (url "https://github.com/mmaul/cl-syslog";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-syslog" version))
(sha256
- (base32
- "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
+ (base32 "1qcz55jiqwk91b01hsahxnha884f6zf2883j2m51sqph0mvj69mh"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("cambl" ,sbcl-cambl)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)
- ("periods" ,sbcl-periods)))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cffi
+ sbcl-global-vars
+ sbcl-local-time
+ sbcl-split-sequence
+ sbcl-usocket))
(arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-system-definition
- (lambda _
- (substitute* "cl-ledger.asd"
- ((" :build-operation program-op") "")
- ((" :build-pathname \"cl-ledger\"") "")
- ((" :entry-point \"ledger::main\"") ""))
- #t)))))
- (synopsis "Common Lisp port of the Ledger accounting system")
- (description
- "CL-Ledger is a Common Lisp port of the Ledger double-entry accounting
-system.")
- (home-page "https://github.com/ledger/cl-ledger";)
+ (list #:tests? #f))
+ (synopsis "Common Lisp interface to local and remote Syslog facilities")
+ (description "@code{cl-syslog} is a Common Lisp library that provides
+access to the syslog logging facility.")
+ (home-page "https://cl-syslog.common-lisp.dev/";)
(license license:bsd-3))))
-(define-public cl-ledger
- (sbcl-package->cl-source-package sbcl-cl-ledger))
+(define-public cl-syslog
+ (sbcl-package->cl-source-package sbcl-cl-syslog))
-(define-public ecl-cl-ledger
- (sbcl-package->ecl-package sbcl-cl-ledger))
+(define-public ecl-cl-syslog
+ (sbcl-package->ecl-package sbcl-cl-syslog))
-(define-public sbcl-bst
- (let ((commit "8545aed0d504df2829ad139566feeabe22305388")
+(define-public sbcl-cl-template
+ (let ((commit "46193a9a389bb950530e579eae7e6e5a18184832")
(revision "0"))
(package
- (name "sbcl-bst")
- (version (git-version "2.0" revision commit))
+ (name "sbcl-cl-template")
+ (version (git-version "0.0.1" revision commit))
+ (home-page "https://github.com/alpha123/cl-template";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alpha123/cl-template";)
+ (commit commit)))
+ (file-name (git-file-name "cl-template" version))
+ (sha256
+ (base32 "1rhg023a2nxsk5x6abd6i0a8sh36aj0bgsh80w60m3b7xlsva2x2"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "Template engine for Common Lisp")
+ (description "@code{cl-template} is a template engine for Common Lisp,
+taking inspiration from Ruby's ERb module.")
+ (license license:expat))))
+
+(define-public cl-template
+ (sbcl-package->cl-source-package sbcl-cl-template))
+
+(define-public ecl-cl-template
+ (sbcl-package->ecl-package sbcl-cl-template))
+
+(define-public sbcl-cl-tga
+ (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
+ (revision "0"))
+ (package
+ (name "sbcl-cl-tga")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/bst";)
+ (url "https://github.com/fisxoj/cl-tga";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8"))))
+ (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria sbcl-fiveam))
- (synopsis "Binary search tree for Common Lisp")
+ (home-page "https://github.com/fisxoj/cl-tga";)
+ (synopsis "TGA file loader for Common Lisp")
(description
- "BST is a Common Lisp library for working with binary search trees that
-can contain any kind of values.")
- (home-page "https://codeberg.org/glv/bst";)
- (license license:gpl3))))
+ "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL
+programs. It's a very simple library, and, at the moment, only supports
+non-RLE encoded forms of the files.")
+ (license license:expat))))
-(define-public cl-bst
- (sbcl-package->cl-source-package sbcl-bst))
+(define-public cl-tga
+ (sbcl-package->cl-source-package sbcl-cl-tga))
-(define-public ecl-bst
- (sbcl-package->ecl-package sbcl-bst))
+(define-public ecl-cl-tga
+ (sbcl-package->ecl-package sbcl-cl-tga))
-(define-public sbcl-trivial-octet-streams
- (let ((commit "bc5d398b18549fd42e9c2a365df28ad865f1b85d")
- (revision "0"))
+(define-public sbcl-cl-tld
+ ;; No release.
+ (let ((commit "f5014da8d831fa9481d4181d4450f10a52850c75"))
(package
- (name "sbcl-trivial-octet-streams")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-cl-tld")
+ (version (git-version "0.1" "2" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/trivial-octet-streams";)
+ (url "https://github.com/lu4nx/cl-tld";)
(commit commit)))
- (file-name (git-file-name "cl-trivial-octet-streams" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0ysnsarlzynb7jf4b63b6kkxjancxc66jwmn0sb3vxyh87siiv6n"))))
+ (base32 "0sxnn35gzdby1ixil6zbjg72vli9fcspwzsqimqk455310syx9iv"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/sharplispers/trivial-octet-streams";)
- (synopsis "In-memory octet streams for Common Lisp")
+ (home-page "https://github.com/lu4nx/cl-tld/";)
+ (synopsis "Extract the Top Level Domain from domains, in Common Lisp")
(description
- "TRIVIAL-OCTET-STREAMS is a Common Lisp library implementing in-memory
-octet streams analogous to string streams.")
- (license license:bsd-3))))
-
-(define-public cl-trivial-octet-streams
- (sbcl-package->cl-source-package sbcl-trivial-octet-streams))
+ "This library extracts the TLD (Top Level Domain) from domains. The
+information is taken from @url{https://publicsuffix.org}.";)
+ (license license:public-domain))))
-(define-public ecl-trivial-octet-streams
- (sbcl-package->ecl-package sbcl-trivial-octet-streams))
+(define-public cl-tld
+ (sbcl-package->cl-source-package sbcl-cl-tld))
-(define-public sbcl-cl-octet-streams
- (package
- (name "sbcl-cl-octet-streams")
- (version "1.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://codeberg.org/glv/cl-octet-streams";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-trivial-gray-streams))
- (synopsis "In-memory octet streams for Common Lisp")
- (description
- "CL-octet-streams is a library implementing in-memory octet
-streams for Common Lisp. It was inspired by the trivial-octet-streams and
-cl-plumbing libraries.")
- (home-page "https://codeberg.org/glv/cl-octet-streams";)
- (license license:gpl3+)))
+(define-public ecl-cl-tld
+ (sbcl-package->ecl-package sbcl-cl-tld))
-(define-public cl-octet-streams
- (sbcl-package->cl-source-package sbcl-cl-octet-streams))
-
-(define-public ecl-cl-octet-streams
- (sbcl-package->ecl-package sbcl-cl-octet-streams))
-
-(define-public sbcl-in-memory-streams
- (let ((commit "bb4ce9c8c08479c9904f5d29f2b6187f264dc620")
- (revision "1"))
+(define-public sbcl-cl-tls
+ (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba")
+ (revision "0"))
(package
- (name "sbcl-in-memory-streams")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cl-tls")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/cl-in-memory-streams";)
+ (url "https://github.com/shrdlu68/cl-tls";)
(commit commit)))
- (file-name (git-file-name "cl-in-memory-streams" version))
+ (file-name (git-file-name "cl-tls" version))
(sha256
- (base32 "1fls1jnkf86wimip6f95y496sc4rxpsh2y65lgqsqpi0yda5xl2f"))))
+ (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-trivial-gray-streams))
- (synopsis "In-memory streams for any element type")
- (description
- "This Common Lisp library provides an implementation of in-memory input
-streams, output streams and io streams for any type of elements.")
- (home-page "https://codeberg.org/glv/cl-in-memory-streams";)
- (license license:gpl3+))))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cl-base64
+ sbcl-fast-io
+ sbcl-ironclad))
+ (home-page "https://github.com/shrdlu68/cl-tls";)
+ (synopsis "Implementation of Transport Layer Security Protocols")
+ (description "This package provides prototype Common Lisp
+implementations of TLS, RFC5246, ASN.1, x{501,509}, and PKCS{1,3,5,8}.")
+ (license license:bsd-3))))
-(define-public cl-in-memory-streams
- (sbcl-package->cl-source-package sbcl-in-memory-streams))
+(define-public cl-tls
+ (sbcl-package->cl-source-package sbcl-cl-tls))
-(define-public ecl-in-memory-streams
- (sbcl-package->ecl-package sbcl-in-memory-streams))
+(define-public ecl-cl-tls
+ (sbcl-package->ecl-package sbcl-cl-tls))
-(define-public sbcl-lzlib
- (let ((commit "22767ca12d1c1bd59a7ae1f9c5ef7d2e937206bb")
- (revision "2"))
+(define-public sbcl-cl-typesetting
+ (let ((commit "86eba981fc4254addebecf765578ec350d6e3b75")
+ (revision "1"))
(package
- (name "sbcl-lzlib")
- (version (git-version "2.0" revision commit))
+ (name "sbcl-cl-typesetting")
+ (version (git-version "0.8.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/cl-lzlib";)
+ (url "https://github.com/mbattyani/cl-typesetting";)
(commit commit)))
- (file-name (git-file-name "cl-lzlib" version))
+ (file-name (git-file-name "cl-typesetting" version))
(sha256
- (base32 "1dxzlkay7aqcs65h2f7j7rl4sdjija60dshlahzyllfw174p9d3m"))))
+ (base32 "0fcs5mq0gxfczbrg7ay8r4bf5r4g6blvpdbjkhcl8dapcikyn35h"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list lzlib
- sbcl-cffi
- sbcl-cl-octet-streams
- sbcl-lparallel))
(arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/lzlib.lisp"
- (("liblz\\.so")
- (search-input-file inputs "/lib/liblz.so"))))))))
- (synopsis "Common Lisp library for lzip (de)compression")
+ ;; NOTE: (Sharlatan-20210515T213014+0100): Circular dependencies with
+ ;; cl-typegraph
+ `(#:tests? #f))
+ (inputs
+ `(("cl-pdf" ,sbcl-cl-pdf)
+ ("xmls" ,sbcl-xmls)))
+ (home-page "https://github.com/mbattyani/cl-typesetting";)
+ (synopsis "Stand-alone Common Lisp typesetting system")
(description
- "This Common Lisp library provides functions for lzip (LZMA)
-compression/decompression using bindings to the lzlib C library.")
- (home-page "https://codeberg.org/glv/cl-lzlib";)
- (license license:gpl3+))))
+ "CL-TYPESETTING is a cross-platform Common Lisp typesetting library for
+all kind of typesetting applications.")
+ (license license:bsd-2))))
-(define-public cl-lzlib
- (sbcl-package->cl-source-package sbcl-lzlib))
+(define-public cl-typesetting
+ (sbcl-package->cl-source-package sbcl-cl-typesetting))
-(define-public ecl-lzlib
- (sbcl-package->ecl-package sbcl-lzlib))
+(define-public ecl-cl-typesetting
+ (sbcl-package->ecl-package sbcl-cl-typesetting))
-(define-public sbcl-chanl
- (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
+(define-public sbcl-cl-uglify-js
+ ;; There have been many bug fixes since the 2010 release.
+ (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
(revision "1"))
(package
- (name "sbcl-chanl")
- (version (git-version "0.4.1" revision commit))
+ (name "sbcl-cl-uglify-js")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/zkat/chanl";)
+ (url "https://github.com/mishoo/cl-uglify-js";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-uglify-js" version))
(sha256
(base32
- "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
+ "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-bordeaux-threads))
- (synopsis "Portable channel-based concurrency for Common Lisp")
- (description "Common Lisp library for channel-based concurrency. In
-a nutshell, you create various threads sequentially executing tasks you need
-done, and use channel objects to communicate and synchronize the state of these
-threads.")
- (home-page "https://github.com/zkat/chanl";)
- (license (list license:expat license:bsd-3)))))
+ (list sbcl-parse-js sbcl-cl-ppcre sbcl-cl-ppcre-unicode
+ sbcl-parse-number sbcl-iterate))
+ (home-page "https://github.com/mishoo/cl-uglify-js";)
+ (synopsis "JavaScript compressor library for Common Lisp")
+ (description "This is a Common Lisp version of UglifyJS, a JavaScript
+compressor. It works on data produced by @code{parse-js} to generate a
+@dfn{minified} version of the code. Currently it can:
-(define-public cl-chanl
- (sbcl-package->cl-source-package sbcl-chanl))
+@itemize
+@item reduce variable names (usually to single letters)
+@item join consecutive @code{var} statements
+@item resolve simple binary expressions
+@item group most consecutive statements using the @code{sequence} operator
(comma)
+@item remove unnecessary blocks
+@item convert @code{IF} expressions in various ways that result in smaller code
+@item remove some unreachable code
+@end itemize\n")
+ (license license:zlib))))
-(define-public ecl-chanl
- (sbcl-package->ecl-package sbcl-chanl))
+(define-public cl-uglify-js
+ (sbcl-package->cl-source-package sbcl-cl-uglify-js))
-(define-public sbcl-cl-store
- (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
+(define-public ecl-cl-uglify-js
+ (sbcl-package->ecl-package sbcl-cl-uglify-js))
+
+(define-public uglify-js
+ (package
+ (inherit sbcl-cl-uglify-js)
+ (name "uglify-js")
+ (build-system trivial-build-system)
+ (arguments
+ `(#:modules ((guix build utils))
+ #:builder
+ (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
+ (script (string-append bin "uglify-js")))
+ (use-modules (guix build utils))
+ (mkdir-p bin)
+ (with-output-to-file script
+ (lambda _
+ (format #t "#!~a/bin/sbcl --script
+
+ (require :asdf)
+ (asdf:initialize-source-registry
+ #p\"~a/etc/common-lisp/source-registry.conf.d/\")
+ (asdf:initialize-output-translations
+ #p\"~a/etc/common-lisp/asdf-output-translations.conf.d/\")"
+ (assoc-ref %build-inputs "sbcl")
+ (assoc-ref %build-inputs "sbcl-cl-uglify-js")
+ (assoc-ref %build-inputs "sbcl-cl-uglify-js"))
+ ;; FIXME: cannot use progn here because otherwise it fails to
+ ;; find cl-uglify-js.
+ (for-each
+ write
+ '(;; Quiet, please!
+ (let ((*standard-output* (make-broadcast-stream))
+ (*error-output* (make-broadcast-stream)))
+ (asdf:load-system :cl-uglify-js))
+ (let ((file (cadr *posix-argv*)))
+ (if file
+ (format t "~a"
+ (cl-uglify-js:ast-gen-code
+ (cl-uglify-js:ast-mangle
+ (cl-uglify-js:ast-squeeze
+ (with-open-file (in file)
+ (parse-js:parse-js in))))
+ :beautify nil))
+ (progn
+ (format *error-output*
+ "Please provide a JavaScript file.~%")
+ (sb-ext:exit :code 1))))))))
+ (chmod script #o755)
+ #t)))
+ (inputs
+ (list sbcl sbcl-cl-uglify-js))
+ (synopsis "JavaScript compressor")))
+
+(define-public sbcl-cl-unicode
+ (package
+ (name "sbcl-cl-unicode")
+ (version "0.1.6")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/cl-unicode";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0ykx2s9lqfl74p1px0ik3l2izd1fc9jd1b4ra68s5x34rvjy0hza"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-flexi-streams))
+ (inputs
+ (list 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)))
+
+(define-public cl-unicode
+ (sbcl-package->cl-source-package sbcl-cl-unicode))
+
+(define-public ecl-cl-unicode
+ (sbcl-package->ecl-package sbcl-cl-unicode))
+
+(define-public sbcl-cl-unification
+ (let ((commit "01079f34d197495880aa49ab727d63774d83035c")
(revision "1"))
(package
- (name "sbcl-cl-store")
- (version (git-version "0.8.11" revision commit))
+ (name "sbcl-cl-unification")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/skypher/cl-store";)
+ (url
"https://gitlab.common-lisp.net/cl-unification/cl-unification";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-unification" version))
(sha256
- (base32
- "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
+ (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-rt))
- (synopsis "Common Lisp library to serialize data")
- (description
- "CL-STORE is a portable serialization package which should give you the
-ability to store all Common Lisp data types into streams.")
- (home-page "https://www.common-lisp.net/project/cl-store/";)
- (license license:expat))))
+ (list sbcl-ptester))
+ (inputs
+ (list sbcl-cl-ppcre))
+ (home-page "https://common-lisp.net/project/cl-unification/";)
+ (synopsis "Unification framework for Common Lisp")
+ (description
+ "This package provides a framework to unify arbitrary
+Common Lisp objects while constructing bindings for placeholders
+(unification variables) in a template sublanguage.")
+ (license license:bsd-0))))
-(define-public cl-store
- (sbcl-package->cl-source-package sbcl-cl-store))
+(define-public cl-unification
+ (sbcl-package->cl-source-package sbcl-cl-unification))
-(define-public ecl-cl-store
- (sbcl-package->ecl-package sbcl-cl-store))
+(define-public ecl-cl-unification
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-unification)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; The tests fail on ECL with:
+ ;; "In MAKE-ARRAY: the elements in :INITIAL-CONTENTS do not match
+ ;; the array dimensions."
+ ((#:tests? _ #f) #f))))))
-(define-public sbcl-specialization-store
- (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3")
+(define-public sbcl-cl-utilities
+ (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
(revision "1"))
(package
- (name "sbcl-specialization-store")
- (version (git-version "0.0.5" revision commit))
+ (name "sbcl-cl-utilities")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/markcox80/specialization-store";)
- (commit commit)))
- (file-name (git-file-name "specialization-store" version))
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/";
+ "archive/" commit "/cl-utilities-" commit ".tar.gz"))
(sha256
- (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0"))))
+ (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-alexandria sbcl-introspect-environment))
- (home-page "https://github.com/markcox80/specialization-store";)
- (synopsis "Different type of generic function for Common Lisp")
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "rotate-byte.lisp"
+ (("in-package :cl-utilities)" all)
+ "in-package :cl-utilities)\n\n#+sbcl\n(require
:sb-rotate-byte)")))))))
+ (home-page "https://common-lisp.net/project/cl-utilities";)
+ (synopsis "Collection of semi-standard utilities")
(description
- "SPECIALIZATION-STORE system provides a new kind of function, called
-a store function, whose behavior depends on the types of objects passed to the
-function.")
- (license license:bsd-2))))
+ "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
+is a collection of Common Lisp Utilities, things that everybody writes since
+they're not part of the official standard. There are some very useful things
+there; the only problems are that they aren't implemented as well as you'd
+like (some aren't implemented at all) and they aren't conveniently packaged
+and maintained. It takes quite a bit of work to carefully implement utilities
+for common use, commented and documented, with error checking placed
+everywhere some dumb user might make a mistake.")
+ (license license:public-domain))))
-(define-public ecl-specialization-store
- (package
- (inherit (sbcl-package->ecl-package sbcl-specialization-store))
- (arguments
- ;; TODO: Find why the tests get stuck forever; disable them for now.
- `(#:tests? #f))))
+(define-public cl-utilities
+ (sbcl-package->cl-source-package sbcl-cl-utilities))
-(define-public cl-specialization-store
- (sbcl-package->cl-source-package sbcl-specialization-store))
+(define-public ecl-cl-utilities
+ (sbcl-package->ecl-package sbcl-cl-utilities))
-(define-public sbcl-cl-gobject-introspection
- (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9")
- (revision "3"))
+(define-public sbcl-cl-variates
+ (let ((commit "4e7548754d8a8731a42487fae31174db4bf36d47")
+ (revision "0"))
(package
- (name "sbcl-cl-gobject-introspection")
- (version (git-version "0.3" revision commit))
- (home-page "https://github.com/andy128k/cl-gobject-introspection";)
+ (name "sbcl-cl-variates")
+ (version "0.9.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://gitlab.common-lisp.net/cl-variates/cl-variates";)
(commit commit)))
- (file-name (git-file-name "cl-gobject-introspection" version))
+ (file-name (git-file-name "cl-variates" version))
(sha256
- (base32 "0xwmj4b3whz12i474g54krp1v6h0fpvsx8lgwpk6rkli9xc71wc3"))))
+ (base32 "03wnvfi3yfflpvi0mr732r834msij4vrwdbgf6csh0b8kqxl47zn"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list glib
- gobject-introspection
- sbcl-alexandria
- sbcl-cffi
- sbcl-iterate
- sbcl-trivial-garbage))
- (native-inputs
- (list sbcl-fiveam))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/init.lisp"
- (("libgobject-2\\.0\\.so")
- (search-input-file inputs "/lib/libgobject-2.0.so"))
- (("libgirepository-1\\.0\\.so")
- (search-input-file inputs
- "/lib/libgirepository-1.0.so"))))))))
- (synopsis "Common Lisp bindings to GObject Introspection")
- (description
- "This library is a bridge between Common Lisp and GObject
-Introspection, which enables Common Lisp programs to access the full interface
-of C+GObject libraries without the need of writing dedicated bindings.")
- (license (list license:bsd-3
- ;; Tests are under a different license.
- license:llgpl)))))
+ ;; USE-PACKAGE #<PACKAGE "CL-VARIATES"> causes name-conflicts in
+ ;; #<PACKAGE "CL-VARIATES-TEST"> between the following symbols:
+ ;; CL-VARIATES:RANDOM-ELEMENT, LIFT:RANDOM-ELEMENT
+ (arguments (list #:tests? #f))
+ (native-inputs (list sbcl-lift))
+ (home-page "https://gitlab.common-lisp.net/cl-variates/cl-variates";)
+ (synopsis "Portable Common Lisp Random Number Generation")
+ (description "The variates package provides portable random number
+generation as well as numerous distributions.")
+ (license license:expat))))
-(define-public cl-gobject-introspection
- (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
+(define-public cl-variates
+ (sbcl-package->cl-source-package sbcl-cl-variates))
-(define-public ecl-cl-gobject-introspection
- (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
+(define-public ecl-cl-variates
+ (sbcl-package->ecl-package sbcl-cl-variates))
-(define-public sbcl-cl-gobject-introspection-wrapper
- (let ((commit "2d197cba7e7d734ac8a2e181e5e709e5b218bada")
- (revision "1"))
+(define-public sbcl-cl-vectors
+ (package
+ (name "sbcl-cl-vectors")
+ (version "0.1.5")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "http://projects.tuxee.net/cl-vectors/";
+ "files/cl-vectors-" version ".tar.gz"))
+ (sha256
+ (base32
+ "04lhwi0kq8pkwhgd885pk80m1cp9sfvjjn5zj70s1dnckibhdmqh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("zpb-ttf" ,sbcl-zpb-ttf)))
+ (arguments
+ '(#:asd-systems '("cl-vectors"
+ "cl-paths"
+ "cl-paths-ttf"
+ "cl-aa"
+ "cl-aa-misc")))
+ (home-page "http://projects.tuxee.net/cl-vectors/";)
+ (synopsis "Create, transform and render anti-aliased vectorial paths")
+ (description
+ "This is a pure Common Lisp library to create, transform and render
+anti-aliased vectorial paths.")
+ (license license:expat)))
+
+(define-public cl-vectors
+ (sbcl-package->cl-source-package sbcl-cl-vectors))
+
+(define-public ecl-cl-vectors
+ (sbcl-package->ecl-package sbcl-cl-vectors))
+
+(define-public sbcl-cl-vorbis
+ (let ((commit "c5835cd7091aea9e2e389ad359d244542d637758")
+ (revision "0"))
(package
- (name "sbcl-cl-gobject-introspection-wrapper")
+ (name "sbcl-cl-vorbis")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url
"https://github.com/bohonghuang/cl-gobject-introspection-wrapper";)
+ (url "https://github.com/Shirakumo/cl-vorbis";)
(commit commit)))
- (file-name (git-file-name "cl-gobject-introspection-wrapper" version))
+ (file-name (git-file-name "cl-vorbis" version))
(sha256
- (base32 "05np2zs5806ib6qfz7d6knyaz6llxgwvjqavl1fsz5hcga40296s"))))
+ (base32 "0713pl5c2khfpf8m3h1l2y0ilack7akf580h70jq6qcrnq3h4b40"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Delete bundled libraries, GlibC and Vorbis sources.
+ `(begin
+ (delete-file-recursively "static")
+ (for-each delete-file '("glibc-2.13.h"
+ "stb_vorbis.c"
+ "stb_vorbis_patch.c"))))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "low-level.lisp"
+ (("libvorbis-lin-amd64.so")
+ (search-input-file inputs "/lib/libvorbis.so"))))))))
(inputs
- (list sbcl-alexandria
- sbcl-cl-gobject-introspection
- sbcl-cl-ppcre))
- (home-page
- "https://github.com/bohonghuang/cl-gobject-introspection-wrapper";)
- (synopsis
- "Wrap and call GObject Introspection FFI function in Common Lisp")
- (description
- "This library converts the elements from GObject Introspection into
-Common Lisp-style definitions, based on cl-gobject-introspection.")
- (license license:lgpl3+))))
+ (list libvorbis
+ sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-static-vectors
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (home-page "https://shirakumo.github.io/cl-vorbis/";)
+ (synopsis "OGG/Vorbis decoding using stb_vorbis for Common Lisp")
+ (description "This package provides CFFI bindings for the
+@code{stb_vorbis} audio library to Common Lisp.")
+ (license license:zlib))))
-(define-public cl-gobject-introspection-wrapper
- (sbcl-package->cl-source-package sbcl-cl-gobject-introspection-wrapper))
+(define-public cl-vorbis
+ (sbcl-package->cl-source-package sbcl-cl-vorbis))
-(define-public ecl-cl-gobject-introspection-wrapper
- (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper))
+(define-public ecl-cl-vorbis
+ (sbcl-package->ecl-package sbcl-cl-vorbis))
-(define-public sbcl-cl-glib
- (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57")
- (revision "1"))
+(define-public sbcl-cl-wayland
+ (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae")
+ (revision "0"))
(package
- (name "sbcl-cl-glib")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-wayland")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bohonghuang/cl-glib";)
+ (url "https://github.com/sdilts/cl-wayland";)
(commit commit)))
- (file-name (git-file-name "cl-glib" version))
+ (file-name (git-file-name "cl-wayland" version))
(sha256
- (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" ))))
+ (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject")))
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "wayland-server-core.lisp"
+ (("libwayland-server.so")
+ (search-input-file inputs
+ "/lib/libwayland-server.so"))))))))
(inputs
- (list glib
- gobject-introspection
- sbcl-bordeaux-threads
- sbcl-cl-gobject-introspection-wrapper))
- (home-page "https://github.com/bohonghuang/cl-glib";)
- (synopsis "Glib, GIO and Gobject bindings for Common Lisp")
- (description "This library provides Glib, GIO and Gobject bindings for
-Common Lisp via Gobject Introspection.")
- (license license:lgpl3+))))
+ (list sbcl-cffi
+ sbcl-closer-mop
+ wayland))
+ (home-page "https://github.com/sdilts/cl-wayland";)
+ (synopsis "Common Lisp FFI bindings for libwayland")
+ (description
+ "This package provides Common Lisp FFI bindings for libwayland,
+primarily for the mahogany window manager.")
+ (license license:bsd-3))))
-(define-public cl-glib
- (sbcl-package->cl-source-package sbcl-cl-glib))
+(define-public cl-wayland
+ (sbcl-package->cl-source-package sbcl-cl-wayland))
-(define-public ecl-cl-glib
- (sbcl-package->ecl-package sbcl-cl-glib))
+(define-public ecl-cl-wayland
+ (sbcl-package->ecl-package sbcl-cl-wayland))
-(define-public sbcl-cl-gtk4
- (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4")
- (revision "1"))
- (package
- (name "sbcl-cl-gtk4")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/bohonghuang/cl-gtk4";)
- (commit commit)))
- (file-name (git-file-name "cl-gtk4" version))
- (sha256
- (base32 "0mprmmvbagnflvhynn51l42nbwr08rld99ls0c48m5lpjn0ja4zc"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-gtk4" "cl-gdk4")))
- ;; propagate because it at least requires the typelib files at runtime
- (propagated-inputs (list gtk))
- (inputs
- (list gobject-introspection
- sbcl-cl-glib
- sbcl-cl-gobject-introspection-wrapper))
- (home-page "https://github.com/bohonghuang/cl-gtk4";)
- (synopsis "GTK4 bindings for Common Lisp")
- (description
- "This library provides GTK4 bindings for Common Lisp via Gobject
-Introspection, in the cl-gtk4 ASDF system.")
- (license license:lgpl3))))
+(define-public sbcl-cl-webkit
+ (package
+ (name "sbcl-cl-webkit")
+ (version "3.5.10")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/joachifm/cl-webkit";)
+ (commit version)))
+ (file-name (git-file-name "cl-webkit" version))
+ (sha256
+ (base32
+ "0bn8idvbi58kg0g76lanvjzkgnkcy41yn9vbp7f80q9fa7w892rq"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("cl-cffi-gtk" ,sbcl-cl-cffi-gtk)
+ ("webkitgtk" ,webkitgtk-for-gtk3)))
+ (native-inputs
+ `(;; Tests seem to need Xorg.
+ ;; ("xorg-server" ,xorg-server-for-tests)
+ ("calispel" ,sbcl-calispel)
+ ("fiveam" ,sbcl-fiveam)
+ ("float-features" ,sbcl-float-features)))
+ (arguments
+ `(#:asd-systems '("cl-webkit2")
+ #:tests? #f ; TODO: Tests hang, why?
+ #:phases
+ (modify-phases %standard-phases
+ ;; The following phase is needed for tests:
+ ;; (add-before 'check 'start-xorg-server
+ ;; (lambda* (#:key inputs #:allow-other-keys)
+ ;; ;; The test suite requires a running X server.
+ ;; (system (string-append (assoc-ref inputs "xorg-server")
+ ;; "/bin/Xvfb :1 &"))
+ ;; (setenv "DISPLAY" ":1")
+ ;; #t))
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "webkit2/webkit2.init.lisp"
+ (("libwebkit2gtk" all)
+ (string-append
+ (assoc-ref inputs "webkitgtk") "/lib/" all))))))))
+ (home-page "https://github.com/joachifm/cl-webkit";)
+ (synopsis "Binding to WebKitGTK+ for Common Lisp")
+ (description
+ "@command{cl-webkit} is a binding to WebKitGTK+ for Common Lisp,
+currently targeting WebKit version 2. The WebKitGTK+ library adds web
+browsing capabilities to an application, leveraging the full power of the
+WebKit browsing engine.")
+ (license license:expat)))
-(define-public cl-gtk4
- (sbcl-package->cl-source-package sbcl-cl-gtk4))
+(define-public cl-webkit
+ (sbcl-package->cl-source-package sbcl-cl-webkit))
-(define-public ecl-cl-gtk4
- (sbcl-package->ecl-package sbcl-cl-gtk4))
+(define-public ecl-cl-webkit
+ (sbcl-package->ecl-package sbcl-cl-webkit))
-(define-public sbcl-cl-slug
- (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749")
- (revision "1"))
+(define-public sbcl-cl-who
+ (let ((version "1.1.4")
+ (commit "07dafe9b351c32326ce20b5804e798f10d4f273d")
+ (revision "3"))
(package
- (name "sbcl-cl-slug")
- (version (git-version "0.4.1" revision commit))
+ (name "sbcl-cl-who")
+ (version (git-version version revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/EuAndreh/cl-slug";)
+ (url "https://github.com/edicl/cl-who";)
(commit commit)))
- (file-name (git-file-name "cl-slug" version))
+ (file-name (git-file-name "cl-who" version))
(sha256
- (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx"))))
+ (base32
+ "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-prove))
- (inputs
- `(("ppcre" ,sbcl-cl-ppcre)))
- (home-page "https://github.com/EuAndreh/cl-slug";)
- (synopsis "Multi-language slug formatter")
+ (list sbcl-flexi-streams))
+ (home-page "https://edicl.github.io/cl-who/";)
+ (synopsis "Yet another Lisp markup language")
(description
- "This is a small Common Lisp library to make slugs, mainly for URIs,
-from English and beyond.")
- (license license:llgpl))))
+ "There are plenty of Lisp Markup Languages out there - every Lisp
+programmer seems to write at least one during his career - and CL-WHO (where
+WHO means \"with-html-output\" for want of a better acronym) is probably just
+as good or bad as the next one.")
+ (license license:bsd-2))))
-(define-public ecl-cl-slug
- (sbcl-package->ecl-package sbcl-cl-slug))
+(define-public cl-who
+ (sbcl-package->cl-source-package sbcl-cl-who))
-(define-public cl-slug
- (sbcl-package->cl-source-package sbcl-cl-slug))
+(define-public ecl-cl-who
+ (sbcl-package->ecl-package sbcl-cl-who))
-(define-public sbcl-string-case
- (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
- (revision "0"))
+(define-public sbcl-cl-xmlspam
+ (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
(package
- (name "sbcl-string-case")
- (version (git-version "0.0.2" revision commit))
- (home-page "https://github.com/pkhuong/string-case";)
+ (name "sbcl-cl-xmlspam")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.0.0" "1" commit))
+ (home-page "https://github.com/rogpeppe/cl-xmlspam";)
(source
(origin
(method git-fetch)
(uri (git-reference
(url home-page)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (string-append name "-" version))
(sha256
(base32
- "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Efficient string= case in Common Lisp")
- (description
- "@code{string-case} is a Common Lisp macro that generates specialised
decision
-trees to dispatch on string equality.")
+ "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
+ (inputs
+ (list sbcl-cxml sbcl-cl-ppcre))
+ (synopsis "Concise, regexp-like pattern matching on streaming XML for
Common Lisp")
+ (description "CXML does an excellent job at parsing XML elements, but
what
+do you do when you have a XML file that's larger than you want to fit in
+memory, and you want to extract some information from it? Writing code to deal
+with SAX events, or even using Klacks, quickly becomes tedious.
+@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
+to write code that mirrors the structure of the XML that it's parsing. It
+also makes it easy to shift paradigms when necessary - the usual Lisp control
+constructs can be used interchangeably with pattern matching, and the full
+power of CXML is available when necessary.")
(license license:bsd-3))))
-(define-public cl-string-case
- (sbcl-package->cl-source-package sbcl-string-case))
+(define-public cl-xmlspam
+ (sbcl-package->cl-source-package sbcl-cl-xmlspam))
-(define-public ecl-string-case
- (sbcl-package->ecl-package sbcl-string-case))
+(define-public ecl-cl-xmlspam
+ (sbcl-package->ecl-package sbcl-cl-xmlspam))
-(define-public sbcl-garbage-pools
- (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790")
+(define-public sbcl-cl-yacc
+ (package
+ (name "sbcl-cl-yacc")
+ (version "0.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jech/cl-yacc";)
+ (commit (string-append "cl-yacc-" version))))
+ (sha256
+ (base32
+ "16946pzf8vvadnyfayvj8rbh4zjzw90h0azz2qk1mxrvhh5wklib"))
+ (file-name (string-append "cl-yacc-" version "-checkout"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("yacc")))
+ (synopsis "LALR(1) parser generator for Common Lisp, similar in spirit to
Yacc")
+ (description
+ "CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit
+to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
+
+CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used
+by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due
+to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).")
+ (home-page "https://www.irif.fr/~jch//software/cl-yacc/";)
+ (license license:expat)))
+
+(define-public cl-yacc
+ (sbcl-package->cl-source-package sbcl-cl-yacc))
+
+(define-public ecl-cl-yacc
+ (sbcl-package->ecl-package sbcl-cl-yacc))
+
+(define-public sbcl-cl-yaml
+ (let ((commit "c3202be9a753c51f3bc79538a5a498a8865192aa")
(revision "1"))
(package
- (name "sbcl-garbage-pools")
- (version (git-version "0.1.2" revision commit))
+ (name "sbcl-cl-yaml")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/garbage-pools";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "04jqwr6j138him6wc4nrwjzm4lvyj5j31xqab02nkf8h9hmsf5v1"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/archimag/garbage-pools";)
- (synopsis "Resource management pools for Common Lisp")
- (description "GARBAGE-POOLS is Common Lisp re-implementation of the APR
-Pools for resource management.")
- (license license:expat))))
-
-(define-public ecl-garbage-pools
- (sbcl-package->ecl-package sbcl-garbage-pools))
-
-(define-public cl-garbage-pools
- (sbcl-package->cl-source-package sbcl-garbage-pools))
-
-(define-public sbcl-global-vars
- (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
- (revision "0"))
- (package
- (name "sbcl-global-vars")
- (version (git-version "1.0.0" revision commit))
- (home-page "https://github.com/lmj/global-vars";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
+ (url "https://github.com/eudoxia0/cl-yaml";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-yaml" version))
(sha256
- (base32
- "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
+ (base32 "1izjg0v6rf7dh069bbnnr67l30lsqj86wdk7y9ggbgiwh6v9j185"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Efficient global variables in Common Lisp")
+ (inputs
+ (list sbcl-alexandria sbcl-cl-libyaml sbcl-cl-ppcre
+ sbcl-parse-number))
+ (native-inputs
+ (list sbcl-cl-fad sbcl-fiveam sbcl-generic-comparability
+ sbcl-trivial-benchmark sbcl-yason))
+ (home-page "https://github.com/eudoxia0/cl-yaml";)
+ (synopsis "YAML parser for Common Lisp")
(description
- "In Common Lisp, a special variable that is never dynamically bound
-typically serves as a stand-in for a global variable. The @code{global-vars}
-library provides true global variables that are implemented by some compilers.
-An attempt to rebind a global variable properly results in a compiler error.
-That is, a global variable cannot be dynamically bound.
-
-Global variables therefore allow us to communicate an intended usage that
-differs from special variables. Global variables are also more efficient than
-special variables, especially in the presence of threads.")
+ "This is a YAML parser and emitter for Common Lisp built on top of
+libyaml.")
(license license:expat))))
-(define-public cl-global-vars
- (sbcl-package->cl-source-package sbcl-global-vars))
+(define-public cl-yaml
+ (sbcl-package->cl-source-package sbcl-cl-yaml))
-(define-public ecl-global-vars
- (sbcl-package->ecl-package sbcl-global-vars))
+(define-public ecl-cl-yaml
+ (sbcl-package->ecl-package sbcl-cl-yaml))
-(define-public sbcl-trivial-file-size
- (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
- (revision "0"))
+(define-public sbcl-cl-z85
+ (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
+ (revision "1"))
(package
- (name "sbcl-trivial-file-size")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/trivial-file-size";)
+ (name "sbcl-cl-z85")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://codeberg.org/glv/cl-z85";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
+ (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
- (synopsis "Size of a file in bytes in Common Lisp")
+ (list sbcl-cl-octet-streams sbcl-fiveam))
+ (synopsis "Common Lisp library for Z85 encoding and decoding")
(description
- "The canonical way to determine the size of a file in bytes, using
Common Lisp,
-is to open the file with an element type of (unsigned-byte 8) and then
-calculate the length of the stream. This is less than ideal. In most cases
-it is better to get the size of the file from its metadata, using a system
-call.
-
-This library exports a single function, file-size-in-octets. It returns the
-size of a file in bytes, using system calls when possible.")
- (license license:expat))))
+ "This package provides functions to encode or decode byte vectors or
+byte streams using the Z85 format, which is a base-85 encoding used by
+ZeroMQ.")
+ (home-page "https://codeberg.org/glv/cl-z85";)
+ (license license:gpl3+))))
-(define-public cl-trivial-file-size
- (sbcl-package->cl-source-package sbcl-trivial-file-size))
+(define-public cl-z85
+ (sbcl-package->cl-source-package sbcl-cl-z85))
-(define-public ecl-trivial-file-size
- (sbcl-package->ecl-package sbcl-trivial-file-size))
+(define-public ecl-cl-z85
+ (sbcl-package->ecl-package sbcl-cl-z85))
-(define-public sbcl-trivial-macroexpand-all
- (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
- (revision "0"))
+(define-public sbcl-clache
+ (let ((commit "112976729565e1035532389ca25090ae99badd07"))
(package
- (name "sbcl-trivial-macroexpand-all")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/cbaggers/trivial-macroexpand-all";)
+ (name "sbcl-clache")
+ (version (git-version "0.2.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/html/clache/";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clache" version))
(sha256
- (base32
- "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
+ (base32 "0wxg004bsay58vr6xr6mlk7wj415qmvisqxvpnjsg6glfwca86ys"))))
(build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cl-annot
+ sbcl-cl-fad
+ sbcl-cl-store
+ sbcl-cl-syntax
+ sbcl-ironclad
+ sbcl-trivial-garbage))
(native-inputs
- (list sbcl-fiveam))
- (synopsis "Portable macroexpand-all for Common Lisp")
+ (list sbcl-prove))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "clache-test.asd"
+ (("cl-test-more") "prove"))
+ #t)))))
+ (home-page "https://github.com/html/clache/";)
+ (synopsis "General caching facility for Common Lisp")
(description
- "This library provides a macroexpand-all function that calls the
-implementation specific equivalent.")
- (license license:unlicense))))
+ "CLACHE provides a general caching facility for Common Lisp. The API is
+similar to the standard hash-table interface.")
+ (license license:llgpl))))
-(define-public cl-trivial-macroexpand-all
- (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
+(define-public cl-clache
+ (sbcl-package->cl-source-package sbcl-clache))
-(define-public ecl-trivial-macroexpand-all
- (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
+(define-public ecl-clache
+ (sbcl-package->ecl-package sbcl-clache))
-(define-public sbcl-serapeum
- (let ((commit "c08442a9757b7fa30ac345cb040e1642f97f6b78")
- (revision "12"))
+(define-public sbcl-clack
+ (let ((commit "6fd0279424f7ba5fd4f92d69a1970846b0b11222")
+ (revision "2"))
(package
- (name "sbcl-serapeum")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/serapeum";)
+ (name "sbcl-clack")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/fukamachi/clack";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clack" version))
(sha256
- (base32 "1sabd048agvgv7bhbw126rci9hf45fk08zhghcv6an2h6xwmc3qv"))))
+ (base32 "0sfmvqmsg9z13x0v77448rpdqgyprdq739nsbrjw9a28hv9jmkg9"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("clack"
+ "clack-handler-fcgi"
+ "clack-socket"
+ "clack-handler-hunchentoot")))
(inputs
(list sbcl-alexandria
- sbcl-trivia
- sbcl-split-sequence
- sbcl-string-case
- sbcl-parse-number
- sbcl-trivial-garbage
sbcl-bordeaux-threads
- sbcl-parse-declarations
- sbcl-introspect-environment
- sbcl-trivial-cltl2
- sbcl-global-vars
- sbcl-trivial-file-size
- sbcl-trivial-macroexpand-all))
- (native-inputs
- (list sbcl-atomics
- sbcl-fiveam
- sbcl-local-time))
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'disable-failing-tests
- (lambda _
- (substitute* "serapeum.asd"
- ;; Guix does not have Quicklisp, and probably never
will.
- (("\\(:file \"quicklisp\"\\)") "")))))))
- (synopsis "Common Lisp utility library beyond Alexandria")
+ sbcl-cl-fastcgi
+ sbcl-flexi-streams
+ sbcl-hunchentoot
+ sbcl-lack
+ sbcl-quri
+ sbcl-split-sequence
+ sbcl-usocket))
+ (home-page "https://github.com/fukamachi/clack";)
+ (synopsis "Web Application Environment for Common Lisp")
(description
- "Serapeum is a conservative library of Common Lisp utilities. It is a
-supplement, not a competitor, to Alexandria.")
- (license license:expat))))
+ "Clack is a web application environment for Common Lisp inspired by
+Python's WSGI and Ruby's Rack.")
+ (license license:llgpl))))
-(define-public cl-serapeum
- (sbcl-package->cl-source-package sbcl-serapeum))
+(define-public cl-clack
+ (sbcl-package->cl-source-package sbcl-clack))
-(define-public ecl-serapeum
- (sbcl-package->ecl-package sbcl-serapeum))
+(define-public ecl-clack
+ (sbcl-package->ecl-package sbcl-clack))
-(define-public sbcl-rutils
- (let ((commit "db3c3f4ae897025b5f0cd81042ca147da60ca0c5")
+(define-public sbcl-clad
+ (let ((commit "1ff6f417d4ee3836d1edd96923d4b03f3cafa849")
(revision "0"))
(package
- (name "sbcl-rutils")
- (version (git-version "5.2.1" revision commit))
+ (name "sbcl-clad")
+ (version
+ ;; There's no version, but there's a timestamp
+ (git-version "2023-01-21" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vseloved/rutils";)
+ (url "https://gitlab.common-lisp.net/mantoniotti/CLAD";)
(commit commit)))
- (file-name (git-file-name "rutils" version))
+ (file-name (git-file-name "cl-clad" version))
(sha256
- (base32 "1d2whscknh1zga2vdqvfqri8wx0gnml3sfqz62igq0ppap6q07y3"))))
+ (base32 "184mhdq7pxd6hd4rzv8z4lfbwnkyhgm5bdn3xsqaav2j0d1dqm6i"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Delete compiled ABCL files.
+ '(begin
+ (delete-file "clad-package.abcl")
+ (delete-file "clad.abcl")))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Library providing standard locations on the file system")
+ (description
+ "The Common Lisp Application Directories (CLAD) library is
+a simple API collection that provides access to a set of @emph{standard}
+Common Lisp folders on a per-application or per-library basis.")
+ (home-page "https://gitlab.common-lisp.net/mantoniotti/CLAD";)
+ (license license:expat)))) ;the mit-modern-variant is used
+
+(define-public cl-clad
+ (sbcl-package->cl-source-package sbcl-clad))
+
+(define-public sbcl-clamp
+ (let ((commit "02b8f3953e5753cc61a719807c82f3795cd28fe1"))
+ (package
+ (name "sbcl-clamp")
+ (version (git-version "0.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/arclanguage/Clamp";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0fdr9nqfmmpxm6hvjdxi1jkclya9xlnrw1yc3cn1m4ww3f50p31m"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("rutils" "rutilsx")
- ;; Tests disabled because of a circular dependency with should-test.
- #:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- ;; File faild to load, and we don't use it as tests are
- ;; disabled, so let's delete it.
- (delete-file "rutilsx-test.asd"))))))
(inputs
- `(("closer-mop" ,sbcl-closer-mop)
- ("named-readtables" ,sbcl-named-readtables)))
- (home-page "https://github.com/vseloved/rutils";)
- (synopsis "Radical Utilities for Common Lisp")
- (description "RUTILS is a syntactic utilities package for Common Lisp.")
- (license license:bsd-3))))
+ `(("iterate" ,sbcl-iterate)
+ ("cl-syntax" ,sbcl-cl-syntax)))
+ (native-inputs
+ `(("cl-unit" ,sbcl-clunit)
+ ("check-it" ,sbcl-check-it)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "clamp.asd"
+ (("\\(:file \"read\" :depends-on \\(\"aliases\"\\)\\)")
+ "(:file \"read\" :depends-on (\"aliases\" \"base\"))"))
+ #t)))))
+ (home-page "https://github.com/arclanguage/Clamp";)
+ (synopsis "Common Lisp with Arc macros and procedures")
+ (description
+ "Clamp is an attempt to bring the powerful, but verbose, language of
+Common Lisp up to the terseness of Arc.
-(define-public cl-rutils
- (sbcl-package->cl-source-package sbcl-rutils))
+There are two parts to Clamp. There is the core of Clamp, which implements
+the utilities of Arc that are easily converted from Arc to Common Lisp. The
+other part is the \"experimental\" part. It contains features of Arc that are
+not so easy to copy (ssyntax, argument destructuring, etc.).")
+ (license license:artistic2.0))))
-(define-public ecl-rutils
- (sbcl-package->ecl-package sbcl-rutils))
+(define-public cl-clamp
+ (sbcl-package->cl-source-package sbcl-clamp))
-(define-public sbcl-arrow-macros
- ;; The latest upstream version tag is dated (pushed in 2020), use the latest
- ;; commit instead.
- (let ((commit "16bdfd31298182099c7d70df4598104e5a38b05e")
+(define-public ecl-clamp
+ (sbcl-package->ecl-package sbcl-clamp))
+
+(define-public sbcl-class-options
+ (package
+ (name "sbcl-class-options")
+ (version "1.0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/class-options";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-class-options" version))
+ (sha256
+ (base32 "1dkgr1vbrsra44jznzz2bvdf8nlpdrrkjcqrfs8aa7axksda3bqk"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-enhanced-boolean sbcl-parachute))
+ (inputs
+ (list sbcl-closer-mop sbcl-enhanced-find-class))
+ (home-page "https://www.hexstreamsoft.com/libraries/class-options/";)
+ (synopsis "Accessing defining class and its options during modification")
+ (description
+ "This package provides easy access to the defining class and its options
+during initialization or reinitialization of its subcomponents.")
+ (license license:unlicense)))
+
+(define-public cl-class-options
+ (sbcl-package->cl-source-package sbcl-class-options))
+
+(define-public ecl-class-options
+ (sbcl-package->ecl-package sbcl-class-options))
+
+(define-public sbcl-classimp
+ (let ((commit "d82a14c59bc733f89a1ea0b3447ebedddce5756e")
(revision "0"))
(package
- (name "sbcl-arrow-macros")
- (version (git-version "0.2.7" revision commit))
+ (name "sbcl-classimp")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hipeta/arrow-macros";)
+ (url "https://github.com/3b/classimp";)
(commit commit)))
- (file-name (git-file-name "arrow-macros" version))
+ (file-name (git-file-name "cl-classimp" version))
(sha256
- (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4"))))
+ (base32 "0pbnz6cf1zb2ayk4kbw0gphjb8nflnjns2rwhv86jz0kf0z1hqha"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (home-page "https://github.com/hipeta/arrow-macros/";)
- (synopsis "Clojure-like arrow macros in Common Lisp")
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'patch-assimp-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "library.lisp"
+ (("libassimp.so.5" _)
+ (search-input-file inputs "/lib/libassimp.so.5.0.0"))))))))
+ (inputs
+ (list assimp-5.0
+ sbcl-cffi
+ sbcl-split-sequence))
+ (home-page "https://github.com/3b/classimp";)
+ (synopsis "Common Lisp CFFI bindings for Open Asset Import Library")
(description
- "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and
diamond wands
-in swiss-arrows.")
+ "This package provides CFFI bindings to the @acronym{ASSIMP, Asset
+Import} library for Common Lisp.")
(license license:expat))))
-(define-public cl-arrow-macros
- (sbcl-package->cl-source-package sbcl-arrow-macros))
+;; FIXME: The cl and ecl packages get the latest version of assimp as
+;; dependency instead of the one specified in the sbcl package. Specifying
+;; the dependencies explicitly works around the issue.
+(define-public cl-classimp
+ (let ((pkg (sbcl-package->cl-source-package sbcl-classimp)))
+ (package
+ (inherit pkg)
+ (inputs
+ (list assimp-5.0
+ cl-cffi
+ cl-split-sequence)))))
-(define-public ecl-arrow-macros
- (sbcl-package->ecl-package sbcl-arrow-macros))
+(define-public ecl-classimp
+ (let ((pkg (sbcl-package->ecl-package sbcl-classimp)))
+ (package
+ (inherit pkg)
+ (inputs
+ (list assimp-5.0
+ ecl-cffi
+ ecl-split-sequence)))))
-(define-public sbcl-arrows
- (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
- (revision "0"))
+(define-public sbcl-clavier
+ (let ((commit "9b1424eaad131e114a45b400784079124b5e2321")
+ (revision "1"))
(package
- (name "sbcl-arrows")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-clavier")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/Harleqin/arrows.git";)
+ (url "https://github.com/mmontone/clavier";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clavier" version))
(sha256
- (base32
- "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
+ (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.stefil))
- (synopsis "Clojure-like arrow macros for Common Lisp")
- (description
- "This library implements the @code{->} and @code{->>} macros from
-Clojure, as well as several expansions on the idea.")
- (home-page "https://gitlab.com/Harleqin/arrows";)
- (license license:public-domain))))
+ (native-inputs (list sbcl-stefil))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-chronicity
+ sbcl-cl-fad
+ sbcl-cl-ppcre
+ sbcl-closer-mop))
+ (home-page "https://github.com/mmontone/clavier/";)
+ (synopsis "General purpose validation library")
+ (description "Clavier is a general purpose validation library for
+Common Lisp.")
+ (license license:expat))))
-(define-public cl-arrows
- (sbcl-package->cl-source-package sbcl-arrows))
+(define-public cl-clavier
+ (sbcl-package->cl-source-package sbcl-clavier))
-(define-public ecl-arrows
- (sbcl-package->ecl-package sbcl-arrows))
+(define-public ecl-clavier
+ (sbcl-package->ecl-package sbcl-clavier))
-(define-public sbcl-simple-parallel-tasks
- (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6")
- (revision "1"))
+(define-public sbcl-claw
+ (let ((revision "0")
+ (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250"))
(package
- (name "sbcl-simple-parallel-tasks")
+ (name "sbcl-claw")
(version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/simple-parallel-tasks";)
+ (url "https://github.com/borodust/claw";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "claw" version))
(sha256
- (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7"))))
+ (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-chanl))
- (synopsis "Common Lisp library to evaluate some forms in parallel")
- (description "This is a simple Common Lisp library to evaluate some
-forms in parallel.")
- (home-page "https://codeberg.org/glv/simple-parallel-tasks";)
- (license license:gpl3))))
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-cl-json
+ sbcl-cl-ppcre
+ sbcl-claw-support
+ sbcl-local-time
+ sbcl-trivial-features))
+ (home-page "https://github.com/borodust/claw";)
+ (synopsis "Autowrapper for Common Lisp")
+ (description
+ "This is a Common Lisp autowrapping facility for quickly creating clean
+and lean bindings to C libraries.")
+ (license license:bsd-2))))
-(define-public cl-simple-parallel-tasks
- (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
+(define-public cl-claw
+ (sbcl-package->cl-source-package sbcl-claw))
-(define-public ecl-simple-parallel-tasks
- (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
+(define-public ecl-claw
+ (sbcl-package->ecl-package sbcl-claw))
-(define-public sbcl-cl-heap
+(define-public sbcl-claw-support
(package
- (name "sbcl-cl-heap")
- (version "0.1.6")
+ (name "sbcl-claw-support")
+ (version "1.0.0")
(source
(origin
- (method url-fetch)
- (uri (string-append "https://common-lisp.net/project/cl-heap/releases/";
- "cl-heap_" version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/borodust/claw-support";)
+ (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b")))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
+ (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-xlunit))
- (arguments
- '(#:asd-test-systems '("cl-heap-tests")))
- (synopsis "Heap and priority queue data structures for Common Lisp")
+ (home-page "https://github.com/borodust/claw-support";)
+ (synopsis "Support routines for claw")
(description
- "CL-HEAP provides various implementations of heap data structures (a
-binary heap and a Fibonacci heap) as well as an efficient priority queue.")
- (home-page "https://common-lisp.net/project/cl-heap/";)
- (license license:gpl3+)))
+ "This package provides support routines for the @code{claw} Common Lisp
+package.")
+ (license license:expat)))
-(define-public cl-heap
- (sbcl-package->cl-source-package sbcl-cl-heap))
+(define-public cl-claw-support
+ (sbcl-package->cl-source-package sbcl-claw-support))
-(define-public ecl-cl-heap
- (sbcl-package->ecl-package sbcl-cl-heap))
+(define-public ecl-claw-support
+ (sbcl-package->ecl-package sbcl-claw-support))
-(define-public sbcl-curry-compose-reader-macros
- (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
- (revision "0"))
+(define-public sbcl-claw-utils
+ (let ((revision "0")
+ (commit "efe25016501973dc369f067a64c7d225802bc56f"))
(package
- (name "sbcl-curry-compose-reader-macros")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-claw-utils")
+ ;; version is not specified
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/eschulte/curry-compose-reader-macros";)
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri (git-reference
+ (url "https://github.com/borodust/claw-utils";)
+ (commit commit)))
+ (file-name (git-file-name "claw-utils" version))
(sha256
- (base32
- "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
+ (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-named-readtables))
- (synopsis "Reader macros for partial application and composition")
+ (list sbcl-alexandria sbcl-cffi sbcl-claw))
+ (home-page "https://github.com/borodust/claw-utils";)
+ (synopsis "Utilities for easier autowrapping")
(description
- "This Common Lisp library provides reader macros for concise expression
-of function partial application and composition.")
- (home-page "https://eschulte.github.io/curry-compose-reader-macros/";)
- (license license:public-domain))))
-
-(define-public cl-curry-compose-reader-macros
- (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
-
-(define-public ecl-curry-compose-reader-macros
- (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
-
-(define-public sbcl-yason
- (package
- (name "sbcl-yason")
- (version "0.8.4")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/phmarek/yason";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-yason" version))
- (sha256
- (base32 "0d22sw7nf2ygqm56ilybg7bza63cv43pc4184r8rvsjz2in37n51"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-trivial-gray-streams))
- (synopsis "Common Lisp JSON parser/encoder")
- (description
- "YASON is a Common Lisp library for encoding and decoding data in the
-JSON interchange format.")
- (home-page "https://github.com/phmarek/yason";)
- (license license:bsd-3)))
+ "This Common Lisp library contains various handy utilities to help
+autowrapping with @code{claw}.")
+ (license license:expat))))
-(define-public cl-yason
- (sbcl-package->cl-source-package sbcl-yason))
+(define-public cl-claw-utils
+ (sbcl-package->cl-source-package sbcl-claw-utils))
-(define-public ecl-yason
- (sbcl-package->ecl-package sbcl-yason))
+(define-public ecl-claw-utils
+ (sbcl-package->ecl-package sbcl-claw-utils))
-(define-public sbcl-graph
- (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
- (revision "0"))
+(define-public sbcl-clawk
+ (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6"))
(package
- (name "sbcl-graph")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-clawk")
+ (version (git-version "4" "1" commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/eschulte/graph";)
- (commit commit)))
+ (uri (git-reference
+ (url "https://github.com/sharplispers/clawk";)
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))))
+ (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-stefil))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-heap" ,sbcl-cl-heap)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)
- ("yason" ,sbcl-yason)))
- (arguments
- '(#:asd-systems '("graph"
- "graph/dot"
- "graph/json")))
- (synopsis "Graph data structure and algorithms for Common Lisp")
+ (list sbcl-regex))
+ (home-page "https://github.com/sharplispers/clawk";)
+ (synopsis "Common Lisp AWK")
(description
- "The GRAPH Common Lisp library provides a data structures to represent
-graphs, as well as some graph manipulation and analysis algorithms (shortest
-path, maximum flow, minimum spanning tree, etc.).")
- (home-page "https://eschulte.github.io/graph/";)
- (license license:gpl3+))))
+ "CLAWK is an AWK implementation embedded into Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-graph
- (sbcl-package->cl-source-package sbcl-graph))
+(define-public cl-clawk
+ (sbcl-package->cl-source-package sbcl-clawk))
-(define-public ecl-graph
- (sbcl-package->ecl-package sbcl-graph))
+(define-public ecl-clawk
+ (sbcl-package->ecl-package sbcl-clawk))
-(define-public sbcl-trivial-indent
- (let ((commit "f25275094b80df8aa158af46db980bbc3ce2f88b")
- (revision "1"))
+(define-public sbcl-clesh
+ (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11"))
(package
- (name "sbcl-trivial-indent")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-clesh")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/trivial-indent";)
- (commit commit)))
- (file-name (git-file-name "cl-trivial-indent" version))
+ (uri (git-reference
+ (url "https://github.com/Neronus/Clesh";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1zg8cyy1xqpcjrxxqz5zb5xixhwcszkv4p2vq305lb2rka6f3dyx"))))
+ (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318"))))
(build-system asdf-build-system/sbcl)
- (synopsis
- "Simple Common Lisp library to allow indentation hints for SWANK")
+ (inputs
+ (list sbcl-trivial-shell sbcl-named-readtables))
+ (home-page "https://github.com/Neronus/Clesh";)
+ (synopsis "Embed shell code in Common Lisp")
(description
- "This library allows you to define custom indentation hints for your
-macros if the one recognised by SLIME automatically produces unwanted
-results.")
- (home-page "https://shinmera.github.io/trivial-indent/";)
- (license license:zlib))))
+ "This is a very short and simple program, written in Common Lisp, that
+extends Common Lisp to embed shell code in a manner similar to Perl's
+backtick. It has been forked from SHELISP.")
+ (license license:bsd-2))))
-(define-public cl-trivial-indent
- (sbcl-package->cl-source-package sbcl-trivial-indent))
+(define-public cl-clesh
+ (sbcl-package->cl-source-package sbcl-clesh))
-(define-public ecl-trivial-indent
- (sbcl-package->ecl-package sbcl-trivial-indent))
+(define-public ecl-clesh
+ (sbcl-package->ecl-package sbcl-clesh))
-(define-public sbcl-data-format-validation
- (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb")
+(define-public sbcl-clinenoise
+ (let ((commit "46e21f99d06a55d93eaa382cf652d55d457032ef")
(revision "1"))
(package
- (name "sbcl-data-format-validation")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-clinenoise")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/willijar/cl-data-format-validation/";)
- (commit commit)))
- (file-name (git-file-name "data-format-validation" version))
+ (uri (git-reference
+ (url "https://github.com/jasom/clinenoise";)
+ (commit commit)))
+ (file-name (git-file-name "clinenoise" version))
(sha256
- (base32
- "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa"))))
+ (base32 "0ydlirfk4dbpqqjwwph99v5swcrhd8v9g8q24fvs35wn2vm08lh1"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-ppcre))
- (synopsis "Validation and conversion between user and internal data")
+ (list sbcl-alexandria sbcl-cffi sbcl-split-sequence))
+ (home-page "https://github.com/jasom/clinenoise";)
+ (synopsis "Port of linenoise to Common Lisp")
(description
- "@code{data-format-validation} is a library for Common Lisp providing a
-consistent regular interface for converting (and validating) external data (in
-the form of strings usually) into internal data types and for formatting
-internal data back into external presentable strings, all according to a
-conversion or type specification.")
- (home-page "http://www.jarw.org.uk/lisp/cl-data-format-validation.html";)
- (license license:gpl3))))
+ "This package provides a trivial line-input library for VT-like
+terminals.")
+ (license license:bsd-2))))
-(define-public sbcl-cl-docutils
- (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40")
- (revision "1"))
+(define-public cl-clinenoise
+ (sbcl-package->cl-source-package sbcl-clinenoise))
+
+(define-public ecl-clinenoise
+ (sbcl-package->ecl-package sbcl-clinenoise))
+
+(define-public sbcl-clingon
+ (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d")
+ (revision "0"))
(package
- (name "sbcl-cl-docutils")
- (version (git-version "0.1.1" revision commit))
+ (name "sbcl-clingon")
+ (version (git-version "0.5.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/willijar/cl-docutils/";)
- (commit commit)))
- (file-name (git-file-name "cl-docutils" version))
- (sha256
- (base32
- "132bxlj0jlhiabi29mygmkcbbgyb5s1yz1xdfhm3pgrf9f8605gg"))))
+ (uri (git-reference
+ (url "https://github.com/dnaeon/clingon";)
+ (commit commit)))
+ (file-name (git-file-name "cl-clingon" version))
+ (sha256
+ (base32 "11p9lplx0fc5ghx601i150vrd46zdbvw0hfrbrrrdqplxaqpywq5"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("docutils")))
+ (native-inputs
+ (list sbcl-rove))
(inputs
- (list sbcl-cl-ppcre
- sbcl-data-format-validation
- sbcl-trivial-gray-streams))
- (synopsis "Document utilities and Restructured text parser")
+ (list sbcl-bobbin
+ sbcl-cl-reexport
+ sbcl-split-sequence
+ sbcl-with-user-abort))
+ (home-page "https://github.com/dnaeon/clingon";)
+ (synopsis "Command-line option parsing library for Common Lisp")
(description
- "@code{cl-docutils} is a Common Lisp implementation of the Docutils text
-processing system for processing plaintext into presentational formats such as
-HTML and LaTeX. It is based upon the Python Docutils reference implementation
-but uses Common Lisp idioms making it easier to extend and more flexible. As
-with the reference implementation it includes a parser for the reStructured
-text plaintext markup syntax which is suitable for marking up documentation
-and for use as user markup for collaborative web sites. It is successfully
-used to support a higher education peer-review assessment and online tutorial
-system.")
- (home-page "http://www.jarw.org.uk/lisp/cl-docutils.html";)
- (license license:gpl3))))
+ "@code{clingon} is a command-line option parsing library for Common
+Lisp. Its features include:
+@itemize
+@item Support for subcommands
+@item Support for command aliases
+@item Support for short and long options
+@item Related options may be grouped into categories
+@item Short options may be collapsed into a single argument, as in
+@option{-xyz}
+@item Long options support the notations @option{--long-opt arg} and
+@option{--long-opt=arg}
+@item Automatic generation of help/usage information for commands and
+subcommands
+@item Out-of-the-box support for @option{--version} and @option{--help}
+@item Support for various kinds of options including string, integer,
+boolean, switch, enum, list, counter, filepath, etc.
+@item Subcommands can look up global options defined in parent commands
+@item Support for required options
+@item Options can be initialized via environment variables
+@item Single interface for creating options using @code{CLINGON:MAKE-OPTION}
+@item Generate documentation for your command-line application
+@item Support for @code{pre-hook} and @code{post-hook} actions for commands,
+which allow invoking functions before and after the respective handler of the
+command is executed
+@item Support for Bash and Zsh completions
+@item Extensibility, so if you don't find something you need you can extend it
+by developing a new option kind, or even a new mechanism for initializing
+options, e.g., by looking up an external key/value store
+@end itemize")
+ (license license:bsd-2))))
-(define-public cl-docutils
- (sbcl-package->cl-source-package sbcl-cl-docutils))
+(define-public cl-clingon
+ (sbcl-package->cl-source-package sbcl-clingon))
-(define-public ecl-cl-docutils
- (sbcl-package->ecl-package sbcl-cl-docutils))
+(define-public ecl-clingon
+ (sbcl-package->ecl-package sbcl-clingon))
-(define-public sbcl-documentation-utils
- (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
- (revision "0"))
+(define-public sbcl-clip
+ (let ((commit "7afa68702fbb99c47ed115ea0faccd97a29d9b2e")
+ (revision "1"))
(package
- (name "sbcl-documentation-utils")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-clip")
+ (version (git-version "0.7.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/documentation-utils";)
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri (git-reference
+ (url "https://github.com/shinmera/clip";)
+ (commit commit)))
+ (file-name (git-file-name "clip" version))
(sha256
- (base32
- "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
+ (base32 "13kkajkva2shm19fvn4yashsw18l6imv2rmy3hmpcky7g5ay7bv3"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-trivial-indent))
- (synopsis "Few simple tools to document Common Lisp libraries")
+ (list sbcl-array-utils sbcl-lquery))
+ (home-page "https://shinmera.github.io/clip/";)
+ (synopsis "Common Lisp HTML templating engine")
(description
- "This is a small library to help you with managing the Common Lisp
-docstrings for your library.")
- (home-page "https://shinmera.github.io/documentation-utils/";)
+ "Clip is an attempt at a templating library that allows you to write
+templates in a way that is both accessible to direct webdesign and
+flexible. The main idea is to incorporate transformation commands into an HTML
+file through tags and attributes. Clip is heavily dependent on Plump and
+lQuery.")
(license license:zlib))))
-(define-public cl-documentation-utils
- (sbcl-package->cl-source-package sbcl-documentation-utils))
+(define-public cl-clip
+ (sbcl-package->cl-source-package sbcl-clip))
-(define-public ecl-documentation-utils
- (sbcl-package->ecl-package sbcl-documentation-utils))
+(define-public ecl-clip
+ (sbcl-package->ecl-package sbcl-clip))
-(define-public sbcl-documentation-utils-extensions
- (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750"))
+(define-public sbcl-clml
+ (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8")
+ (revision "0"))
(package
- (name "sbcl-documentation-utils-extensions")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-clml")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url
"https://github.com/sirherrbatka/documentation-utils-extensions/";)
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri (git-reference
+ (url "https://github.com/mmaul/clml";)
+ (commit commit)))
+ (file-name (git-file-name "clml" version))
(sha256
- (base32
- "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f"))))
+ (base32 "006pii59nmpc61n7p7h8ha5vjg6x0dya327i58z0rnvxs249h345"))
+ ;; TODO: Remove this when the patch has been merged upstream.
+ (patches (search-patches "sbcl-clml-fix-types.patch"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-documentation-utils))
- (home-page
"https://github.com/sirherrbatka/documentation-utils-extensions";)
- (synopsis "Set of extensions for documentation-utils")
+ (list sbcl-alexandria
+ sbcl-array-operations
+ sbcl-cl-fad
+ sbcl-cl-ppcre
+ sbcl-drakma
+ sbcl-introspect-environment
+ sbcl-iterate
+ sbcl-lparallel
+ sbcl-parse-number
+ sbcl-split-sequence
+ sbcl-trivial-garbage))
+ (synopsis "Common Lisp machine learning library")
(description
- "Use @code{rich-formatter} to format documentation with sections
@code{:syntax},
-@code{:arguments}, @code{:examples}, @code{:description}, @code{:returns},
-@code{:side-effects}, @code{:thread-safety}, @code{:affected-by},
-@code{:see-also} and @code{:notes}. Gather unformatted input by using
-@code{rich-aggregating-formatter} and @code{*DOCUMENTATION*} variable. Find
-gathered documentation with find-documentation function. Execute code stored
-in documentation with @code{execute-documentation}. See the examples in the
-@code{src/documentation.lisp} file. See the @code{documentation-utils} system
-for more information.")
- (license license:expat))))
+ "CLML (Common Lisp Machine Learning) is a high performance and large
+scale statistical machine learning package")
+ (home-page "https://mmaul.github.io/clml/";)
+ (license license:llgpl))))
-(define-public cl-documentation-utils-extensions
- (sbcl-package->cl-source-package sbcl-documentation-utils-extensions))
+(define-public cl-clml
+ (sbcl-package->cl-source-package sbcl-clml))
-(define-public ecl-documentation-utils-extensions
- (sbcl-package->ecl-package sbcl-documentation-utils-extensions))
+(define-public sbcl-clobber
+ (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98")
+ (revision "0"))
+ (package
+ (name "sbcl-clobber")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/Clobber";)
+ (commit commit)))
+ (file-name (git-file-name "cl-clobber" version))
+ (sha256
+ (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/Clobber";)
+ (synopsis "Common Lisp Library for transaction-oriented databases")
+ (description
+ "CLOBBER is an alternative to so-called @emph{object prevalence}, and in
+particular to @code{cl-prevalence}. Clobber is both simpler, more flexible,
and
+more robust than systems based on object prevalence.")
+ (license license:bsd-2))))
-(define-public sbcl-charje.documentation
+(define-public cl-clobber
+ (sbcl-package->cl-source-package sbcl-clobber))
+
+(define-public ecl-clobber
+ (sbcl-package->ecl-package sbcl-clobber))
+
+(define-public sbcl-clog
(package
- (name "sbcl-charje.documentation")
- (version "0.0.0")
+ (name "sbcl-clog")
+ (version "1.2")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.sr.ht/~charje/documentation";)
+ (url "https://github.com/rabbibotton/clog";)
(commit (string-append "v" version))))
+ (file-name (git-file-name "cl-clog" version))
(sha256
- (base32
- "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc"))
- (file-name (git-file-name "cl-charje.documentation" version))))
+ (base32 "0f4i6571nm0j704zgnh60sc9slifs11byb2gs8gamqjcfh931dap"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (home-page "https://git.sr.ht/~charje/documentation";)
- (synopsis "Docstring parsing library for Common Lisp")
- (description "Charje.documentation can used to parse Common Lisp
-docstrings the charje way, or it can be used to create custom docstring
-parsers. Docstring parsers are composed using mixin classes and
-initialization methods.")
- (license license:agpl3+)))
+ (list sbcl-3bmd
+ sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cl-ppcre
+ sbcl-cl-sqlite
+ sbcl-cl-template
+ sbcl-clack
+ sbcl-closer-mop
+ sbcl-colorize
+ sbcl-dbi
+ sbcl-hunchentoot
+ sbcl-lack
+ sbcl-mgl-pax
+ sbcl-parse-float
+ sbcl-quri
+ sbcl-trivial-open-browser
+ sbcl-websocket-driver))
+ (arguments
+ '(#:asd-systems '("clog" "clog/docs" "clog/tools")
+ #:phases (modify-phases %standard-phases
+ (add-after 'unpack 'fix-symbol-name
+ (lambda _
+ (substitute* "source/clog-docs.lisp"
+ (("clog:@CLOG-MANUAL")
+ "clog::@CLOG_MANUAL")))))))
+ (home-page "https://github.com/rabbibotton/clog";)
+ (synopsis "Common Lisp Omnificent GUI")
+ (description
+ "This package provides a Common Lisp web framework for building GUI
+applications. CLOG can take the place, or work along side, most cross platform
+GUI frameworks and website frameworks. The CLOG package starts up the
+connectivity to the browser or other websocket client (often a browser embedded
+in a native template application).")
+ (license license:bsd-3)))
-(define-public cl-charje.documentation
- (sbcl-package->cl-source-package sbcl-charje.documentation))
+(define-public cl-clog
+ (sbcl-package->cl-source-package sbcl-clog))
-(define-public ecl-charje.documentation
- (sbcl-package->ecl-package sbcl-charje.documentation))
+(define-public ecl-clog
+ (sbcl-package->ecl-package sbcl-clog))
-(define-public sbcl-staple
- (let ((commit "0ee8e25fe6fe8fa83b2a6c93d4febd468c3eaa4e")
- (revision "1"))
+(define-public sbcl-clop
+ (let ((commit "c0c3fe7efa5ac95ba1644febfb2c2acab757fcda")
+ (revision "0"))
(package
- (name "sbcl-staple")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-clop")
+ ;; ASD file indicates 0.1.0, but changelog 1.0.1.
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/staple/";)
+ (url "https://github.com/sheepduke/clop";)
(commit commit)))
+ (file-name (git-file-name "cl-clop" version))
(sha256
- (base32 "0qf0if7py3n4rszg25lcavpsqikfz6k5dvcmh5q67y8x5r12i5m7"))
- (file-name (git-file-name "staple" version))))
+ (base32 "1q7rlizr8gcbfz4a9660gdbw7d2zbld18akjpibg54j7jh5kb8gc"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("staple-package-recording"
- "staple-code-parser"
- "staple"
- "staple-markdown"
- "staple-markless"
- "staple-restructured-text")))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-3bmd
- sbcl-babel
- sbcl-cl-docutils
- sbcl-cl-markless
- sbcl-cl-ppcre
- sbcl-clip
- sbcl-concrete-syntax-tree
- sbcl-definitions
- sbcl-documentation-utils
- sbcl-eclector
- sbcl-language-codes
- sbcl-pathname-utils))
- (synopsis "Generate documentation about Lisp projects through an HTML
template")
- (description "Staple is a documentation system. It provides you with a
-way to generate standalone documentation accumulated from various sources such
-as readmes, documentation files, and docstrings.")
- (home-page "https://Shinmera.github.io/staple/";)
- (license license:zlib))))
+ (list sbcl-alexandria
+ sbcl-cl-str
+ sbcl-esrap
+ sbcl-local-time
+ sbcl-parse-number))
+ (home-page "https://github.com/sheepduke/clop";)
+ (synopsis "TOML parser for Common Lisp")
+ (description
+ "Clop is a Common Lisp library for parsing strings in the TOML
+configuration file format.")
+ (license license:expat))))
-(define-public cl-staple
- (sbcl-package->cl-source-package sbcl-staple))
+(define-public cl-clop
+ (sbcl-package->cl-source-package sbcl-clop))
-(define-public ecl-staple
- (sbcl-package->ecl-package sbcl-staple))
+(define-public ecl-clop
+ (sbcl-package->ecl-package sbcl-clop))
-(define-public sbcl-helambdap
- (let ((commit "5bf65f57a36ee094cadb096caca6e90eb3ba46c4")
- (revision "0"))
+(define-public sbcl-closer-mop
+ (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc")
+ (revision "3"))
(package
- (name "sbcl-helambdap")
- (version (git-version "20220103" revision commit))
+ (name "sbcl-closer-mop")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.code.sf.net/p/helambdap/code";)
+ (url "https://github.com/pcostanza/closer-mop";)
(commit commit)))
- (file-name (git-file-name "cl-helambdap" version))
(sha256
- (base32 "1kzapbf9l2bw8i9m9sxv0dfnkksrxq81d5hbn34pm25abk0i937j"))))
+ (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16"))
+ (file-name (git-file-name "cl-closer-mop" version ))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-fad
- sbcl-clad
- sbcl-split-sequence
- sbcl-xhtmlambda))
- (synopsis "Common Lisp documentation system")
- (description "HELambdap is a Common Lisp documentation system which
-strives to be simple to use, yet easily customizable.")
- (home-page "https://helambdap.sourceforge.net";)
+ (home-page "https://github.com/pcostanza/closer-mop";)
+ (synopsis "Rectifies absent or incorrect CLOS MOP features")
+ (description "Closer to MOP is a compatibility layer that rectifies many
+of the absent or incorrect CLOS MOP features across a broad range of Common
+Lisp implementations.")
(license license:expat))))
-(define-public cl-helambdap
- (sbcl-package->cl-source-package sbcl-helambdap))
-
-(define-public sbcl-form-fiddle
- (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
- (revision "0"))
- (package
- (name "sbcl-form-fiddle")
- (version (git-version "1.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/form-fiddle";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-documentation-utils))
- (synopsis "Utilities to destructure Common Lisp lambda forms")
- (description
- "Often times we need to destructure a form definition in a Common Lisp
-macro. This library provides a set of simple utilities to help with that.")
- (home-page "https://shinmera.github.io/form-fiddle/";)
- (license license:zlib))))
-
-(define-public cl-form-fiddle
- (sbcl-package->cl-source-package sbcl-form-fiddle))
+(define-public cl-closer-mop
+ (sbcl-package->cl-source-package sbcl-closer-mop))
-(define-public ecl-form-fiddle
- (sbcl-package->ecl-package sbcl-form-fiddle))
+(define-public ecl-closer-mop
+ (sbcl-package->ecl-package sbcl-closer-mop))
-(define-public sbcl-array-utils
- (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834")
+(define-public sbcl-clostrum
+ (let ((commit "c85d38bde9d093f1f132574e9b98b8d64683cd51")
(revision "0"))
(package
- (name "sbcl-array-utils")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-clostrum")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/array-utils";)
- (commit commit)))
- (file-name (git-file-name "cl-array-utils" version))
+ (uri (git-reference
+ (url "https://github.com/s-expressionists/Clostrum";)
+ (commit commit)))
+ (file-name (git-file-name "cl-clostrum" commit))
(sha256
- (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az"))))
+ (base32 "10alsdnpzbgic75xghwjp414sqwg4npvp69zn0r4l8ms0ki9zr1x"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-documentation-utils))
- (synopsis "Tiny collection of array and vector utilities for Common
Lisp")
+ (native-inputs (list sbcl-fiveam))
+ (home-page "https://github.com/s-expressionists/Clostrum";)
+ (synopsis "First Class Global Environments")
(description
- "A miniature toolkit that contains some useful shifting/popping/pushing
-functions for arrays and vectors. Originally from Plump.")
- (home-page "https://shinmera.github.io/array-utils/";)
- (license license:zlib))))
+ "This package provides first-class global environments for
+Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-array-utils
- (sbcl-package->cl-source-package sbcl-array-utils))
+(define-public cl-clostrum
+ (sbcl-package->cl-source-package sbcl-clostrum))
-(define-public ecl-array-utils
- (sbcl-package->ecl-package sbcl-array-utils))
+(define-public ecl-clostrum
+ (sbcl-package->ecl-package sbcl-clostrum))
-(define-public sbcl-lass
- (let ((commit "1f2418dbf2d8d6f5892171057616b2ca9d6e5008")
+(define sbcl-closure-common
+ (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
(revision "1"))
(package
- (name "sbcl-lass")
- (version (git-version "0.6.0" revision commit))
+ (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/Shinmera/LASS";)
- (commit commit)))
- (file-name (git-file-name "cl-lass" version))
+ (uri (git-reference
+ (url "https://github.com/sharplispers/closure-common";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1wax2kykc9ff0sk2linp9v8fcsm5ay6idpq365vivady9fh504r5"))))
- (build-system asdf-build-system/sbcl)
+ (base32
+ "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
(inputs
- (list sbcl-cl-base64 sbcl-trivial-indent sbcl-trivial-mimes))
- (synopsis "LASS (Lisp Augmented Style Sheets) compiles Lisp to CSS")
- (description
- "With lispy syntax, shortcuts, and improvements, LASS aims to help you
-out in writing CSS quick and easy. LASS was largely inspired by SASS. LASS
-supports two modes, one being directly in your lisp code, the other in pure
-LASS files.")
- (home-page "https://shinmera.github.io/LASS/";)
- (license license:zlib))))
-
-(define-public cl-lass
- (sbcl-package->cl-source-package sbcl-lass))
-
-(define-public ecl-lass
- (sbcl-package->ecl-package sbcl-lass))
+ `(("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-xhtmlambda
- (let ((commit "c86376bccebf77ca428e8033df2ba7d8450ea1e8")
+(define-public sbcl-closure-template
+ ;; There are no releases since 2015.
+ (let ((commit "f1983aa525045691e128027d2a2d74831c873d6e")
(revision "0"))
(package
- (name "sbcl-xhtmlambda")
- (version
- ;; The source repository doesn't provide any version nor revision, but
- ;; a timestamp
- (git-version "2022-01-21" revision commit))
+ (name "sbcl-closure-template")
+ (version (git-version "0.2.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/xhtmlambda/XHTMLambda";)
+ (url "https://github.com/archimag/cl-closure-template";)
(commit commit)))
- (file-name (git-file-name "cl-xhtmlambda" version))
+ (file-name (git-file-name "cl-closure-template" version))
(sha256
- (base32 "0narbzz06ry1wn048avm1fwihvnjvvc4wfcv5hmdazkilpvnqz2y"))))
+ (base32 "16h0fs6bjjd4n9pbkwcprpgyj26vsw2akk3q08m7xmsmqi05dppv"))))
(build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cl-unicode))
- (synopsis "(X)HTML library for Common Lisp")
+ (native-inputs (list sbcl-lift))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-closer-mop
+ sbcl-esrap
+ sbcl-iterate
+ sbcl-parse-number
+ sbcl-split-sequence))
+ (synopsis "Lisp implementation of Google Closure Templates")
(description
- "(X)HTMLambda is yet another (X)HTML library which
-emphasizes programmability and user-friendliness. Each (X)HTML element is a
-structured object and pretty-printing of (X)HTML trees is well defined to
-provide properly indented human-readable output even for complex recursive
-arrangements.")
- (home-page "https://xhtmlambda.common-lisp.dev/";)
- (license license:expat))))
+ "This package provides a Common Lisp implementation of Google
+Closure Templates.")
+ (home-page "https://github.com/archimag/cl-closure-template/";)
+ (license license:llgpl))))
-(define-public cl-xhtmlambda
- (sbcl-package->cl-source-package sbcl-xhtmlambda))
+(define-public cl-closure-template
+ (sbcl-package->cl-source-package sbcl-closure-template))
-(define-public sbcl-clad
- (let ((commit "1ff6f417d4ee3836d1edd96923d4b03f3cafa849")
- (revision "0"))
- (package
- (name "sbcl-clad")
- (version
- ;; There's no version, but there's a timestamp
- (git-version "2023-01-21" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/mantoniotti/CLAD";)
- (commit commit)))
- (file-name (git-file-name "cl-clad" version))
- (sha256
- (base32 "184mhdq7pxd6hd4rzv8z4lfbwnkyhgm5bdn3xsqaav2j0d1dqm6i"))
- (modules '((guix build utils)))
- (snippet
- ;; Delete compiled ABCL files.
- '(begin
- (delete-file "clad-package.abcl")
- (delete-file "clad.abcl")))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Library providing standard locations on the file system")
- (description
- "The Common Lisp Application Directories (CLAD) library is
-a simple API collection that provides access to a set of @emph{standard}
-Common Lisp folders on a per-application or per-library basis.")
- (home-page "https://gitlab.common-lisp.net/mantoniotti/CLAD";)
- (license license:expat)))) ;the mit-modern-variant is used
+(define-public ecl-closure-template
+ (sbcl-package->ecl-package sbcl-closure-template))
-(define-public cl-clad
- (sbcl-package->cl-source-package sbcl-clad))
+(define-public sbcl-clsql
+ (package
+ (name "sbcl-clsql")
+ (version "6.7.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "http://git.kpe.io/clsql.git";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; The useless bundled debian folder drags `make' into the closure.
+ (delete-file-recursively "debian")
+ ;; Other Makefiles that drag `make'.
+ (for-each delete-file
+ '("Makefile"
+ "db-db2/Makefile"
+ "db-mysql/Makefile"
+ "db-odbc/Makefile"
+ "db-oracle/Makefile"
+ "db-sqlite/Makefile"
+ "doc/Makefile"
+ "examples/sqlite3/init-func/Makefile"
+ "sql/Makefile"
+ "tests/Makefile"
+ "uffi/Makefile"
+ "uffi/Makefile.32+64bits"))
+ ;; Remove precompiled libraries.
+ (delete-file "db-mysql/clsql_mysql.dll")
+ (delete-file "uffi/clsql_uffi.dll")
+ (delete-file "uffi/clsql_uffi.lib")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("rt" ,sbcl-rt)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("md5" ,sbcl-md5)
+ ("mariadb-dev" ,mariadb "dev")
+ ("mariadb-lib" ,mariadb "lib")
+ ("postgresql" ,postgresql)
+ ("postmodern" ,sbcl-postmodern)
+ ("sqlite" ,sqlite)
+ ("uffi" ,sbcl-uffi)
+ ("zlib" ,zlib)))
+ (arguments
+ `(#:asd-systems '("clsql"
+ "clsql-uffi"
+ "clsql-sqlite3"
+ "clsql-postgresql"
+ "clsql-postgresql-socket3"
+ "clsql-mysql")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-permissions
+ (lambda _
+ (make-file-writable "doc/html.tar.gz")
+ #t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "clsql-uffi.asd"
+ (("\\(:version uffi \"2.0\"\\)")
+ "uffi"))
+ (substitute* "db-postgresql/postgresql-api.lisp"
+ (("\\(data :cstring\\)")
+ "(data :string)"))
+ #t))
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (substitute* "db-sqlite3/sqlite3-loader.lisp"
+ (("libsqlite3")
+ (string-append (assoc-ref inputs "sqlite")
+ "/lib/libsqlite3")))
+ (substitute* "db-postgresql/postgresql-loader.lisp"
+ (("libpq")
+ (string-append (assoc-ref inputs "postgresql")
+ "/lib/libpq")))
+ (let ((lib (string-append "#p\""
+ (assoc-ref outputs "out")
+ "/lib/\"")))
+ (substitute* "clsql-mysql.asd"
+ (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
+ lib))
+ (substitute* "db-mysql/mysql-loader.lisp"
+ (("libmysqlclient" all)
+ (string-append (assoc-ref inputs "mariadb-lib") "/lib/" all))
+ (("clsql-mysql-system::\\*library-file-dir\\*")
+ lib)))
+ #t))
+ (add-before 'build 'build-helper-library
+ (lambda* (#:key inputs outputs #:allow-other-keys)
+ (let* ((mariadb-dev (assoc-ref inputs "mariadb-dev"))
+ (mariadb-lib (assoc-ref inputs "mariadb-lib"))
+ (inc-dir (string-append mariadb-dev "/include/mysql"))
+ (lib-dir (string-append mariadb-lib "/lib"))
+ (shared-lib-dir (string-append (assoc-ref outputs "out")
+ "/lib"))
+ (shared-lib (string-append shared-lib-dir
+ "/clsql_mysql.so")))
+ (mkdir-p shared-lib-dir)
+ (invoke "gcc" "-fPIC" "-shared"
+ "-I" inc-dir
+ "db-mysql/clsql_mysql.c"
+ "-Wl,-soname=clsql_mysql"
+ "-L" lib-dir "-lmariadb" "-lz"
+ "-o" shared-lib)
+ #t)))
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "clsql.asd"
+ (("clsql-tests :force t")
+ "clsql-tests"))
+ #t)))))
+ (synopsis "Common Lisp SQL Interface library")
+ (description
+ "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
+Xanalys CommonSQL interface for Lispworks. It provides low-level database
+interfaces as well as a functional and an object oriented interface.")
+ (home-page "https://clsql.kpe.io/";)
+ (license license:llgpl)))
-(define-public sbcl-plump
- (let ((commit "0c3e0b57b43b6e0c5794b6a902f1cf5bee2a2927")
- (revision "3"))
+(define-public cl-clsql
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-clsql))
+ (native-inputs
+ `(("rt" ,cl-rt)))
+ (inputs
+ (list (list mariadb "dev") postgresql sqlite zlib))
+ (propagated-inputs
+ `(("cffi" ,cl-cffi)
+ ("md5" ,cl-md5)
+ ("postmodern" ,cl-postmodern)
+ ("uffi" ,cl-uffi)))
+ (arguments
+ `(#:phases
+ ;; asdf-build-system/source has its own phases and does not inherit
+ ;; from asdf-build-system/sbcl phases.
+ (modify-phases %standard-phases/source
+ (add-after 'unpack 'fix-permissions
+ (lambda _
+ (make-file-writable "doc/html.tar.gz")
+ #t)))))))
+
+(define-public ecl-clsql
+ (let ((pkg (sbcl-package->ecl-package sbcl-clsql)))
(package
- (name "sbcl-plump")
- (version (git-version "2.0.0" revision commit))
+ (inherit pkg)
+ (inputs
+ (alist-delete "uffi" (package-inputs pkg)))
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:asd-systems asd-systems '())
+ `(cons "clsql-cffi" ,asd-systems)))))))
+
+(define-public sbcl-clss
+ (let ((revision "2")
+ (commit "f62b849189c5d1be378f0bd3d403cda8d4fe310b"))
+ (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/plump";)
+ (url "https://github.com/Shinmera/clss";)
(commit commit)))
- (file-name (git-file-name "cl-plump" version))
(sha256
- (base32 "1fyb66pqvr1iy31ah9638ihs8cax17zkxk0zq14jy7x5l9rq1qlf"))))
- (build-system asdf-build-system/sbcl)
+ (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv"))
+ (file-name (git-file-name name version))))
(inputs
- (list sbcl-array-utils sbcl-documentation-utils))
- (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
- (description
- "Plump is a parser for HTML/XML-like documents, focusing on being
-lenient towards invalid markup. It can handle things like invalid attributes,
-bad closing tag order, unencoded entities, inexistent tag types, self-closing
-tags and so on. It parses documents to a class representation and offers a
-small set of DOM functions to manipulate it. It can be extended to parse to
-your own classes.")
- (home-page "https://shinmera.github.io/plump/";)
+ (list sbcl-array-utils 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-plump
- (sbcl-package->cl-source-package sbcl-plump))
+(define-public cl-clss
+ (sbcl-package->cl-source-package sbcl-clss))
-(define-public ecl-plump
- (sbcl-package->ecl-package sbcl-plump))
+(define-public ecl-clss
+ (sbcl-package->ecl-package sbcl-clss))
-(define-public sbcl-plump-sexp
- (let ((commit "bbcf75e9ecda8fe7603098ab8c15828407bb4f08")
- (revision "0"))
+(define-public sbcl-cluffer
+ (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
(package
- (name "sbcl-plump-sexp")
- (version (git-version "0.1.0" revision commit))
- (source
+ (name "sbcl-cluffer")
+ (version (git-version "0.0.0" "1" commit))
+ (source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/plump-sexp";)
- (commit commit)))
- (file-name (git-file-name "cl-plump-sexp" version))
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/cluffer";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
(base32
- "0zm9h0assjb8766z2v6l1k1s60y90y6f8smrl1dczwqlvc8xyln5"))))
+ "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-plump))
- (synopsis "Convert S-expressions into a Plump DOM and back")
- (description
- "The Plump-SEXP library is a backend for Plump which can convert
-between S-expressions and the Plump DOM.")
- (home-page "https://github.com/Shinmera/plump-sexp";)
- (license license:zlib))))
+ (list sbcl-acclimation sbcl-clump))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'install 'unpatch-shebangs
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; The documentation Makefile rely on shell scripts.
+ ;; TODO: Build it!
+ ;; In the mean time, remove the shabang as it adds bash to the
+ ;; closure.
+ (let* ((out (assoc-ref outputs "out"))
+ (build-aux (string-append
+ out "/share/")))
+ (substitute* (find-files build-aux)
+ (("^#!.*/bin/sh") "#!/bin/sh")
+ (("^#!.*/bin/bash") "#!/bin/bash"))))))))
+ (home-page "https://github.com/robert-strandh/cluffer";)
+ (synopsis "Common Lisp library providing a protocol for text-editor
buffers")
+ (description "Cluffer is a library for representing the buffer of a text
+editor. As such, it defines a set of CLOS protocols for client code to
+interact with the buffer contents in various ways, and it supplies different
+implementations of those protocols for different purposes.")
+ (license license:bsd-2))))
-(define-public cl-plump-sexp
- (sbcl-package->cl-source-package sbcl-plump-sexp))
+(define-public cl-cluffer
+ (sbcl-package->cl-source-package sbcl-cluffer))
-(define-public ecl-plump-sexp
- (sbcl-package->ecl-package sbcl-plump-sexp))
+(define-public ecl-cluffer
+ (sbcl-package->ecl-package sbcl-cluffer))
-;;; Split the antik package in two to work around the circular dependency
-;;; between antik/antik and antik/gsll.
-(define-public sbcl-antik-base
- (let ((commit "e4711a69b3d6bf37b5727af05c3cfd03e8428ba3")
- (revision "1"))
+(define-public sbcl-clump
+ (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
(package
- (name "sbcl-antik-base")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-clump")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/antik/antik.git";)
+ (url "https://github.com/robert-strandh/Clump";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
- (build-system asdf-build-system/sbcl)
+ "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("drakma" ,sbcl-drakma)
- ("fare-utils" ,sbcl-fare-utils)
- ("iterate" ,sbcl-iterate)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("named-readtables" ,sbcl-named-readtables)
- ("split-sequence" ,sbcl-split-sequence)
- ("static-vectors" ,sbcl-static-vectors)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("trivial-utf-8" ,sbcl-trivial-utf-8)))
- (native-inputs
- (list sbcl-lisp-unit))
- (arguments
- '(#:asd-systems '("antik-base"
- "foreign-array")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (for-each delete-file
- '("antik.asd"
- "physical-dimension.asd"
- "science-data.asd"))
- #t)))))
- (synopsis "Scientific and engineering computation in Common Lisp")
- (description
- "Antik provides a foundation for scientific and engineering
-computation in Common Lisp. It is designed not only to facilitate
-numerical computations, but to permit the use of numerical computation
-libraries and the interchange of data and procedures, whether
-foreign (non-Lisp) or Lisp libraries. It is named after the
-Antikythera mechanism, one of the oldest examples of a scientific
-computer known.")
- (home-page "https://common-lisp.net/project/antik/";)
- (license license:gpl3))))
+ (list sbcl-acclimation))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/Clump";)
+ (synopsis "Collection of tree implementations for Common Lisp")
+ (description "The purpose of this library is to provide a collection of
+implementations of trees.
-(define-public cl-antik-base
- (sbcl-package->cl-source-package sbcl-antik-base))
+In contrast to existing libraries such as cl-containers, it does not impose a
+particular use for the trees. Instead, it aims for a stratified design,
+allowing client code to choose between different levels of abstraction.
-(define-public ecl-antik-base
- (let ((pkg (sbcl-package->ecl-package sbcl-antik-base)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-readtable
- (lambda _
- (substitute* "input-output/readtable.lisp"
- (("#-ccl")
- "#-(or ccl ecl)"))
- #t)))))))))
+As a consequence of this policy, low-level interfaces are provided where
+the concrete representation is exposed, but also high level interfaces
+where the trees can be used as search trees or as trees that represent
+sequences of objects.")
+ (license license:bsd-2))))
-(define-public sbcl-gsll
- (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
- (revision "1"))
+(define-public cl-clump
+ (sbcl-package->cl-source-package sbcl-clump))
+
+(define-public ecl-clump
+ (sbcl-package->ecl-package sbcl-clump))
+
+(define-public sbcl-cluster
+ (let ((commit "b040e97578f3027d7d8c7652c74917726574c43e")
+ (revision "0"))
(package
- (name "sbcl-gsll")
+ (name "sbcl-cluster")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/antik/gsll.git";)
+ (url "https://github.com/robert-strandh/Cluster";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-cluster" commit))
(sha256
- (base32
- "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
+ (base32 "0ixbr3wm7d3m8mgzasd95rxvs9kip6ngr5s1zk7j3604mcfssqyi"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("antik-base" ,sbcl-antik-base)
- ("cffi" ,sbcl-cffi)
- ("gsl" ,gsl)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("trivial-features" ,sbcl-trivial-features)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (arguments
- `(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-cffi-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gsll.asd"
- ((":depends-on \\(#:foreign-array")
- ":depends-on (#:foreign-array #:cffi-libffi"))
- (substitute* "init/init.lisp"
- (("libgslcblas.so" all)
- (string-append
- (assoc-ref inputs "gsl") "/lib/" all)))
- (substitute* "init/init.lisp"
- (("libgsl.so" all)
- (string-append
- (assoc-ref inputs "gsl") "/lib/" all))))))))
- (synopsis "GNU Scientific Library for Lisp")
+ (list sbcl-acclimation
+ sbcl-split-sequence))
+ (home-page "https://github.com/robert-strandh/Cluster";)
+ (synopsis "Assembler with input in the form of standard instances")
(description
- "The GNU Scientific Library for Lisp (GSLL) allows the use of the
-GNU Scientific Library (GSL) from Common Lisp. This library provides a
-full range of common mathematical operations useful to scientific and
-engineering applications. The design of the GSLL interface is such
-that access to most of the GSL library is possible in a Lisp-natural
-way; the intent is that the user not be hampered by the restrictions
-of the C language in which GSL has been written. GSLL thus provides
-interactive use of GSL for getting quick answers, even for someone not
-intending to program in Lisp.")
- (home-page "https://common-lisp.net/project/gsll/";)
- (license license:gpl3))))
-
-(define-public cl-gsll
- (sbcl-package->cl-source-package sbcl-gsll))
-
-(define-public ecl-gsll
- (sbcl-package->ecl-package sbcl-gsll))
+ "Cluster is an assembler (initially for x86 and x86-64) with a
difference.
+To avoid the issue of defining a syntax, the input to Cluster is a list
+of standard objects (i.e., instances of the class STANDARD-OBJECT),
+as opposed to a character file or S-expressions.")
+ (license license:bsd-2))))
-(define-public sbcl-antik
- (package
- (inherit sbcl-antik-base)
- (name "sbcl-antik")
- (inputs
- `(("antik-base" ,sbcl-antik-base)
- ("gsll" ,sbcl-gsll)))
- (arguments
- '(#:asd-systems '("antik"
- "science-data")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (for-each delete-file
- '("antik-base.asd"
- "foreign-array.asd"))
- #t)))))))
+(define-public cl-cluster
+ (sbcl-package->cl-source-package sbcl-cluster))
-(define-public cl-antik
- (sbcl-package->cl-source-package sbcl-antik))
+(define-public ecl-cluster
+ (sbcl-package->ecl-package sbcl-cluster))
-(define-public sbcl-cl-interpol
- (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa")
+(define-public sbcl-clx
+ (let ((commit "38400456d66823e417d1d27d339b09885e25eb59")
(revision "1"))
(package
- (name "sbcl-cl-interpol")
- (version (git-version "0.2.7" revision commit))
+ (name "sbcl-clx")
+ (version (git-version "0.7.5" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/edicl/cl-interpol";)
- (commit commit)))
- (file-name (git-file-name "cl-interpol" version))
+ (uri
+ (git-reference
+ (url "https://github.com/sharplispers/clx";)
+ (commit commit)))
(sha256
- (base32
- "1kr00zf62m7la7rxa2m5w49r9cyzamc106hvjcc8ffmi7a4jw490"))))
+ (base32 "1c05gjqh5lil2sgma0yap4mxd9y1cjkp933hyx1iaj14950nhfnl"))
+ (file-name (git-file-name "cl-clx" version))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-unicode sbcl-named-readtables))
(native-inputs
- (list sbcl-flexi-streams))
- (synopsis "String interpolation for Common Lisp")
- (description
- "CL-INTERPOL is a library for Common Lisp which modifies the
-reader so that you can have interpolation within strings similar to
-Perl or Unix Shell scripts. It also provides various ways to insert
-arbitrary characters into literal strings even if your editor/IDE
-doesn't support them.")
- (home-page "https://edicl.github.io/cl-interpol/";)
- (license license:bsd-3))))
+ (list sbcl-fiasco xorg-server-for-tests))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-before 'check 'prepare-test-environment
+ (lambda _
+ (system "Xvfb :1 &")
+ (setenv "DISPLAY" ":1"))))))
+ (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
+make it compile and run under SBCL, then a selection of patches were added
+from other CLXes around the net.")
+ (license license:x11))))
-(define-public cl-interpol
- (sbcl-package->cl-source-package sbcl-cl-interpol))
+(define-public cl-clx
+ (sbcl-package->cl-source-package sbcl-clx))
-(define-public ecl-cl-interpol
- (sbcl-package->ecl-package sbcl-cl-interpol))
+(define-public ecl-clx
+ (sbcl-package->ecl-package sbcl-clx))
-(define-public sbcl-symbol-munger
- (let ((commit "e96558e8315b8eef3822be713354787b2348b25e")
- (revision "2"))
+(define-public sbcl-clx-truetype
+ (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
+ (revision "1"))
(package
- (name "sbcl-symbol-munger")
+ (name "sbcl-clx-truetype")
(version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/symbol-munger";)
+ (url "https://github.com/l04m33/clx-truetype";)
(commit commit)))
- (file-name (git-file-name "cl-symbol-munger" version))
+ (file-name (git-file-name name version))
(sha256
(base32
- "16fshnxp9212503z1vjlmx5pafv14bzpihn486x1ljakqjigfnfz"))))
+ "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ (substitute* "package.lisp"
+ ((":export") ":export\n :+font-cache-filename+"))
+ #t))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)))
- (arguments
- ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
- ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
- '(#:tests? #f))
- (synopsis
- "Capitalization and spacing conversion functions for Common Lisp")
- (description
- "This is a Common Lisp library to change the capitalization and spacing
-of a string or a symbol. It can convert to and from Lisp, english, underscore
-and camel-case rules.")
- (home-page "https://github.com/AccelerationNet/symbol-munger";)
- ;; The package declares a BSD license, but all of the license
- ;; text is MIT.
- ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
+ (list sbcl-clx
+ sbcl-zpb-ttf
+ sbcl-cl-vectors
+ sbcl-cl-fad
+ sbcl-cl-store
+ sbcl-trivial-features))
+ (home-page "https://github.com/l04m33/clx-truetype";)
+ (synopsis "Antialiased TrueType font rendering using CLX and XRender")
+ (description "CLX-TrueType is pure common lisp solution for
+antialiased TrueType font rendering using CLX and XRender extension.")
(license license:expat))))
-(define-public cl-symbol-munger
- (sbcl-package->cl-source-package sbcl-symbol-munger))
+(define-public cl-clx-truetype
+ (sbcl-package->cl-source-package sbcl-clx-truetype))
-(define-public ecl-symbol-munger
- (sbcl-package->ecl-package sbcl-symbol-munger))
+(define-public ecl-clx-truetype
+ (sbcl-package->ecl-package sbcl-clx-truetype))
-(define-public sbcl-cl-csv
- (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
- (revision "2"))
+(define-public sbcl-clx-xembed
+ (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
+ (revision "1"))
(package
- (name "sbcl-cl-csv")
- (version (git-version "1.0.6" revision commit))
+ (name "sbcl-clx-xembed")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/laynor/clx-xembed";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/cl-csv";)
+ (url "https://github.com/laynor/clx-xembed";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
+ (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
- `(#:tests? #f))
+ `(#:asd-systems '("xembed")))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-interpol" ,sbcl-cl-interpol)
- ("iterate" ,sbcl-iterate)))
- (native-inputs
- (list sbcl-lisp-unit2))
- (synopsis "Common lisp library for comma-separated values")
- (description
- "This is a Common Lisp library providing functions to read/write CSV
-from/to strings, streams and files.")
- (home-page "https://github.com/AccelerationNet/cl-csv";)
- (license license:bsd-3))))
+ (list sbcl-clx))
+ (synopsis "CL(x) xembed protocol implementation")
+ (description "CL(x) xembed protocol implementation")
+ ;; MIT License
+ (license license:expat))))
-(define-public cl-csv
- (sbcl-package->cl-source-package sbcl-cl-csv))
+(define-public cl-clx-xembed
+ (sbcl-package->cl-source-package sbcl-clx-xembed))
-(define-public ecl-cl-csv
- (sbcl-package->ecl-package sbcl-cl-csv))
+(define-public ecl-clx-xembed
+ (sbcl-package->ecl-package sbcl-clx-xembed))
-(define-public sbcl-external-program
- (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
- (revision "1"))
+(define-public sbcl-cmd
+ (let ((commit "0164d574ba236e2001ee1d9dba3f4774c7512a8c")
+ (revision "8"))
(package
- (name "sbcl-external-program")
- (version (git-version "0.0.6" revision commit))
+ (name "sbcl-cmd")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sellout/external-program";)
+ (url "https://github.com/ruricolist/cmd/";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-cmd" version))
(sha256
- (base32
- "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
+ (base32 "03wbckzmz6pqdlz7pyar6nfg4vs4bl0b2np7n3kk3qhjbrdakc4m"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((bin (string-append (assoc-ref inputs "coreutils")
+ "/bin"))
+ (ps-bin (string-append (assoc-ref inputs "procps")
+ "/bin")))
+ (substitute* "cmd.lisp"
+ (("\\(def \\+env\\+ \"env\"\\)")
+ (format #f "(def +env+ \"~a/env\")" bin))
+ (("\\(def \\+kill\\+ \"kill\"\\)")
+ (format #f "(def +kill+ \"~a/kill\")" bin))
+ (("\\(def \\+ps\\+ \"ps\"\\)")
+ (format #f "(def +ps+ \"~a/ps\")" ps-bin))
+ (("\\(def \\+pwd\\+ \"pwd\"\\)")
+ (format #f "(def +pwd+ \"~a/pwd\")" bin))
+ (("\\(def \\+sh\\+ \"/bin/sh\"\\)")
+ (format #f "(def +sh+ \"~a\")" (which "sh")))
+ (("\\(def \\+tr\\+ \"tr\"\\)")
+ (format #f "(def +tr+ \"~a/tr\")" bin)))))))))
(inputs
- (list sbcl-trivial-features))
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "Common Lisp library for running external programs")
+ (list coreutils
+ procps
+ sbcl-alexandria
+ sbcl-serapeum
+ sbcl-shlex
+ sbcl-trivia))
+ (home-page "https://github.com/ruricolist/cmd";)
+ (synopsis "Conveniently run external programs from Common Lisp")
(description
- "EXTERNAL-PROGRAM enables running programs outside the Lisp
-process. It is an attempt to make the RUN-PROGRAM functionality in
-implementations like SBCL and CCL as portable as possible without
-sacrificing much in the way of power.")
- (home-page "https://github.com/sellout/external-program";)
- (license license:llgpl))))
+ "A utility for running external programs, built on UIOP.
+Cmd is designed to be natural to use, protect against shell interpolation and
+be usable from multi-threaded programs.")
+ (license license:expat))))
-(define-public cl-external-program
- (sbcl-package->cl-source-package sbcl-external-program))
+(define-public cl-cmd
+ (sbcl-package->cl-source-package sbcl-cmd))
-(define-public ecl-external-program
- (sbcl-package->ecl-package sbcl-external-program))
+(define-public ecl-cmd
+ (sbcl-package->ecl-package sbcl-cmd))
-(define-public sbcl-cl-ana
- (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e")
- (revision "2"))
+(define-public sbcl-cmn
+ (package
+ (name "sbcl-cmn")
+ (version "2021.11.22")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://ccrma.stanford.edu/software/cmn/cmn.tar.gz";)
+ (file-name (string-append "cmn-" version ".tar.gz"))
+ (sha256
+ (base32 "04j1l57cdyfi2zzxqwmvmf1hl899ffgs3bl4r42ba47zsw45kq14"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://ccrma.stanford.edu/software/cmn/";)
+ (synopsis "Western music notation package written in Common Lisp")
+ (description
+ "CMN provides a package of functions to hierarchically describe a musical
+score. When evaluated, the musical score is rendered to an image.")
+ (license license:expat)))
+
+(define-public cl-cmn
+ (sbcl-package->cl-source-package sbcl-cmn))
+
+(define-public ecl-cmn
+ (sbcl-package->ecl-package sbcl-cmn))
+
+(define-public sbcl-coalton
+ (let ((commit "939342495f55991812c2c2767322c5e51e755216")
+ (revision "4"))
(package
- (name "sbcl-cl-ana")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-coalton")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ghollisjr/cl-ana";)
+ (url "https://github.com/coalton-lang/coalton";)
(commit commit)))
- (file-name (git-file-name "cl-ana" version))
+ (file-name (git-file-name "cl-coalton" version))
(sha256
- (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y"))))
+ (base32 "08qzj3v4fvn9h87whyqg650rpap8lva7jr94d1akv6m2z62l5q68"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list openmpi ;; for hdf-cffi
- pkg-config
- sbcl-cl-fad))
+ (list sbcl-fiasco))
(inputs
- (list gsl
- hdf5-parallel-openmpi
- libffi
- sbcl-antik
- sbcl-cffi
- sbcl-cl-csv
- sbcl-closer-mop
- sbcl-external-program
- sbcl-gsll
- sbcl-iterate
- sbcl-alexandria
- sbcl-split-sequence))
- (propagated-inputs
- (list gnuplot)) ;; for gnuplot-interface
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "hdf-cffi/src/library.lisp"
- (("libhdf5.so")
- (search-input-file inputs "/lib/libhdf5.so")))
- (substitute* (list "gsl-cffi/gsl-cffi.lisp"
- "spline/spline.lisp")
- (("libgsl.so")
- (search-input-file inputs "/lib/libgsl.so")))))
- (add-after 'fix-paths 'fix-newer-hdf5-compatibility
- (lambda _
- (substitute* (list "hdf-cffi/src/h5-grovel.lisp"
- "hdf-cffi/src/h5a-grovel.lisp"
- "hdf-cffi/src/h5d-grovel.lisp"
- "hdf-cffi/src/h5f-grovel.lisp"
- "hdf-cffi/src/h5g-grovel.lisp"
- "hdf-cffi/src/h5i-grovel.lisp"
- "hdf-cffi/src/h5l-grovel.lisp"
- "hdf-cffi/src/h5o-grovel.lisp"
- "hdf-cffi/src/h5p-grovel.lisp"
- "hdf-cffi/src/h5pl-grovel.lisp"
- "hdf-cffi/src/h5r-grovel.lisp"
- "hdf-cffi/src/h5s-grovel.lisp"
- "hdf-cffi/src/h5t-grovel.lisp"
- "hdf-cffi/src/h5z-grovel.lisp")
- (("_H5private_H")
- "H5private_H")))))))
- (synopsis "Common Lisp data analysis library")
+ (list sbcl-alexandria
+ sbcl-concrete-syntax-tree
+ sbcl-eclector
+ sbcl-float-features
+ sbcl-fset
+ sbcl-named-readtables
+ sbcl-trivial-garbage))
+ (home-page "https://coalton-lang.github.io";)
+ (synopsis "Dialect of ML in Common Lisp")
(description
- "CL-ANA is a data analysis library in Common Lisp providing tabular and
-binned data analysis along with nonlinear least squares fitting and
-visualization.")
- (home-page "https://github.com/ghollisjr/cl-ana";)
- (license license:gpl3))))
+ "Coalton is a dialect of ML embedded in Common Lisp. It emphasizes
+practicality and interoperability with Lisp, and is intended to be a DSL that
+allows one to gradually make their programs safer.")
+ (license license:expat))))
-(define-public cl-ana
- (sbcl-package->cl-source-package sbcl-cl-ana))
+(define-public cl-coalton
+ (sbcl-package->cl-source-package sbcl-coalton))
-(define-public sbcl-eazy-gnuplot
- (let ((commit "2eb900fe2557e6c066a9851c166e572c25bc0996")
+(define-public ecl-coalton
+ (sbcl-package->ecl-package sbcl-coalton))
+
+(define-public sbcl-coleslaw
+ (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40")
(revision "0"))
(package
- (name "sbcl-eazy-gnuplot")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-coleslaw")
+ (version (git-version "0.9.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/eazy-gnuplot";)
+ (url "https://github.com/coleslaw-org/coleslaw";)
(commit commit)))
- (file-name (git-file-name "cl-eazy-gnuplot" version))
+ (file-name (git-file-name "cl-coleslaw" version))
(sha256
- (base32 "0mpkx1z52riahydzvqv7kk15p0pv2k7k5a7j65fg571kcxmssx8s"))
- (patches (search-patches "sbcl-eazy-gnuplot-skip-path-check.patch"))))
+ (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list gnuplot
- sbcl-alexandria
- sbcl-iterate
- sbcl-trivia))
+ (outputs '("out" "bin"))
(arguments
- `(#:phases
+ '(#:asd-systems '("coleslaw" "coleslaw-cli")
+ #:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda _
- (substitute* "src/package.lisp"
- (("\"gnuplot\"")
- (string-append "\"" (which "gnuplot") "\""))))))))
- (home-page "https://github.com/guicho271828/eazy-gnuplot";)
- (synopsis "Common Lisp interface to gnuplot")
+ (substitute* "plugins/publish-gh-pages.sh"
+ (("^rsync\\b") (which "rsync")))
+ (substitute* '("plugins/rsync.lisp"
+ "src/coleslaw.lisp")
+ (("\\brun-program \"rsync\\b")
+ (string-append "run-program \"" (which "rsync"))))))
+ (add-after 'create-asdf-configuration 'build-program
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-program
+ (string-append (assoc-ref outputs "bin") "/bin/coleslaw")
+ outputs
+ #:dependencies '("coleslaw-cli")
+ #:entry-program '((apply (function coleslaw-cli::main)
+ arguments))
+ #:compress? #t))))))
+ (native-inputs
+ (list sbcl-prove))
+ (inputs
+ (list rsync
+ sbcl-3bmd
+ sbcl-alexandria
+ sbcl-cl-fad
+ sbcl-cl-ppcre
+ sbcl-cl-unicode
+ sbcl-clack
+ sbcl-closer-mop
+ sbcl-closure-template
+ sbcl-inferior-shell
+ sbcl-local-time
+ sbcl-trivia))
+ (home-page "https://github.com/coleslaw-org/coleslaw";)
+ (synopsis "Static site generator")
(description
- "Eazy-Gnuplot is a Common Lisp interface to gnuplot which eschews CFFI,
-CLOS and structures. It communicates with @command{gnuplot} via
-@code{*standard-output*}, and users can plot data by printing to that
-stream.")
- (license license:llgpl))))
+ "Coleslaw is a static site generator written in Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-eazy-gnuplot
- (sbcl-package->cl-source-package sbcl-eazy-gnuplot))
+(define-public cl-coleslaw
+ (sbcl-package->cl-source-package sbcl-coleslaw))
-(define-public ecl-eazy-gnuplot
- (sbcl-package->ecl-package sbcl-eazy-gnuplot))
+(define-public ecl-coleslaw
+ (sbcl-package->ecl-package sbcl-coleslaw))
-(define-public sbcl-archive
- (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
- (revision "1"))
+(define-public sbcl-collectors
+ (let ((commit "4c5e70cf399381de8fb485d4ed5a5c8fd7555146")
+ (revision "2"))
(package
- (name "sbcl-archive")
- (version (git-version "0.9" revision commit))
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/archive";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0pvsc9fmybx7rxd0kmzq4shi6hszdpwdc1sfy7jwyfxf8n3hnv4p"))))
+ (name "sbcl-collectors")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/AccelerationNet/collectors";)
+ (commit commit)))
+ (file-name (git-file-name "cl-collectors" version))
+ (sha256
+ (base32 "1kc9q05wyp8yjz5wqc73nar7l49vcnfhj4924li81v76hlb03665"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-fad sbcl-trivial-gray-streams))
- (synopsis "Common Lisp library for tar and cpio archives")
- (description
- "This is a Common Lisp library to read and write disk-based file
-archives such as those generated by the tar and cpio programs on Unix.")
- (home-page "https://github.com/sharplispers/archive";)
+ (list sbcl-alexandria sbcl-closer-mop sbcl-symbol-munger))
+ (native-inputs
+ (list sbcl-lisp-unit2))
+ (home-page "https://github.com/AccelerationNet/collectors/";)
+ (synopsis "Common lisp library providing collector macros")
+ (description "A small collection of common lisp macros to make
+collecting values easier.")
(license license:bsd-3))))
-(define-public cl-archive
- (sbcl-package->cl-source-package sbcl-archive))
+(define-public cl-collectors
+ (sbcl-package->cl-source-package sbcl-collectors))
-(define-public ecl-archive
- (sbcl-package->ecl-package sbcl-archive))
+(define-public ecl-collectors
+ (sbcl-package->ecl-package sbcl-collectors))
-(define-public sbcl-tar-file
- (let ((commit "0c10bc82f14702c97a26dc25ce075b5d3a2347d1")
- (revision "0"))
+(define-public sbcl-colored
+ (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb")
+ (revision "1"))
(package
- (name "sbcl-tar-file")
- (version (git-version "0.2.1" revision commit))
+ (name "sbcl-colored")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-tar/cl-tar-file";)
+ (url "https://github.com/Shinmera/colored/";)
(commit commit)))
- (file-name (git-file-name "cl-tar-file" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0i8j05fkgdqy4c4pqj0c68sh4s3klpx9kc5wp73qwzrl3xqd2svy"))))
+ (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-parachute))
(inputs
- (list sbcl-40ants-doc
- sbcl-alexandria
- sbcl-babel
- sbcl-chipz
- sbcl-flexi-streams
- sbcl-salza2
- sbcl-trivial-gray-streams))
- (home-page "https://gitlab.common-lisp.net/cl-tar/cl-tar-file";)
- (synopsis "Read and write physical entries to and from tar files")
+ (list sbcl-documentation-utils))
+ (synopsis "Colour representation, conversion, and operation for Common
Lisp")
(description
- "@code{cl-tar-file} is a Common Lisp library that allows reading from
-and writing to various tar archive formats. Currently supported are the POSIX
-ustar, PAX (ustar with a few new entry types), GNU, and v7 (very old) formats.
-
-This library is rather low level and is focused exclusively on reading and
-writing physical tar file entries using streams. Therefore, it contains no
-functionality for automatically building archives from a set of files on the
-filesystem or writing the contents of a file to the filesystem. Additionally,
-there are no smarts that read multiple physical entries and combine them into
-a single logical entry (e.g., with PAX extended headers or GNU long link/path
-name support). For a higher-level library that reads and writes logical
-entries, and also includes filesystem integration, see @code{cl-tar}.")
- (license license:bsd-3))))
+ "This is a library for representing and mapping colours between their
+various spaces.")
+ (home-page "https://shinmera.github.io/colored/";)
+ (license license:zlib))))
-(define-public cl-tar-file
- (sbcl-package->cl-source-package sbcl-tar-file))
+(define-public cl-colored
+ (sbcl-package->cl-source-package sbcl-colored))
-(define-public ecl-tar-file
- (sbcl-package->ecl-package sbcl-tar-file))
+(define-public ecl-colored
+ (sbcl-package->ecl-package sbcl-colored))
-(define-public sbcl-tar
- (let ((commit "7c6e07a10c93d9e311f087b5f6328cddd481669a")
- (revision "0"))
+(define-public sbcl-colorize
+ (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
(package
- (name "sbcl-tar")
- (version (git-version "0.2.3" revision commit))
+ (name "sbcl-colorize")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-tar/cl-tar";)
+ (url "https://github.com/kingcons/colorize";)
(commit commit)))
- (file-name (git-file-name "cl-tar" version))
(sha256
- (base32 "0wp23cs3i6a89dibifiz6559la5nk58d1n17xvbxq4nrl8cqsllf"))))
+ (base32
+ "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
+ (file-name (git-file-name "colorize" version))))
(build-system asdf-build-system/sbcl)
- ;; TODO: Build the tar program with 'build-program' when the
- ;; 'asdf-release-ops' library is added to Guix.
- (arguments
- '(#:asd-systems '("tar"
- "tar/common-extract"
- "tar/create"
- "tar/docs"
- "tar/extract"
- "tar/simple-extract")))
- (native-inputs
- (list sbcl-parachute))
(inputs
- (list sbcl-40ants-doc
- sbcl-alexandria
- sbcl-babel
- sbcl-local-time
- sbcl-osicat
- sbcl-split-sequence
- sbcl-tar-file))
- (home-page "https://gitlab.common-lisp.net/cl-tar/cl-tar";)
- (synopsis "High-level interface for tar files")
+ (list sbcl-alexandria sbcl-split-sequence sbcl-html-encode))
+ (synopsis "Common Lisp for syntax highlighting")
(description
- "@code{cl-tar} is a Common Lisp library providing a high-level interface
-for interacting with tar archives.")
+ "@command{colorize} is a Lisp library for syntax highlighting
+supporting the following languages: Common Lisp, Emacs Lisp, Scheme, Clojure,
+C, C++, Java, Python, Erlang, Haskell, Objective-C, Diff, Webkit.")
+ (home-page "https://github.com/kingcons/colorize";)
+ ;; TODO: Missing license?
(license license:expat))))
-(define-public cl-tar
- (sbcl-package->cl-source-package sbcl-tar))
+(define-public cl-colorize
+ (sbcl-package->cl-source-package sbcl-colorize))
-(define-public ecl-tar
- (sbcl-package->ecl-package sbcl-tar))
+(define-public ecl-colorize
+ (sbcl-package->ecl-package sbcl-colorize))
-(define-public sbcl-misc-extensions
- (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
- (revision "1"))
+(define-public sbcl-com.gigamonkeys.binary-data
+ (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
+ (revision "0"))
(package
- (name "sbcl-misc-extensions")
- (version (git-version "3.3" revision commit))
+ (name "sbcl-com.gigamonkeys.binary-data")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/misc-extensions/devel.git";)
+ (url "https://github.com/gigamonkey/monkeylib-binary-data";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
+ (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Collection of small macros and extensions for Common Lisp")
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://github.com/gigamonkey/monkeylib-binary-data";)
+ (synopsis "Common Lisp library for reading and writing binary data")
(description
- "This project is intended as a catchall for small, general-purpose
-extensions to Common Lisp. It contains:
-
-@itemize
-@item @code{new-let}, a macro that combines and generalizes @code{let},
-@code{let*} and @code{multiple-value-bind},
-@item @code{gmap}, an iteration macro that generalizes @code{map}.
-@end itemize\n")
- (home-page "https://common-lisp.net/project/misc-extensions/";)
- (license license:public-domain))))
+ "This a Common Lisp library for reading and writing binary data. It is
+based on code from chapter 24 of the book @emph{Practical Common Lisp}.")
+ (license license:bsd-3))))
-(define-public cl-misc-extensions
- (sbcl-package->cl-source-package sbcl-misc-extensions))
+(define-public cl-com.gigamonkeys.binary-data
+ (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
-(define-public ecl-misc-extensions
- (sbcl-package->ecl-package sbcl-misc-extensions))
+(define-public ecl-com.gigamonkeys.binary-data
+ (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
-(define-public sbcl-mt19937
+(define-public sbcl-command-line-args
(package
- (name "sbcl-mt19937")
- (version "1.1")
+ (name "sbcl-command-line-args")
+ (version "0.1.1")
(source
(origin
- (method url-fetch)
- (uri (string-append "https://common-lisp.net/project/asdf-packaging/";
- "mt19937-latest.tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.sr.ht/~whereiseveryone/command-line-args";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-command-line-args" version))
(sha256
- (base32
- "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
+ (base32 "140xnz2v0v3hfg3dp2fhidw8ns6lxd3a5knm07wqdp48ksg119wy"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Mersenne Twister pseudo-random number generator")
- (description
- "MT19937 is a portable Mersenne Twister pseudo-random number generator
-for Common Lisp.")
- (home-page "https://www.cliki.net/mt19937";)
- (license license:public-domain)))
+ (arguments
+ '(#:asd-systems '("whereiseveryone.command-line-args")))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-charje.documentation
+ sbcl-cl-str
+ sbcl-serapeum
+ sbcl-trivia))
+ (home-page "https://git.sr.ht/~whereiseveryone/command-line-args";)
+ (synopsis "Automatically generate command line interfaces")
+ (description "Command-Line-Args provides a main macro (@code{command})
+that wraps a @code{defun} form and creates a new function that parses the
+command line arguments. It has support for command-line options, positional,
+and variadic arguments. It also generates a basic help message. The
+interface is meant to be easy and non-intrusive.")
+ (license license:agpl3+)))
-(define-public cl-mt19937
- (sbcl-package->cl-source-package sbcl-mt19937))
+(define-public cl-command-line-args
+ (sbcl-package->cl-source-package sbcl-command-line-args))
-(define-public ecl-mt19937
- (sbcl-package->ecl-package sbcl-mt19937))
+(define-public ecl-command-line-args
+ (sbcl-package->ecl-package sbcl-command-line-args))
-(define-public sbcl-fset
- (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
+(define-public sbcl-command-line-arguments
+ (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe")
(revision "1"))
(package
- (name "sbcl-fset")
- (version (git-version "1.3.2" revision commit))
+ (name "sbcl-command-line-arguments")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slburson/fset";)
+ (url "https://github.com/fare/command-line-arguments";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
- (snippet '(begin
- ;; Remove obsolete copy of system definition.
- (delete-file "Code/fset.asd")
- #t))))
+ (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-misc-extensions sbcl-mt19937 sbcl-named-readtables))
- (synopsis "Functional set-theoretic collections library")
- (description
- "FSet is a functional set-theoretic collections library for Common Lisp.
-Functional means that all update operations return a new collection rather than
-modifying an existing one in place. Set-theoretic means that collections may
-be nested arbitrarily with no additional programmer effort; for instance, sets
-may contain sets, maps may be keyed by sets, etc.")
- (home-page "https://common-lisp.net/project/fset/Site/index.html";)
- (license license:llgpl))))
+ (home-page "https://github.com/fare/command-line-arguments";)
+ (synopsis "Trivial command-line argument parsing library for Common
Lisp")
+ (description "This is a library to abstract away the parsing of
+Unix-style command-line arguments. Use it in conjunction with asdf:program-op
+or cl-launch for portable processing of command-line arguments.")
+ (license license:expat))))
-(define-public cl-fset
- (sbcl-package->cl-source-package sbcl-fset))
+(define-public cl-command-line-arguments
+ (sbcl-package->cl-source-package sbcl-command-line-arguments))
-(define-public ecl-fset
- (package
- (inherit (sbcl-package->ecl-package sbcl-fset))
- (arguments
- ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined".
- '(#:tests? #f))))
+(define-public ecl-command-line-arguments
+ (sbcl-package->ecl-package sbcl-command-line-arguments))
-(define-public sbcl-modf
- (let ((commit "dea93fe62c6bf7f66f32f52ac0c555aedbf7abad")
- (revision "0"))
+(define-public sbcl-common-lisp-jupyter
+ (let ((commit "ba9f0e746b9200d6fd6db647d7274448119ed01b")
+ (revision "3"))
(package
- (name "sbcl-modf")
- (version (git-version "0" revision commit))
+ (name "sbcl-common-lisp-jupyter")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/smithzvk/modf";)
+ (url "https://github.com/yitzchak/common-lisp-jupyter";)
(commit commit)))
- (file-name (git-file-name "cl-modf" version))
+ (file-name (git-file-name "common-lisp-jupyter" commit))
(sha256
- (base32
- "1aap7ldy7lv942khp026pgndgdzfkkqa9xcq1ykinrmflrgdazay"))))
+ (base32 "0si69xfzi769dprwfy7gp1x3bl7lxz6d4n98sa26w9r41wvay5ja"))))
(build-system asdf-build-system/sbcl)
(inputs
(list sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cl-base64
+ sbcl-cl-indentify
sbcl-closer-mop
- sbcl-iterate))
- (native-inputs
- (list sbcl-stefil))
- (home-page "https://github.com/smithzvk/modf";)
- (synopsis "SETF like macro for functional programming in Common Lisp")
- (description "This library simplifies functional programming in Common
-Lisp by making it easier to make new data structures with specified changes in
-place.")
- (license license:bsd-3))))
-
-(define-public cl-modf
- (sbcl-package->cl-source-package sbcl-modf))
-
-(define-public ecl-modf
- (sbcl-package->ecl-package sbcl-modf))
-
-(define-public sbcl-cl-cont
- (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
- (revision "1"))
- (package
- (name "sbcl-cl-cont")
- (version (git-version "0.3.8" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-closer-mop))
- (native-inputs
- (list sbcl-rt))
- (synopsis "Delimited continuations for Common Lisp")
+ sbcl-dissect
+ sbcl-eclector
+ sbcl-ironclad
+ sbcl-iterate
+ sbcl-multilang-documentation
+ sbcl-puri
+ sbcl-pzmq
+ sbcl-shasht
+ sbcl-static-vectors
+ sbcl-trivial-do
+ sbcl-trivial-garbage
+ sbcl-trivial-gray-streams
+ sbcl-trivial-mimes))
+ (home-page "https://yitzchak.github.io/common-lisp-jupyter/";)
+ (synopsis "Common Lisp kernel for Jupyter")
(description
- "This is a library that implements delimited continuations by
-transforming Common Lisp code to continuation passing style.")
- (home-page "https://common-lisp.net/project/cl-cont/";)
- (license license:llgpl))))
-
-(define-public cl-cont
- (sbcl-package->cl-source-package sbcl-cl-cont))
+ "This is a Common Lisp kernel for Jupyter along with a library for
+building Jupyter kernels, based on Maxima-Jupyter which was based on
+@code{cl-jupyter}.")
+ (license license:expat))))
-(define-public ecl-cl-cont
- (sbcl-package->ecl-package sbcl-cl-cont))
+(define-public cl-common-lisp-jupyter
+ (sbcl-package->cl-source-package sbcl-common-lisp-jupyter))
-(define-public sbcl-cl-coroutine
- (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
- (revision "1"))
+(define-public ecl-common-lisp-jupyter
+ (sbcl-package->ecl-package sbcl-common-lisp-jupyter))
+
+(define-public sbcl-compatible-metaclasses
+ (package
+ (name "sbcl-compatible-metaclasses")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/compatible-metaclasses";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-compatible-metaclasses" version))
+ (sha256
+ (base32 "17cf74j400cl6sjslfhkv13lir85k705v63mx3dd4y6dl5hvsdh6"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-class-options
+ sbcl-closer-mop
+ sbcl-enhanced-find-class))
+ (home-page
"https://www.hexstreamsoft.com/libraries/compatible-metaclasses/";)
+ (synopsis "Simplifies class mixins by validating superclasses")
+ (description
+ "This library validates superclasses according to a simple substitution
+model, thereby greatly simplifying the definition of class mixins.")
+ (license license:unlicense)))
+
+(define-public cl-compatible-metaclasses
+ (sbcl-package->cl-source-package sbcl-compatible-metaclasses))
+
+(define-public ecl-compatible-metaclasses
+ (sbcl-package->ecl-package sbcl-compatible-metaclasses))
+
+(define-public sbcl-compiler-macro
+ (let ((commit "7796bda64aec5af3ca175170ad3565167868789c")
+ (revision "0"))
(package
- (name "sbcl-cl-coroutine")
+ (name "sbcl-compiler-macro")
(version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/takagi/cl-coroutine";)
+ (url "https://github.com/Bike/compiler-macro";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-compiler-macro" version))
(sha256
- (base32
- "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
+ (base32 "13sswps7s0qy6939mvj8q57hkx0qkga6rl6xjhjr7pk7by0xdsjq"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-cont" ,sbcl-cl-cont)))
(native-inputs
- (list sbcl-prove))
- (arguments
- `(;; TODO: Fix the tests. They fail with:
- ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
- #:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "cl-coroutine-test.asd"
- (("cl-test-more")
- "prove"))
- #t)))))
- (synopsis "Coroutine library for Common Lisp")
- (description
- "This is a coroutine library for Common Lisp implemented using the
-continuations of the @code{cl-cont} library.")
- (home-page "https://github.com/takagi/cl-coroutine";)
- (license license:llgpl))))
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-introspect-environment))
+ (home-page "https://github.com/Bike/compiler-macro";)
+ (synopsis "Common Lisp compiler macro utilities")
+ (description "This library is a collection of utilities for writing
+compiler macros. It is intended to make it possible to make compiler macros
+much more useful, by granting them access to lexical type information, making
+the protocol for declining expansion more convenient, and establishing some
+information for signaling optimization advice to programmers. Some utilities
+to support this, especially for reasoning on types, are also included.")
+ (license license:cc0))))
-(define-public cl-coroutine
- (sbcl-package->cl-source-package sbcl-cl-coroutine))
+(define-public cl-compiler-macro
+ (sbcl-package->cl-source-package sbcl-compiler-macro))
-(define-public ecl-cl-coroutine
- (sbcl-package->ecl-package sbcl-cl-coroutine))
+(define-public ecl-compiler-macro
+ (sbcl-package->ecl-package sbcl-compiler-macro))
-(define-public sbcl-vas-string-metrics
- (let ((commit "f2e4500b180316123fbd549bd51c751ee2d6ba0f")
- (revision "1"))
+(define-public sbcl-compiler-macro-notes
+ (package
+ (name "sbcl-compiler-macro-notes")
+ (version "0.2.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/digikar99/compiler-macro-notes";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-compiler-macro-notes" version))
+ (sha256
+ (base32 "1jv8snj2wvim3k9qhl1vsx82n56nzdmwa3ms9c4ml2d58fwpfjzs"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cl-environments))
+ (home-page "https://github.com/digikar99/compiler-macro-notes";)
+ (synopsis "Macros and conditions for use within macros and
compiler-macros")
+ (description
+ "Alternative to the @code{compiler-macro} library:
+
+@itemize
+@item Here, we do not treat compiler notes as warnings, but instead these are
+a separate class of conditions. These are also not errors.
+@item Two main condition classes are provided: compiler-macro-notes:note and
+compiler-macro-notes:optimization-failure-note. While the latter is a subclass
+of the former, the latter notes are printed in a slightly different manner to
+the former.
+@item To be able to correctly print the expansion path that led to the
+condition, user code is expected to avoid performing a nonlocal exit to a
+place outside with-notes.
+@end itemize\n")
+ (license license:expat)))
+
+(define-public cl-compiler-macro-notes
+ (sbcl-package->cl-source-package sbcl-compiler-macro-notes))
+
+(define-public ecl-compiler-macro-notes
+ (sbcl-package->ecl-package sbcl-compiler-macro-notes))
+
+(define-public sbcl-computable-reals
+ (let ((commit "fdc73d75e79d0a4ce6d01c822c950ae2eb137d39"))
(package
- (name "sbcl-vas-string-metrics")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-computable-reals")
+ (version (git-version "1.1.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vsedach/vas-string-metrics";)
+ (url "https://github.com/stylewarning/computable-reals";)
(commit commit)))
- (file-name (git-file-name "vas-string-metrics" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "11fcnd03ybzz37rkg3z0wsb727yqgcd9gn70sccfb34l89ia279k"))))
+ (base32 "0f12axi53x14l12dgf4a1lfq3p1fx7fh7sjfc0db3lk88ph9qfwl"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-test-systems '("test.vas-string-metrics")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-test-asd
- (lambda _
- (substitute* "test.vas-string-metrics.asd"
- ((":depends-on")
- (string-append
- ":perform (test-op (op c) (symbol-call :vas-string-metrics
:run-tests))"
- "\n"
- " :depends-on"))))))))
- (home-page "https://github.com/vsedach/vas-string-metrics";)
- (synopsis "String distance algorithms for Common Lisp")
+ (home-page "https://github.com/stylewarning/computable-reals";)
+ (synopsis "Arbitrary-precision, re-computing real-numbers in Common
Lisp")
(description
- "VAS-STRING-METRICS provides the Jaro, Jaro-Winkler, Soerensen-Dice,
-Levenshtein, and normalized Levenshtein string distance/similarity metrics
-algorithms.")
- (license license:lgpl3+))))
+ "This library provides arbitrary precision (floating point) real
+numbers in Common Lisp.")
+ (license license:bsd-3))))
-(define-public ecl-vas-string-metrics
- (sbcl-package->ecl-package sbcl-vas-string-metrics))
+(define-public cl-computable-reals
+ (sbcl-package->cl-source-package sbcl-computable-reals))
-(define-public cl-vas-string-metrics
- (sbcl-package->cl-source-package sbcl-vas-string-metrics))
+(define-public ecl-computable-reals
+ (sbcl-package->ecl-package sbcl-computable-reals))
-(define-public sbcl-vom
- (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
- (revision "1"))
+(define-public sbcl-concrete-syntax-tree
+ (let ((commit "37291727196a3bc88a7be67c1427c52078d4b82c")
+ (revision "0"))
(package
- (name "sbcl-vom")
- (version (git-version "0.1.4" revision commit))
+ (name "sbcl-concrete-syntax-tree")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/vom";)
+ (url "https://github.com/s-expressionists/Concrete-Syntax-Tree";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-concrete-syntax-tree" commit))
(sha256
- (base32
- "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
+ (base32 "15q9jyqsh2z921li9my8c840cj2ci7k217x5frfiyk0kymkx4rgv"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Tiny logging utility for Common Lisp")
+ (inputs
+ (list sbcl-acclimation))
+ (arguments
+ '(#:asd-systems '("concrete-syntax-tree"
+ "concrete-syntax-tree-destructuring"
+ "concrete-syntax-tree-source-info")))
+ (home-page "https://github.com/s-expressionists/Concrete-Syntax-Tree";)
+ (synopsis "Parse Common Lisp code into a concrete syntax tree")
(description
- "Vom is a logging library for Common Lisp. It's goal is to be useful
-and small. It does not provide a lot of features as other loggers do, but
-has a small codebase that's easy to understand and use.")
- (home-page "https://github.com/orthecreedence/vom";)
- (license license:expat))))
+ "This library is intended to solve the problem of source tracking for
+Common Lisp code.
-(define-public cl-vom
- (sbcl-package->cl-source-package sbcl-vom))
+By \"source tracking\", it is meant that code elements that have a known
+origin in the form of a position in a file or in an editor buffer are
+associated with some kind of information about this origin.
-(define-public ecl-vom
- (sbcl-package->ecl-package sbcl-vom))
+Since the exact nature of such origin information depends on the Common Lisp
+implementation and the purpose of wanting to track that origin, the library
+does not impose a particular structure of this information. Instead, it
+provides utilities for manipulating source code in the form of what is called
+concrete syntax trees (CSTs for short) that preserve this information about
+the origin.")
+ (license license:bsd-2))))
-(define-public sbcl-cl-libuv
- (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
+(define-public cl-concrete-syntax-tree
+ (sbcl-package->cl-source-package sbcl-concrete-syntax-tree))
+
+(define-public ecl-concrete-syntax-tree
+ (sbcl-package->ecl-package sbcl-concrete-syntax-tree))
+
+(define-public sbcl-concurrent-hash-tables
+ (let ((commit "6ad539b8970ff94b1e1369b59065ed7d0660904c")
(revision "1"))
(package
- (name "sbcl-cl-libuv")
- (version (git-version "0.1.6" revision commit))
+ (name "sbcl-concurrent-hash-tables")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/cl-libuv";)
+ (url
"https://github.com/no-defun-allowed/concurrent-hash-tables";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-concurrent-hash-tables" version))
(sha256
- (base32
- "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
+ (base32 "0wgbv3wl33rlfbywmjag0gk7igzfksmib30r8cbnd5n47ic09iip"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("libuv" ,libuv)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "lib.lisp"
- (("/usr/lib/libuv.so")
- (search-input-file inputs "/lib/libuv.so")))))
- (add-after 'fix-paths 'fix-system-definition
- (lambda _
- (substitute* "cl-libuv.asd"
- (("#:cffi #:alexandria")
- "#:cffi #:cffi-grovel #:alexandria"))
- #t)))))
- (synopsis "Common Lisp bindings to libuv")
- (description
- "This library provides low-level libuv bindings for Common Lisp.")
- (home-page "https://github.com/orthecreedence/cl-libuv";)
- (license license:expat))))
+ (list sbcl-atomics sbcl-bordeaux-threads))
+ (home-page "https://github.com/no-defun-allowed/concurrent-hash-tables";)
+ (synopsis "Portability library for concurrent hash tables in Common
Lisp")
+ (description "@code{concurrent-hash-tables} is a Common Lisp portability
+library wrapping some implementations of concurrent hash tables which do not
+have to be entirely locked in their operation, including
+@code{42nd-at-threadmill}, @code{luckless}, and a fallback, segmented hash
+table.")
+ (license license:bsd-2))))
-(define-public cl-libuv
- (sbcl-package->cl-source-package sbcl-cl-libuv))
+(define-public cl-concurrent-hash-tables
+ (sbcl-package->cl-source-package sbcl-concurrent-hash-tables))
-(define-public ecl-cl-libuv
- (sbcl-package->ecl-package sbcl-cl-libuv))
+(define-public ecl-concurrent-hash-tables
+ (sbcl-package->ecl-package sbcl-concurrent-hash-tables))
-(define-public sbcl-cl-async
- (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
+(define-public sbcl-conduit-packages
+ (package
+ (name "sbcl-conduit-packages")
+ (version "2.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tfeb/conduit-packages";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-conduit-packages" version))
+ (sha256
+ (base32 "1n783in84mrk9lnc3nshwsgxhb8y0dk6ys9z6jlxkv0jpjxhpjjc"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments '(#:asd-systems '("org.tfeb.conduit-packages")))
+ (synopsis "Conduit packages for Common Lisp")
+ (description "This library defines a way of treating Common Lisp
+packages as conduits which can sit between one or more implementation
+packages and users of those packages.")
+ (home-page "https://github.com/tfeb/conduit-packages/";)
+ (license license:expat)))
+
+(define-public cl-conduit-packages
+ (sbcl-package->cl-source-package sbcl-conduit-packages))
+
+(define-public ecl-conduit-packages
+ (sbcl-package->ecl-package sbcl-conduit-packages))
+
+(define-public sbcl-conium
+ (let ((commit "089adfd8759ec7973bb6f67b98d7a246e67aeb05")
(revision "1"))
(package
- (name "sbcl-cl-async")
- (version (git-version "0.6.1" revision commit))
+ (name "sbcl-conium")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/cl-async";)
+ (url "https://github.com/sharplispers/conium";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "conium" version))
(sha256
- (base32
- "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
+ (base32 "0y31za8xr8734p2pf8mrw1jd1fksh2d4y1p12wwjyn8hxxsvsx1w"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("babel" ,sbcl-babel)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("cl-libuv" ,sbcl-cl-libuv)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("fast-io" ,sbcl-fast-io)
- ("openssl" ,openssl)
- ("static-vectors" ,sbcl-static-vectors)
- ("trivial-features" ,sbcl-trivial-features)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("vom" ,sbcl-vom)))
- (arguments
- `(#:asd-systems '("cl-async"
- "cl-async-repl"
- "cl-async-ssl")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/ssl/package.lisp"
- (("libcrypto\\.so")
- (search-input-file inputs "/lib/libcrypto.so"))
- (("libssl\\.so")
- (search-input-file inputs "/lib/libssl.so"))))))))
- (synopsis "Asynchronous operations for Common Lisp")
+ (list sbcl-closer-mop))
+ (home-page "https://github.com/sharplispers/conium";)
+ (synopsis "Portability library for debugger- and compiler-related tasks")
(description
- "Cl-async is a library for general purpose, non-blocking programming in
-Common Lisp. It uses the libuv library as backend.")
- (home-page "https://orthecreedence.github.io/cl-async/";)
- (license license:expat))))
+ "Conium is a portability library for debugger- and compiler-related
+tasks in Common Lisp. It is fork of SWANK-BACKEND.")
+ (license license:public-domain))))
-(define-public cl-async
- (sbcl-package->cl-source-package sbcl-cl-async))
+(define-public cl-conium
+ (sbcl-package->cl-source-package sbcl-conium))
-(define-public ecl-cl-async
- (sbcl-package->ecl-package sbcl-cl-async))
+(define-public ecl-conium
+ (sbcl-package->ecl-package sbcl-conium))
-(define-public sbcl-classimp
- (let ((commit "d82a14c59bc733f89a1ea0b3447ebedddce5756e")
- (revision "0"))
+(define-public sbcl-constantfold
+ (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
+ (revision "1"))
(package
- (name "sbcl-classimp")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-constantfold")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/classimp";)
+ (url "https://github.com/numcl/constantfold";)
(commit commit)))
- (file-name (git-file-name "cl-classimp" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0pbnz6cf1zb2ayk4kbw0gphjb8nflnjns2rwhv86jz0kf0z1hqha"))))
+ (base32
+ "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'patch-assimp-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "library.lisp"
- (("libassimp.so.5" _)
- (search-input-file inputs "/lib/libassimp.so.5.0.0"))))))))
- (inputs
- (list assimp-5.0
- sbcl-cffi
- sbcl-split-sequence))
- (home-page "https://github.com/3b/classimp";)
- (synopsis "Common Lisp CFFI bindings for Open Asset Import Library")
+ (synopsis "Support library for numcl")
(description
- "This package provides CFFI bindings to the @acronym{ASSIMP, Asset
-Import} library for Common Lisp.")
- (license license:expat))))
-
-;; FIXME: The cl and ecl packages get the latest version of assimp as
-;; dependency instead of the one specified in the sbcl package. Specifying
-;; the dependencies explicitly works around the issue.
-(define-public cl-classimp
- (let ((pkg (sbcl-package->cl-source-package sbcl-classimp)))
- (package
- (inherit pkg)
+ "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
- (list assimp-5.0
- cl-cffi
- cl-split-sequence)))))
+ `(("trivia" ,sbcl-trivia)
+ ("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("lisp-namespace" ,sbcl-lisp-namespace)))
+ (native-inputs
+ (list sbcl-fiveam)))))
-(define-public ecl-classimp
- (let ((pkg (sbcl-package->ecl-package sbcl-classimp)))
- (package
- (inherit pkg)
- (inputs
- (list assimp-5.0
- ecl-cffi
- ecl-split-sequence)))))
+(define-public cl-constantfold
+ (sbcl-package->cl-source-package sbcl-constantfold))
-(define-public sbcl-blackbird
- (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
- (revision "1"))
+(define-public ecl-constantfold
+ (sbcl-package->ecl-package sbcl-constantfold))
+
+(define-public sbcl-contextl
+ ;; No release since 2013.
+ (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb")
+ (revision "2"))
(package
- (name "sbcl-blackbird")
- (version (git-version "0.5.2" revision commit))
+ (name "sbcl-contextl")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/blackbird";)
+ (url "https://github.com/pcostanza/contextl/";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
+ (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-vom))
- (native-inputs
- (list sbcl-cl-async sbcl-fiveam))
- (synopsis "Promise implementation for Common Lisp")
- (description
- "This is a standalone promise implementation for Common Lisp. It is
-the successor to the now-deprecated cl-async-future project.")
- (home-page "https://orthecreedence.github.io/blackbird/";)
+ (list sbcl-closer-mop sbcl-lw-compat))
+ (home-page "https://github.com/pcostanza/contextl";)
+ (synopsis "Context-oriented programming for Common Lisp")
+ (description "ContextL is a CLOS extension for Context-Oriented
+Programming (COP).
+
+Find overview of ContextL's features in an overview paper:
+@url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general
+overview article about COP which also contains some ContextL examples:
+@url{http://www.jot.fm/issues/issue_2008_03/article4/}.";)
(license license:expat))))
-(define-public cl-blackbird
- (sbcl-package->cl-source-package sbcl-blackbird))
+(define-public cl-contextl
+ (sbcl-package->cl-source-package sbcl-contextl))
-(define-public ecl-blackbird
- (sbcl-package->ecl-package sbcl-blackbird))
+(define-public ecl-contextl
+ (sbcl-package->ecl-package sbcl-contextl))
-(define-public sbcl-cl-async-future
- (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
+(define-public sbcl-core-gp
+ (let ((commit "90ec1c4599a19c5a911be1f703f78d5108aee160")
(revision "1"))
(package
- (name "sbcl-cl-async-future")
- (version (git-version "0.4.4.1" revision commit))
+ (name "sbcl-core-gp")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/cl-async-future";)
+ (url "https://github.com/jorgetavares/core-gp";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-core-gp" version))
(sha256
- (base32
- "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
+ (base32 "0nzlb2gwqisa1amlpl4zc5xxph2g3qwhfyaxchci67d31rzws6l3"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-blackbird))
- (native-inputs
- (list sbcl-cl-async sbcl-eos))
- (synopsis "Futures implementation for Common Lisp")
+ (home-page "https://github.com/jorgetavares/core-gp";)
+ (synopsis "Common Lisp library for genetic programming")
(description
- "This is futures implementation for Common Lisp. It plugs in nicely
-to cl-async.")
- (home-page "https://orthecreedence.github.io/cl-async/future";)
- (license license:expat))))
-
-(define-public cl-async-future
- (sbcl-package->cl-source-package sbcl-cl-async-future))
+ "@code{core-gp} is a Common Lisp library for genetic programming (GP)
+algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as
+well as standard genetic algorithms.")
+ (license license:expat))))
-(define-public ecl-cl-async-future
- (sbcl-package->ecl-package sbcl-cl-async-future))
+(define-public cl-core-gp
+ (sbcl-package->cl-source-package sbcl-core-gp))
-(define-public sbcl-green-threads
- (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
+(define-public ecl-core-gp
+ (sbcl-package->ecl-package sbcl-core-gp))
+
+(define-public sbcl-croatoan
+ (let ((commit "282145ff9e9005fddc4241bc6827b3ab09c5bd25")
(revision "1"))
(package
- (name "sbcl-green-threads")
- (version (git-version "0.3" revision commit))
+ (name "sbcl-croatoan")
+ (version (git-version "2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/thezerobit/green-threads";)
+ (url "https://github.com/McParen/croatoan";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-croatoan" version))
(sha256
- (base32
- "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
+ (base32 "021h2f2yj4j9gynr3k7qi36x94jm5b95p3vaddbaih96wyzgbmq5"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-async-future" ,sbcl-cl-async-future)
- ("cl-cont" ,sbcl-cl-cont)))
- (native-inputs
- (list sbcl-prove))
(arguments
- `(;; TODO: Fix the tests. They fail with:
- ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
- #:tests? #f
- #:phases
+ '(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "green-threads-test.asd"
- (("cl-test-more")
- "prove"))
- #t)))))
- (synopsis "Cooperative multitasking library for Common Lisp")
- (description
- "This library allows for cooperative multitasking with help of cl-cont
-for continuations. It tries to mimic the API of bordeaux-threads as much as
-possible.")
- (home-page "https://github.com/thezerobit/green-threads";)
- (license license:bsd-3))))
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "ncurses/ncurses.lisp"
+ (("libncursesw.so")
+ (search-input-file inputs "/lib/libncursesw.so"))))))))
+ (inputs
+ (list ncurses
+ sbcl-cffi
+ sbcl-trivial-gray-streams
+ sbcl-bordeaux-threads))
+ (synopsis "Common Lisp bindings for the ncurses terminal library")
+ (description "Croatoan provides high-level Common Lisp CLOS bindings for
+the ncurses terminal library.")
+ (home-page "https://github.com/McParen/croatoan";)
+ (license license:expat))))
-(define-public cl-green-threads
- (sbcl-package->cl-source-package sbcl-green-threads))
+(define-public cl-croatoan
+ (sbcl-package->cl-source-package sbcl-croatoan))
-(define-public ecl-green-threads
- (sbcl-package->ecl-package sbcl-green-threads))
+(define-public ecl-croatoan
+ (sbcl-package->ecl-package sbcl-croatoan))
-(define-public sbcl-cl-base32
- (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
+(define-public sbcl-crypto-shortcuts
+ (let ((commit "7efd22d80e867cd8c9f8f363d4fe7b51ee2dadc0")
(revision "1"))
(package
- (name "sbcl-cl-base32")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-crypto-shortcuts")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hargettp/cl-base32";)
+ (url "https://github.com/Shinmera/crypto-shortcuts";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "crypto-shortcuts" version))
(sha256
- (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
+ (base32 "0c0m0ar04jn7qf2v8c4sivamlzki03r13rnxy8b3n27rh9r6hgin"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
- (synopsis "Common Lisp library for base32 encoding and decoding")
+ (inputs
+ (list sbcl-cl-base64 sbcl-flexi-streams sbcl-ironclad))
+ (synopsis "Collection of common cryptography functions")
(description
- "This package provides functions for base32 encoding and decoding as
-defined in RFC4648.")
- (home-page "https://github.com/hargettp/cl-base32";)
- (license license:expat))))
+ "This is a collection of common cryptography functions for Common
+Lisp.")
+ (home-page "https://shinmera.github.io/crypto-shortcuts/";)
+ (license license:zlib))))
-(define-public cl-base32
- (sbcl-package->cl-source-package sbcl-cl-base32))
+(define-public cl-crypto-shortcuts
+ (sbcl-package->cl-source-package sbcl-crypto-shortcuts))
-(define-public ecl-cl-base32
- (sbcl-package->ecl-package sbcl-cl-base32))
+(define-public ecl-crypto-shortcuts
+ (sbcl-package->ecl-package sbcl-crypto-shortcuts))
-(define-public sbcl-cl-z85
- (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
- (revision "1"))
+(define-public sbcl-css-lite
+ (let ((commit "6ee4e6212ed56943d665df163d2a834b122e6273")
+ (revision "0"))
(package
- (name "sbcl-cl-z85")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-css-lite")
+ (version "0.01")
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://codeberg.org/glv/cl-z85";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp"))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/paddymul/css-lite";)
+ (commit commit)))
+ (sha256
+ (base32 "1lyvw7hcy09k5qs6icky23s13psqxncyc73hdyiimb66p0jx6k0d"))
+ (file-name (git-file-name "cl-css-lite" commit))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-cl-octet-streams sbcl-fiveam))
- (synopsis "Common Lisp library for Z85 encoding and decoding")
+ (home-page "https://github.com/paddymul/css-lite";)
+ (synopsis "CSS grammar for Lisp")
(description
- "This package provides functions to encode or decode byte vectors or
-byte streams using the Z85 format, which is a base-85 encoding used by
-ZeroMQ.")
- (home-page "https://codeberg.org/glv/cl-z85";)
- (license license:gpl3+))))
+ "@code{cl-css-lite} is a library for generating CSS from an s-exp based
+syntax. When compiled with Parenscript loaded in the Lisp image, it
+also provides the same CSS generation facilities in Parenscript-generated
+JavaScript code.")
+ (license license:bsd-3))))
-(define-public cl-z85
- (sbcl-package->cl-source-package sbcl-cl-z85))
+(define-public cl-css-lite
+ (sbcl-package->cl-source-package sbcl-css-lite))
-(define-public ecl-cl-z85
- (sbcl-package->ecl-package sbcl-cl-z85))
+(define-public ecl-css-lite
+ (sbcl-package->ecl-package sbcl-css-lite))
-(define-public sbcl-ltk
- (let ((commit "ff14a781d211c19c35e65a7ecaece67dda0b3ebb")
- (revision "0"))
+(define-public sbcl-ctype
+ (let ((commit "4fc4c5ae44c435ed82556969f698005bee50101c"))
(package
- (name "sbcl-ltk")
- (version (git-version "0.992" revision commit))
+ (name "sbcl-ctype")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/herth/ltk";)
+ (url "https://github.com/s-expressionists/ctype";)
(commit commit)))
- (file-name (git-file-name "cl-ltk" version))
+ (file-name (git-file-name "cl-ctype" version))
(sha256
- (base32 "0f1xgsj2j7bq21cq2pa9rw3ybxd9vyknisl6z307lxx7lvhm3xac"))))
+ (base32 "05smc81ml9rbcbzdhqg2mi9drnjsipq62r5q7f7qql8hbx01vl9i"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list imagemagick tk))
+ (list sbcl-alexandria))
(arguments
- `(#:asd-systems '("ltk"
- "ltk-mw"
- "ltk-remote")
- #:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "ltk/ltk.lisp"
- (("#-freebsd \"wish\"")
- (string-append "#-freebsd \""
- (assoc-ref inputs "tk")
- "/bin/wish\""))
- (("do-execute \"convert\"")
- (string-append "do-execute \""
- (assoc-ref inputs "imagemagick")
- "/bin/convert\"")))
- #t))
- (add-after 'unpack 'fix-build
- (lambda _
- (substitute* "ltk/ltk-remote.lisp"
- (("\\(:export")
- "(:shadow #:raise) (:export"))
- #t)))))
- (synopsis "Common Lisp bindings for the Tk GUI toolkit")
+ '(#:asd-systems '("ctype" "ctype-tfun")))
+ (home-page "https://github.com/s-expressionists/ctype";)
+ (synopsis "Common Lisp type system implementation")
(description
- "LTK is a Common Lisp binding for the Tk graphics toolkit. It is
-written in pure Common Lisp and does not require any Tk knowledge for its
-usage.")
- (home-page "http://www.peter-herth.de/ltk/";)
- (license license:llgpl))))
+ "This system is an implementation of the Common Lisp type system;
+particularly @code{cl:typep} and @code{cl:subtypep}.")
+ (license license:bsd-2))))
-(define-public cl-ltk
- (sbcl-package->cl-source-package sbcl-ltk))
+(define-public cl-ctype
+ (sbcl-package->cl-source-package sbcl-ctype))
-(define-public ecl-ltk
- (sbcl-package->ecl-package sbcl-ltk))
+(define-public ecl-ctype
+ (sbcl-package->ecl-package sbcl-ctype))
-(define-public sbcl-cl-lex
- (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
- (revision "1"))
+(define-public sbcl-curry-compose-reader-macros
+ (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
+ (revision "0"))
(package
- (name "sbcl-cl-lex")
- (version (git-version "1.1.3" revision commit))
+ (name "sbcl-curry-compose-reader-macros")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/djr7C4/cl-lex";)
- (commit commit)))
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/curry-compose-reader-macros";)
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
+ (base32
+ "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-ppcre))
- (synopsis "Common Lisp macros for generating lexical analyzers")
+ (list sbcl-alexandria sbcl-named-readtables))
+ (synopsis "Reader macros for partial application and composition")
(description
- "This is a Common Lisp library providing a set of macros for generating
-lexical analyzers automatically. The lexers generated using @code{cl-lex} can
-be used with @code{cl-yacc}.")
- (home-page "https://github.com/djr7C4/cl-lex";)
- (license license:gpl3))))
-
-(define-public cl-lex
- (sbcl-package->cl-source-package sbcl-cl-lex))
+ "This Common Lisp library provides reader macros for concise expression
+of function partial application and composition.")
+ (home-page "https://eschulte.github.io/curry-compose-reader-macros/";)
+ (license license:public-domain))))
-(define-public ecl-cl-lex
- (sbcl-package->ecl-package sbcl-cl-lex))
-
-(define-public sbcl-cl-colors2
- (package
- (name "sbcl-cl-colors2")
- (version "0.6.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://codeberg.org/cage/cl-colors2";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-colors2" version))
- (sha256
- (base32 "0vnvlq9xixs04768q7hapsi16cjp3ych6mypvs6chihd5dal4cnd"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-clunit2))
- (inputs
- (list sbcl-alexandria sbcl-cl-ppcre sbcl-parse-number))
- (synopsis "Color library for Common Lisp")
- (description
- "This is a very simple color library for Common Lisp, providing:
-
-@itemize
-@item Types for representing colors in HSV, HSL, and RGB spaces.
-@item Simple conversion functions between the above types.
-@item Function printing colors to HEX, RGB, RGBA, and HSL.
-@item Predefined colors from X11, SVG, and GDK.
-@end itemize\n")
- (home-page "https://codeberg.org/cage/cl-colors2";)
- (license license:boost1.0)))
-
-(define-public cl-colors2
- (sbcl-package->cl-source-package sbcl-cl-colors2))
+(define-public cl-curry-compose-reader-macros
+ (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
-(define-public ecl-cl-colors2
- (sbcl-package->ecl-package sbcl-cl-colors2))
+(define-public ecl-curry-compose-reader-macros
+ (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
-(define-public sbcl-colored
- (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb")
- (revision "1"))
+(define-public sbcl-custom-hash-table
+ (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa"))
(package
- (name "sbcl-colored")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-custom-hash-table")
+ (version (git-version "0.3" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/colored/";)
+ (url "https://github.com/metawilm/cl-custom-hash-table";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k"))))
+ (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-documentation-utils))
- (synopsis "Colour representation, conversion, and operation for Common
Lisp")
- (description
- "This is a library for representing and mapping colours between their
-various spaces.")
- (home-page "https://shinmera.github.io/colored/";)
- (license license:zlib))))
+ (arguments
+ '(#:asd-systems '("cl-custom-hash-table")))
+ (home-page "https://github.com/metawilm/cl-custom-hash-table";)
+ (synopsis "Custom hash tables for Common Lisp")
+ (description "This library allows creation of hash tables with arbitrary
+@code{test}/@code{hash} functions, in addition to the @code{test} functions
+allowed by the standard (@code{EQ}, @code{EQL}, @code{EQUAL} and
+@code{EQUALP}), even in implementations that don't support this functionality
+directly.")
+ (license license:expat))))
-(define-public cl-colored
- (sbcl-package->cl-source-package sbcl-colored))
+(define-public cl-custom-hash-table
+ (sbcl-package->cl-source-package sbcl-custom-hash-table))
-(define-public ecl-colored
- (sbcl-package->ecl-package sbcl-colored))
+(define-public ecl-custom-hash-table
+ (sbcl-package->ecl-package sbcl-custom-hash-table))
-(define-public sbcl-cl-jpeg
- (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
+(define-public sbcl-cxml
+ (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
(revision "1"))
(package
- (name "sbcl-cl-jpeg")
- (version (git-version "2.8" revision commit))
+ (name "sbcl-cxml")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/cl-jpeg";)
+ (url "https://github.com/sharplispers/cxml";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
+ (base32
+ "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
(build-system asdf-build-system/sbcl)
- (synopsis "JPEG image library for Common Lisp")
- (description
- "This is a baseline JPEG codec written in Common Lisp. It can be used
-for reading and writing JPEG image files.")
- (home-page "https://github.com/sharplispers/cl-jpeg";)
- (license license:bsd-3))))
+ (inputs
+ (list sbcl-closure-common sbcl-puri sbcl-trivial-gray-streams))
+ (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.")
+ (home-page "https://common-lisp.net/project/cxml/";)
+ (license license:llgpl))))
-(define-public cl-jpeg
- (sbcl-package->cl-source-package sbcl-cl-jpeg))
+(define-public cl-cxml
+ (sbcl-package->cl-source-package sbcl-cxml))
-(define-public ecl-cl-jpeg
- (sbcl-package->ecl-package sbcl-cl-jpeg))
+(define-public ecl-cxml
+ (sbcl-package->ecl-package sbcl-cxml))
-(define-public sbcl-jpeg-turbo
- (let ((commit "f79c646cc266c107bdace53572a31664754c6e0c")
+(define-public sbcl-cxml-rng
+ (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b")
(revision "1"))
(package
- (name "sbcl-jpeg-turbo")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cxml-rng")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/shamazmazum/jpeg-turbo/";)
+ (url "http://www.lichteblau.com/git/cxml-rng.git";)
(commit commit)))
- (file-name (git-file-name "cl-jpeg-turbo" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1andd1ibbk3224idnpsnrn96flr5d1wm9ja3di57fs04wn577sag"))))
+ (base32
+ "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-lib-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/jpeg-turbo.lisp"
- (("\"libturbojpeg\\.so\\.0\"")
- (string-append "\""
- (search-input-file inputs
-
"/lib/libturbojpeg.so")
- "\""))))))))
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list libjpeg-turbo sbcl-cffi))
- (synopsis "Common Lisp wrapper for libjpeg-turbo")
- (description
- "This is a Common Lisp wrapper for libjpeg-turbo library which provides
-TurboJPEG API for compressing and decompressing JPEG images.")
- (home-page "https://github.com/shamazmazum/jpeg-turbo/";)
- (license license:bsd-2))))
+ (inputs
+ (list sbcl-cxml sbcl-cl-ppcre sbcl-cl-yacc sbcl-parse-number
+ sbcl-cl-base64))
+ (synopsis "Relax NG for Closure XML (CXML)")
+ (description "An implementation of Relax NG schema validation written in
+Common Lisp, including support for compact syntax, DTD Compatibility, and the
+XSD type library.")
+ (home-page "http://www.lichteblau.com/cxml-rng/";)
+ (license license:bsd-2))))
-(define-public cl-jpeg-turbo
- (sbcl-package->cl-source-package sbcl-jpeg-turbo))
+(define-public cl-cxml-rng
+ (sbcl-package->cl-source-package sbcl-cxml-rng))
-(define-public ecl-cl-jpeg-turbo
- (sbcl-package->ecl-package sbcl-jpeg-turbo))
+;; FIXME: Fails on ECL with
+;; In function STRUCTURE-SET, the value of the first argument is
+;; #<empty 0x7fffeb0fd440>
+;; which is not of the expected type %TYPED-PATTERN.
+;; (define-public ecl-cxml-rng
+;; (sbcl-package->ecl-package sbcl-cxml-rng))
-(define-public sbcl-png
- (let ((commit "11b965fe378fd0561abe3616b18ff03af5179648")
+(define-public sbcl-daemon
+ (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597")
(revision "1"))
(package
- (name "sbcl-png")
- (version (git-version "0.6" revision commit))
+ (name "sbcl-daemon")
+ (version (git-version "0.0.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ljosa/cl-png";)
+ (url "https://github.com/snmsts/daemon";)
(commit commit)))
- (file-name (git-file-name "cl-png" version))
+ (file-name (git-file-name "daemon" version))
(sha256
- (base32 "173hqwpd0rwqf95mfx1h9l9c3i8bb0gvnpspzmmz3g5x3440czy4"))
- ;; Patch to fix compiling with SBCL >= 2.1.6.
- (patches (search-patches "sbcl-png-fix-sbcl-compatibility.patch"))))
+ (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-lib-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "libpng.lisp"
- (("\"libpng\"")
- (string-append "\""
- (assoc-ref inputs "libpng")
- "/lib/libpng\""))))))))
(inputs
- `(("cffi" ,sbcl-cffi)
- ("libpng" ,libpng)))
- (home-page "https://github.com/ljosa/cl-png";)
- (synopsis "Read and write PNG file format")
+ (list sbcl-trivial-features))
+ (home-page "https://github.com/snmsts/daemon";)
+ (synopsis "Daemonize Common Lisp processes")
(description
- "This package provides a @code{PNG} Common Lisp system to operate with
-Portable Network Graphics file format.")
- (license license:lgpl2.1))))
+ "DAEMON provides the functionality of daemonizing Common Lisp processes
+on UNIX like platforms.")
+ (license license:expat))))
-(define-public ecl-png
- (sbcl-package->ecl-package sbcl-png))
+(define-public cl-daemon
+ (sbcl-package->cl-source-package sbcl-daemon))
-(define-public cl-png
- (sbcl-package->cl-source-package sbcl-png))
+(define-public ecl-daemon
+ (sbcl-package->ecl-package sbcl-daemon))
-(define-public sbcl-cl-svg
- (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc")
+(define-public sbcl-data-format-validation
+ (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb")
(revision "1"))
(package
- (name "sbcl-cl-svg")
- (version (git-version "0.0.3" revision commit))
+ (name "sbcl-data-format-validation")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/wmannis/cl-svg";)
- (commit commit)))
- (file-name (git-file-name "cl-svg" version))
+ (uri
+ (git-reference
+ (url "https://github.com/willijar/cl-data-format-validation/";)
+ (commit commit)))
+ (file-name (git-file-name "data-format-validation" version))
(sha256
- (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz"))))
+ (base32
+ "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/wmannis/cl-svg";)
- (synopsis "Write SVG file format")
+ (inputs
+ (list sbcl-cl-ppcre))
+ (synopsis "Validation and conversion between user and internal data")
(description
- "This package provides the @code{CL-SVG} Common Lisp system to produce
-Scalable Vector Graphics files.")
- (license license:expat))))
+ "@code{data-format-validation} is a library for Common Lisp providing a
+consistent regular interface for converting (and validating) external data (in
+the form of strings usually) into internal data types and for formatting
+internal data back into external presentable strings, all according to a
+conversion or type specification.")
+ (home-page "http://www.jarw.org.uk/lisp/cl-data-format-validation.html";)
+ (license license:gpl3))))
-(define-public ecl-cl-svg
- (sbcl-package->ecl-package sbcl-cl-svg))
-
-(define-public cl-svg
- (sbcl-package->cl-source-package sbcl-cl-svg))
-
-(define-public sbcl-nodgui
- (let ((commit "9d0c9731bc2f2b434f0ddabe4b3796432aad8cba")
- (revision "1"))
+(define-public sbcl-data-frame
+ (let ((commit "6f02e58312654ddf19d686f234dcf699fc4cd0f5")
+ (revision "0"))
(package
- (name "sbcl-nodgui")
- (version (git-version "0.6.2.0" revision commit))
+ (name "sbcl-data-frame")
+ (version (git-version "1.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/cage/nodgui.git";)
+ (url "https://github.com/Lisp-Stat/data-frame";)
(commit commit)))
- (file-name (git-file-name "cl-nodgui" version))
+ (file-name (git-file-name "cl-data-frame" version))
(sha256
- (base32 "0j98mcq0mn3wrlqm3j29pv530q0pkq00sk6liai97an51i1n08g6"))))
+ (base32 "0bs1jh66bml25bj1lxdzz8cjhj3g060yyd5ggqsnsr4l2j0zyszv"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-clunit2))
+ (native-inputs (list sbcl-clunit2))
(inputs
(list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cl-colors2
- sbcl-cl-ppcre-unicode
- sbcl-cl-unicode
- sbcl-esrap
- sbcl-flexi-streams
- sbcl-jpeg-turbo
- sbcl-named-readtables
- sbcl-cl-opengl
- sbcl-parse-number
- sbcl-pngload
- sbcl-sdl2
- sbcl-static-vectors
- sbcl-trivial-garbage
- sbcl-zpng
- tk
- tklib))
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/wish-communication.lisp"
- (("#-freebsd \"wish\"")
- (string-append "#-freebsd \""
- (search-input-file inputs "/bin/wish")
- "\""))))))))
- (synopsis "Common Lisp bindings for the Tk GUI toolkit")
- (description
- "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
-toolkit. It also provides a few additional widgets more than the standard Tk
-ones.")
- (home-page "https://www.autistici.org/interzona/nodgui.html";)
- (license license:llgpl))))
+ sbcl-alexandria-plus
+ sbcl-anaphora
+ sbcl-array-operations
+ sbcl-duologue
+ sbcl-let-plus
+ sbcl-numerical-utilities
+ sbcl-select
+ sbcl-serapeum
+ sbcl-statistics))
+ (home-page "https://lisp-stat.dev/docs/manuals/data-frame/";)
+ (synopsis "Data frames for Common Lisp")
+ (description "This package provides data frames for Common Lisp, a
+two-dimensional array-like structure in which each column contains values
+of one variable and each row contains one set of values from each column.")
+ (license license:ms-pl))))
-(define-public cl-nodgui
- (sbcl-package->cl-source-package sbcl-nodgui))
+(define-public cl-data-frame
+ (sbcl-package->cl-source-package sbcl-data-frame))
-(define-public ecl-nodgui
- (sbcl-package->ecl-package sbcl-nodgui))
+;; The data-frame system depends on the sb-cltl2 system, which is only
+;; available with SBCL.
+;; (define-public ecl-data-frame
+;; (sbcl-package->ecl-package sbcl-data-frame))
-(define-public sbcl-salza2
- (package
- (name "sbcl-salza2")
- (version "2.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/xach/salza2";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1p48lxdibnps5rpyh5cmnk0vc77bmmxb32qdzfz93zadr8wwas10"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-chipz sbcl-flexi-streams sbcl-parachute))
- (inputs
- (list sbcl-trivial-gray-streams))
- (synopsis "Common Lisp library for zlib, deflate and gzip compression")
- (description
- "Salza2 is a Common Lisp library for creating compressed data in the zlib,
-deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
-respectively.")
- (home-page "https://www.xach.com/lisp/salza2/";)
- (license license:bsd-2)))
+(define-public sbcl-data-lens
+ (let ((commit "801bc1e0331f19fdc38be314c86ccac9362fde78")
+ (revision "0"))
+ (package
+ (name "sbcl-data-lens")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fiddlerwoaroof/data-lens";)
+ (commit commit)))
+ (file-name (git-file-name "cl-data-lens" version))
+ (sha256
+ (base32 "1w4rvhcnss037q0bb1j70kdlhfh9085hy95d9q56sk519alhzhrp"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-cl-ppcre
+ sbcl-alexandria
+ sbcl-serapeum))
+ (synopsis "Functional utilities for Common Lisp")
+ (description
+ "The @code{cl-data-lens} library provides a language for expressing data
+manipulations as the composition of more primitive operations.")
+ (home-page "https://fiddlerwoaroof.github.io/data-lens/";)
+ (license license:asl2.0))))
-(define-public cl-salza2
- (sbcl-package->cl-source-package sbcl-salza2))
+(define-public cl-data-lens
+ (sbcl-package->cl-source-package sbcl-data-lens))
-(define-public ecl-salza2
- (sbcl-package->ecl-package sbcl-salza2))
+(define-public ecl-data-lens
+ (sbcl-package->ecl-package sbcl-data-lens))
-(define-public sbcl-origin
- (let ((commit "d646134302456408d6d43580bb05299f1695ab8e")
+(define-public sbcl-data-sift
+ (let ((commit "fd617d8200cdcc1b87ecf45ab59bb38e8b16ef7e")
(revision "1"))
(package
- (name "sbcl-origin")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-data-sift")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.mfiano.net/mfiano/origin";)
+ (url "https://github.com/archimag/data-sift";)
(commit commit)))
- (file-name (git-file-name "origin" version))
+ (file-name (git-file-name "cl-data-sift" version))
(sha256
- (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b"))))
+ (base32 "1v7gf0x4ibjzp0c56n9m77hxdgwcm9356zlk5n4l3fx4i0hj6146"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
+ (arguments
+ ;; All test cases test a function that has been removed.
+ `(#:tests? #f))
(inputs
- (list sbcl-golden-utils sbcl-specialization-store))
- (home-page "https://git.mfiano.net/mfiano/origin";)
- (synopsis "Common Lisp graphics math library")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("parse-number" ,sbcl-parse-number)
+ ("puri" ,sbcl-puri)))
+ (native-inputs
+ (list sbcl-lift))
+ (home-page "https://github.com/archimag/data-sift";)
+ (synopsis
+ "Common Lisp library for validation and transformation of string data")
(description
- "This is a native Common Lisp graphics math library with an emphasis on
-performance and correctness.")
- (license license:expat))))
+ "@code{DATA-SIFT} is a Common Lisp data validation and transformation
+library inspired by @code{cl-data-format-validation} and WTForms validators.")
+ (license license:llgpl))))
-(define-public ecl-origin
- (sbcl-package->ecl-package sbcl-origin))
+(define-public cl-data-sift
+ (sbcl-package->cl-source-package sbcl-data-sift))
-(define-public cl-origin
- (sbcl-package->cl-source-package sbcl-origin))
+(define-public ecl-data-sift
+ (sbcl-package->ecl-package sbcl-data-sift))
-(define-public sbcl-png-read
- (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
+(define-public sbcl-datafly
+ (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d")
(revision "1"))
(package
- (name "sbcl-png-read")
- (version (git-version "0.3.1" revision commit))
+ (name "sbcl-datafly")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/fukamachi/datafly";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Ramarren/png-read";)
+ (url home-page)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
+ (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-babel sbcl-chipz 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";)
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("optima" ,sbcl-optima)
+ ("trivial-types" ,sbcl-trivial-types)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("cl-syntax" ,sbcl-cl-syntax)
+ ("sxql" ,sbcl-sxql)
+ ("dbi" ,sbcl-dbi)
+ ("babel" ,sbcl-babel)
+ ("local-time" ,sbcl-local-time)
+ ("function-cache" ,sbcl-function-cache)
+ ("jonathan" ,sbcl-jonathan)
+ ("kebab" ,sbcl-kebab)
+ ("log4cl" ,sbcl-log4cl)))
+ (native-inputs
+ (list sbcl-prove))
+ (arguments
+ ;; TODO: Tests fail with
+ ;; While evaluating the form starting at line 22, column 0
+ ;; of
#P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp":
+ ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main
thread" RUNNING
+ ;; {10009F8083}>:
+ ;; Error when binding parameter 1 to value NIL.
+ ;; Code RANGE: column index out of range.
+ `(#:tests? #f))
+ (synopsis "Lightweight database library for Common Lisp")
+ (description "Datafly is a lightweight database library for Common
Lisp.")
(license license:bsd-3))))
-(define-public cl-png-read
- (sbcl-package->cl-source-package sbcl-png-read))
+(define-public cl-datafly
+ (sbcl-package->cl-source-package sbcl-datafly))
-(define-public ecl-png-read
- (sbcl-package->ecl-package sbcl-png-read))
+(define-public ecl-datafly
+ (sbcl-package->ecl-package sbcl-datafly))
-(define-public sbcl-3b-bmfont
- (let ((commit "332c2262705f161627fc18add0310451a42799af")
- (revision "3"))
+(define-public sbcl-db3
+ (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d")
+ (revision "1"))
(package
- (name "sbcl-3b-bmfont")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-db3")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/3b-bmfont/";)
+ (url "https://github.com/dimitri/cl-db3";)
(commit commit)))
- (file-name (git-file-name "cl-3b-bmfont" version))
+ (file-name (git-file-name "cl-db3" version))
(sha256
- (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6"))))
+ (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("3b-bmfont"
- "3b-bmfont/common"
- "3b-bmfont/json"
- "3b-bmfont/text"
- "3b-bmfont/xml")))
- (inputs
- (list sbcl-alexandria
- sbcl-cxml
- sbcl-flexi-streams
- sbcl-jsown
- sbcl-parse-number
- sbcl-split-sequence))
- (home-page "https://github.com/3b/3b-bmfont/";)
- (synopsis "Read/write bmfont metadata files")
+ (home-page "https://github.com/dimitri/cl-db3";)
+ (synopsis "Common Lisp library to read dBase III database files")
(description
- "This is a Common Lisp library which provides functionality to
-read/write Bit Map Font (BMF) into text, JSON and XML.")
- (license license:expat))))
-
-(define-public ecl-3b-bmfont
- (sbcl-package->ecl-package sbcl-3b-bmfont))
+ "This is a Common Lisp library for processing data found in dBase III
+database files (dbf and db3 files).")
+ (license license:public-domain))))
-(define-public cl-3b-bmfont
- (sbcl-package->cl-source-package sbcl-3b-bmfont))
+(define-public cl-db3
+ (sbcl-package->cl-source-package sbcl-db3))
-(define sbcl-3b-bmfont/shinmera
- (let ((commit "58e529d24b7799d56b4b3f9c8a953b585d42c7d2")
- (revision "1"))
- (package (inherit sbcl-3b-bmfont)
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/3b-bmfont/";)
- (commit commit)))
- (file-name (git-file-name "3b-bmfont2" version))
- (sha256
- (base32
"17zby669b64rhxhk2szamzdgvispimh6ici05xa6x2vz4rvk71jq")))))))
+(define-public ecl-db3
+ (sbcl-package->ecl-package sbcl-db3))
-(define-public sbcl-sdf
- ;; Shinmera's fork required for Alloy.
- (let ((commit "e1ab3ac4ea52c0e0119b832f428c71f580b4d83b")
- (revision "1"))
+(define-public sbcl-dbi
+ (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227")
+ (revision "2"))
(package
- (name "sbcl-sdf")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-dbi")
+ (version (git-version "0.9.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/sdf";)
+ (url "https://github.com/fukamachi/cl-dbi";)
(commit commit)))
- (file-name (git-file-name "sdf" version))
+ (file-name (git-file-name "cl-dbi" version))
(sha256
- (base32 "1cyq4hkgiw9mnb87ah6xw19cybfs9hfbjvg1ch2mf4cr0ism0nvn"))))
+ (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("rove" ,sbcl-rove)
+ ("trivial-types" ,sbcl-trivial-types)))
(inputs
- (list sbcl-zpb-ttf
- sbcl-cl-vectors
- sbcl-opticl
- sbcl-binpack
- sbcl-3b-bmfont/shinmera
- sbcl-pathname-utils))
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-mysql" ,sbcl-cl-mysql)
+ ("cl-sqlite" ,sbcl-cl-sqlite)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("postmodern" ,sbcl-postmodern)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
(arguments
- `(#:asd-systems '("sdf" "sdf/bmfont")))
- (home-page "https://github.com/Shinmera/sdf";)
- (synopsis "Signed distance font atlas generator")
+ `(#:asd-systems '("dbi"
+ "dbd-mysql"
+ "dbd-postgres"
+ "dbd-sqlite3")))
+ (synopsis "Database independent interface for Common Lisp")
(description
- "This library generates
-sdf
(@url{https://steamcdn-a.akamaihd.net/apps/valve/2007/SIGGRAPH2007_AlphaTestedMagnification.pdf}),
-psdf and
-msdf (@url{https://github.com/Chlumsky/msdfgen/files/3050967/thesis.pdf})
-atlases.")
- (license license:expat))))
+ "@code{dbi} is a Common Lisp library providing a database independent
+interface for MySQL, PostgreSQL and SQLite.")
+ (home-page "https://github.com/fukamachi/cl-dbi";)
+ (license license:llgpl))))
-(define-public ecl-sdf
- (sbcl-package->ecl-package sbcl-sdf))
+(define-public cl-dbi
+ (sbcl-package->cl-source-package sbcl-dbi))
-(define-public cl-sdf
- (sbcl-package->cl-source-package sbcl-sdf))
+(define-public ecl-dbi
+ (sbcl-package->ecl-package sbcl-dbi))
-(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";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list 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 sbcl-dbus
+ (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
+ (revision "1"))
+ (package
+ (name "sbcl-dbus")
+ (version (git-version "20190408" revision commit))
+ (home-page "https://github.com/death/dbus";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-trivial-garbage
+ sbcl-babel
+ sbcl-iolib
+ sbcl-ieee-floats
+ sbcl-flexi-streams
+ sbcl-cl-xmlspam
+ sbcl-ironclad))
+ (synopsis "D-Bus client library for Common Lisp")
+ (description "This is a Common Lisp library that publishes D-Bus
+objects as well as send and notify other objects connected to a bus.")
+ (license license:bsd-2))))
-(define-public cl-zpng
- (sbcl-package->cl-source-package sbcl-zpng))
+(define-public cl-dbus
+ (sbcl-package->cl-source-package sbcl-dbus))
-(define-public ecl-zpng
- (sbcl-package->ecl-package sbcl-zpng))
+(define-public ecl-dbus
+ (sbcl-package->ecl-package sbcl-dbus))
-(define-public sbcl-cl-qrencode
+(define-public sbcl-decimals
(package
- (name "sbcl-cl-qrencode")
- (version "0.1.2")
+ (name "sbcl-decimals")
+ (version "2021")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jnjcc/cl-qrencode";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (url "https://github.com/tlikonen/cl-decimals";)
+ (commit version)))
+ (file-name (git-file-name "cl-decimals" version))
(sha256
- (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
+ (base32 "0wn5hq1pwd3wpjqqhpjzarcdk1q6416g8y447iaf55j5nbhlmbn6"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
- (inputs
- (list 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+)))
+ (home-page "https://github.com/tlikonen/cl-decimals";)
+ (synopsis "Decimal number parser and formatting package for Common Lisp")
+ (description "This Common Lisp package offers functions for parsing and
+formatting decimal numbers. The package's main interface are the functions
+@code{parse-decimal-number} and @code{format-decimal-number}. The former is
+for parsing strings for decimal numbers and the latter for pretty-printing
+them as strings.")
+ (license license:cc0)))
-(define-public cl-qrencode
- (sbcl-package->cl-source-package sbcl-cl-qrencode))
+(define-public cl-decimals
+ (sbcl-package->cl-source-package sbcl-decimals))
-(define-public ecl-cl-qrencode
- (sbcl-package->ecl-package sbcl-cl-qrencode))
+(define-public ecl-decimals
+ (sbcl-package->ecl-package sbcl-decimals))
-(define-public sbcl-hdf5-cffi
- (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
- (revision "1"))
+(define-public sbcl-deeds
+ ;; taged branch is outdated
+ (let ((revision "1")
+ (commit "f5df54eac79b58a34030e0eb8acf3952c788410d"))
(package
- (name "sbcl-hdf5-cffi")
- (version (git-version "1.8.18" revision commit))
+ (name "sbcl-deeds")
+ (version (git-version "1.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hdfgroup/hdf5-cffi";)
+ (url "https://github.com/Shinmera/deeds";)
(commit commit)))
- (file-name (git-file-name "cl-hdf5-cffi" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
+ (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k"))))
(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
- (list hdf5-1.10 sbcl-cffi))
- (native-inputs
- (list sbcl-fiveam))
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libhdf5.so")
- (search-input-file inputs "/lib/libhdf5.so")))))
- (add-after 'fix-paths 'fix-newer-hdf5-compatibility
- (lambda _
- (substitute* (list "src/h5-grovel.lisp"
- "src/h5a-grovel.lisp"
- "src/h5d-grovel.lisp"
- "src/h5f-grovel.lisp"
- "src/h5g-grovel.lisp"
- "src/h5i-grovel.lisp"
- "src/h5l-grovel.lisp"
- "src/h5o-grovel.lisp"
- "src/h5p-grovel.lisp"
- "src/h5pl-grovel.lisp"
- "src/h5r-grovel.lisp"
- "src/h5s-grovel.lisp"
- "src/h5t-grovel.lisp"
- "src/h5z-grovel.lisp")
- (("_H5private_H")
- "H5private_H"))))
- (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"))))))))))
+ (list sbcl-bordeaux-threads sbcl-closer-mop sbcl-form-fiddle
+ sbcl-lambda-fiddle))
+ (home-page "https://github.com/Shinmera/deeds";)
+ (synopsis "Extensible Event Delivery System")
+ (description
+ "@code{deeds} allows for efficient event delivery to multiple handlers
+with a complex event filtering system.")
+ (license license:zlib))))
-(define-public cl-hdf5-cffi
- (sbcl-package->cl-source-package sbcl-hdf5-cffi))
+(define-public cl-deeds
+ (sbcl-package->cl-source-package sbcl-deeds))
-(define-public ecl-hdf5-cffi
- (sbcl-package->ecl-package sbcl-hdf5-cffi))
+(define-public ecl-deeds
+ (sbcl-package->ecl-package sbcl-deeds))
-(define-public sbcl-history-tree
+(define-public sbcl-definitions
+ (let ((commit "1f4bd7a634a2299aea19cefb5da8041bbb27f2ec"))
+ (package
+ (name "sbcl-definitions")
+ (version (git-version "1.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/definitions/";)
+ (commit commit)))
+ (file-name (git-file-name "cl-definitions" version))
+ (sha256
+ (base32 "16dh9iy3v344xj4qllsp47007px3yx26fxxh9gh2cvs8dqgk3kch"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/definitions";)
+ (synopsis "General definitions reflection library")
+ (description
+ "This system implements a general definitions introspection library.
+It gives you the ability to retrieve definitions or bindings associated with
+designators such as symbols, packages, and names in general. For instance, it
+allows you to retrieve all function, type, variable, method, etc. definitions
+of a symbol.")
+ (license license:zlib))))
+
+(define-public cl-definitions
+ (sbcl-package->cl-source-package sbcl-definitions))
+
+(define-public ecl-definitions
+ (sbcl-package->ecl-package sbcl-definitions))
+
+(define-public sbcl-definitions-systems
(package
- (name "sbcl-history-tree")
- (version "0.1.2")
+ (name "sbcl-definitions-systems")
+ (version "2.0.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/history-tree";)
- (commit version)))
- (file-name (git-file-name "cl-history-tree" version))
+ (url "https://github.com/Hexstream/definitions-systems";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-definitions-systems" version))
(sha256
- (base32 "1n3q6aqh0wm24pksj8371j5iinxpzy2kcnz97kmpndm1yhv4x5f2"))))
+ (base32 "009392mj0qdq4jy0dw5r41schnygwj286759yvyg7xja30a0psfq"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list
- sbcl-alexandria
- sbcl-custom-hash-table
- sbcl-local-time
- sbcl-nclasses
- sbcl-trivial-package-local-nicknames))
- (native-inputs (list sbcl-lisp-unit2))
- (home-page "https://github.com/atlas-engineer/history-tree";)
- (synopsis "Store the history of a browser's visited paths")
+ (list sbcl-canonicalized-initargs
+ sbcl-enhanced-defclass
+ sbcl-enhanced-find-class
+ sbcl-shared-preferences))
+ (home-page "https://www.hexstreamsoft.com/libraries/definitions-systems/";)
+ (synopsis "Unified extensible way of processing named definitions")
(description
- "This data structure can be used to store the history of visited paths or
-URLs with a file or web browser, in a way that no “forward” element is ever
-forgotten.
-
-The history tree is “global” in the sense that multiple owners (e.g. tabs) can
-have overlapping histories. On top of that, an owner can spawn another one,
-starting from one of its nodes (typically when you open a URL in a new tab).")
- (license license:bsd-3)))
+ "@code{definitions-systems} provides a simple unified extensible way of
+processing named definitions.")
+ (license license:unlicense)))
-(define-public cl-history-tree
- (sbcl-package->cl-source-package sbcl-history-tree))
+(define-public cl-definitions-systems
+ (sbcl-package->cl-source-package sbcl-definitions-systems))
-(define-public ecl-history-tree
- (sbcl-package->ecl-package sbcl-history-tree))
+(define-public ecl-definitions-systems
+ (sbcl-package->ecl-package sbcl-definitions-systems))
-(define-public sbcl-cl-randist
+(define-public sbcl-deflate
(package
- (name "sbcl-cl-randist")
- (version "0.4.2")
+ (name "sbcl-deflate")
+ (version "1.0.3")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lvaruzza/cl-randist";)
- (commit "f088a54b540a7adefab7c04094a6103f9edda3d0")))
+ (url "https://github.com/pmai/Deflate";)
+ (commit (string-append "release-" version))))
(file-name (git-file-name name version))
(sha256
- (base32
- "0l8hyd6nbxb7f50vyxz3rbbm7kgr1fnadc40jywy4xj5vi5kpj5g"))))
+ (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Random distributions for Common Lisp")
+ (home-page "https://github.com/pmai/Deflate";)
+ (synopsis "Native deflate decompression 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
- `(#:tests? #f))))
+ "This library is an implementation of Deflate (RFC 1951) decompression,
+with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952)
+wrappers of deflate streams. It currently does not handle compression.")
+ (license license:expat)))
-(define-public cl-randist
- (sbcl-package->cl-source-package sbcl-cl-randist))
+(define-public cl-deflate
+ (sbcl-package->cl-source-package sbcl-deflate))
-(define-public ecl-cl-randist
- (sbcl-package->ecl-package sbcl-cl-randist))
+(define-public ecl-deflate
+ (sbcl-package->ecl-package sbcl-deflate))
-(define-public sbcl-float-features
- (let ((commit "c1f86aea91cfaa3aa59799162be23ef8a12b199d")
- (revision "2"))
+(define-public sbcl-defpackage-plus
+ (let ((revision "0")
+ (commit "5492e27e0bdb7b75fa5177ea4388519dc7a75f11"))
(package
- (name "sbcl-float-features")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-defpackage-plus")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/float-features";)
+ (url "https://github.com/rpav/defpackage-plus";)
(commit commit)))
- (file-name (git-file-name "float-features" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0vqm9xhn2i4vbjrxnp4hr1l3lydjflhjykdz6cmqg2j48c5kh3g3"))))
+ (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq"))))
(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
- `(#: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";)
- (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
- `(#:tests? #f))))
+ (list sbcl-alexandria))
+ (home-page "https://github.com/rpav/defpackage-plus";)
+ (synopsis "Extensible @code{DEFPACKAGE} variant with version support")
+ (description
+ "@code{DEFPACKAGE-PLUS} is an extensible @code{DEFPACKAGE} variant with
+predictable cross-platform behavior and some utilities useful for versioning.")
+ (license license:bsd-2))))
-(define-public cl-function-cache
- (sbcl-package->cl-source-package sbcl-function-cache))
+(define-public cl-defpackage-plus
+ (sbcl-package->cl-source-package sbcl-defpackage-plus))
-(define-public ecl-function-cache
- (sbcl-package->ecl-package sbcl-function-cache))
+(define-public ecl-defpackage-plus
+ (sbcl-package->ecl-package sbcl-defpackage-plus))
-(define-public sbcl-cache-while
- (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7")
- (revision "1"))
+(define-public sbcl-defstar
+ (let ((commit "132829dac9f84fa7202a0c5793aa6accb8d2662a"))
(package
- (name "sbcl-cache-while")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-defstar")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charje/cache-while";)
+ (url "http://bitbucket.org/eeeickythump/defstar/";)
(commit commit)))
- (file-name (git-file-name "cache-while" version))
+ (file-name (git-file-name "cl-defstar" version))
(sha256
- (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3"))))
+ (base32 "0n6m3aqvdfnsrhlhqjcy72d1i55lbkjg13ij5c7vw003p1n78wxi"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/charje/cache-while";)
- (synopsis "Temporary / one-time caching macro for Common Lisp")
+ (home-page "http://bitbucket.org/eeeickythump/defstar/";)
+ (synopsis "Easy inline (return) type declarations for functions")
(description
- "This is a Common Lisp macro for defining temporary caches that
-invalidate based on expressions evaluating to different values.")
- (license license:llgpl))))
-
-(define-public cl-cache-while
- (sbcl-package->cl-source-package sbcl-cache-while))
+ "Defstar is a collection of Common Lisp macros that can be used in
+place of @code{defun}, @code{defmethod}, @code{defgeneric}, @code{defvar},
+@code{defparameter}, @code{flet}, @code{labels}, @code{let*} and
+@code{lambda}. Each macro has the same name as the form it replaces, with a
+star added at the end, e.g. @code{defun}. (the exception is the @code{let*}
+replacement, which is called @code{*let}).")
+ (license license:gpl3))))
-(define-public ecl-cache-while
- (sbcl-package->ecl-package sbcl-cache-while))
+(define-public cl-defstar
+ (sbcl-package->cl-source-package sbcl-defstar))
-(define-public sbcl-type-r
- (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
- (revision "1"))
+(define-public ecl-defstar
+ (sbcl-package->ecl-package sbcl-defstar))
+
+(define-public sbcl-deploy
+ (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8")
+ (revision "2"))
(package
- (name "sbcl-type-r")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-deploy")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/type-r";)
+ (url "https://github.com/Shinmera/deploy";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "deploy" version))
(sha256
- (base32
- "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
+ (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1"))))
(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
- (list sbcl-fiveam)))))
+ (list sbcl-cl-mpg123 sbcl-cl-out123))
+ (inputs
+ (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-features))
+ (home-page "https://shinmera.github.io/deploy/";)
+ (synopsis "Deployment tools for standalone Common Lisp application")
+ (description
+ "This is a system to help you easily and quickly deploy standalone
+common lisp applications as binaries. Specifically it is geared towards
+applications with foreign library dependencies that run some kind of GUI.")
+ (license license:artistic2.0))))
-(define-public cl-type-r
- (sbcl-package->cl-source-package sbcl-type-r))
+(define-public cl-deploy
+ (sbcl-package->cl-source-package sbcl-deploy))
-(define-public ecl-type-r
- (sbcl-package->ecl-package sbcl-type-r))
+(define-public ecl-deploy
+ (sbcl-package->ecl-package sbcl-deploy))
-(define-public sbcl-trivialib-type-unify
- (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
+(define-public sbcl-depot
+ (let ((commit "73822d9f480cbad00971b45ee80117297a67fb53")
(revision "1"))
(package
- (name "sbcl-trivialib-type-unify")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-depot")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/trivialib.type-unify";)
+ (url "https://github.com/Shinmera/depot/";)
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32
- "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
+ (base32 "1v42pirdwbxy8l8i9a2jmbpri8a62vh0r4vm25xwaak0y4gr71va"))
+ (file-name (git-file-name "depot" version))))
(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
- (list sbcl-fiveam))
+ (list sbcl-atomics
+ sbcl-babel
+ sbcl-documentation-utils
+ sbcl-trivial-features
+ sbcl-trivial-gray-streams
+ sbcl-zippy))
+ ;; TODO: Some 6 tests fail, why? See
https://github.com/Shinmera/depot/issues/2.
(arguments
- `(#:asd-systems '("trivialib.type-unify"))))))
+ '(#:asd-systems '("depot"
+ "depot-in-memory"
+ "depot-virtual"
+ "depot-zip")))
+ (synopsis "Protocol for transparent collections of files")
+ (description "This is a system presenting a protocol for \"file
+systems\": things that present a collection of \"files,\" which are things
+that have several attributes, and a central data payload. Most notably this
+includes the OS filesystem, but can also be used to address other
+filesystem-like things like archives, object stores, etc. in the same
+manner.")
+ (home-page "https://shinmera.github.io/depot/";)
+ (license license:zlib))))
-(define-public cl-trivialib-type-unify
- (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
+(define-public cl-depot
+ (sbcl-package->cl-source-package sbcl-depot))
-(define-public ecl-trivialib-type-unify
- (sbcl-package->ecl-package sbcl-trivialib-type-unify))
+(define-public ecl-depot
+ (sbcl-package->ecl-package sbcl-depot))
-(define-public sbcl-cl-unification
- (let ((commit "01079f34d197495880aa49ab727d63774d83035c")
- (revision "1"))
+(define-public sbcl-dexador
+ (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5")
+ (revision "2"))
(package
- (name "sbcl-cl-unification")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-dexador")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.9.15" revision commit))
+ (home-page "https://github.com/fukamachi/dexador";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url
"https://gitlab.common-lisp.net/cl-unification/cl-unification";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-unification" version))
+ (file-name (git-file-name "cl-dexador" version))
(sha256
- (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-ptester))
+ (base32 "1sggpi43la8dai102fmkzysh7760hvk6q68f0pkbb9187vz8nd3y"))))
(inputs
- (list sbcl-cl-ppcre))
- (home-page "https://common-lisp.net/project/cl-unification/";)
- (synopsis "Unification framework for Common Lisp")
- (description
- "This package provides a framework to unify arbitrary
-Common Lisp objects while constructing bindings for placeholders
-(unification variables) in a template sublanguage.")
- (license license:bsd-0))))
-
-(define-public ecl-cl-unification
- (let ((pkg (sbcl-package->ecl-package sbcl-cl-unification)))
- (package
- (inherit pkg)
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-chipz
+ sbcl-chunga
+ sbcl-cl+ssl
+ sbcl-cl-base64
+ sbcl-cl-cookie
+ sbcl-cl-ppcre
+ sbcl-fast-http
+ sbcl-fast-io
+ sbcl-quri
+ sbcl-trivial-garbage
+ sbcl-trivial-gray-streams
+ sbcl-trivial-mimes
+ sbcl-usocket))
+ ;; These native-inputs are for tests only, which are disabled.
+ ;; Leave them commented since they add a lot to the closure size.
+ ;; (native-inputs
+ ;; (list sbcl-clack
+ ;; sbcl-lack
+ ;; sbcl-rove))
(arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; The tests fail on ECL with:
- ;; "In MAKE-ARRAY: the elements in :INITIAL-CONTENTS do not match
- ;; the array dimensions."
- ((#:tests? _ #f) #f))))))
+ ;; 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 cl-unification
- (sbcl-package->cl-source-package sbcl-cl-unification))
+(define-public cl-dexador
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-dexador))
+ (arguments
+ `(#:phases
+ ;; asdf-build-system/source has its own phases and does not inherit
+ ;; from asdf-build-system/sbcl phases.
+ (modify-phases %standard-phases/source
+ ;; Already done in SBCL package.
+ (delete 'reset-gzip-timestamps))))))
-(define-public sbcl-specialized-function
- (let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247")
- (revision "3"))
+(define-public ecl-dexador
+ (sbcl-package->ecl-package sbcl-dexador))
+
+(define-public sbcl-dfio
+ (let ((commit "5caf473acb9bc464839e87395724cbd941167915")
+ (revision "0"))
(package
- (name "sbcl-specialized-function")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-dfio")
+ (version (git-version "1.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/numcl/specialized-function";)
+ (url "https://github.com/Lisp-Stat/dfio";)
(commit commit)))
- (file-name (git-file-name "specialized-function" version))
+ (file-name (git-file-name "cl-dfio" version))
(sha256
- (base32 "19hfgc83b7as630r1w9r8yl0v6xq3dn01vcrl0bd4pza5hgjn4la"))))
+ (base32 "1p53r7773939jnap518xp4b4wfvc1kbrz9jp6yd40xq0jpf9pbqg"))))
(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
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("lisp-namespace" ,sbcl-lisp-namespace)
- ("trivia" ,sbcl-trivia)
- ("trivial-cltl2" ,sbcl-trivial-cltl2)
- ("type-r" ,sbcl-type-r)))
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-data-frame
+ sbcl-dexador
+ sbcl-fare-csv
+ sbcl-let-plus
+ sbcl-yason))
(native-inputs
- (list sbcl-fiveam)))))
+ (list sbcl-clunit2))
+ (home-page "https://lisp-stat.dev/docs/manuals/data-frame/";)
+ (synopsis "Read data to and from data frames")
+ (description "This package provides tools for manipulating data
+in files using data frames.")
+ (license license:ms-pl))))
-(define-public cl-specialized-function
- (sbcl-package->cl-source-package sbcl-specialized-function))
+(define-public cl-dfio
+ (sbcl-package->cl-source-package sbcl-dfio))
-(define-public ecl-specialized-function
- (sbcl-package->ecl-package sbcl-specialized-function))
+;; This depends on ecl-data-frame, which doesn't work yet.
+;; (define-public ecl-dfio
+;; (sbcl-package->ecl-package sbcl-dfio))
-(define-public sbcl-conduit-packages
- (package
- (name "sbcl-conduit-packages")
- (version "2.0.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tfeb/conduit-packages";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-conduit-packages" version))
- (sha256
- (base32 "1n783in84mrk9lnc3nshwsgxhb8y0dk6ys9z6jlxkv0jpjxhpjjc"))))
- (build-system asdf-build-system/sbcl)
- (arguments '(#:asd-systems '("org.tfeb.conduit-packages")))
- (synopsis "Conduit packages for Common Lisp")
- (description "This library defines a way of treating Common Lisp
-packages as conduits which can sit between one or more implementation
-packages and users of those packages.")
- (home-page "https://github.com/tfeb/conduit-packages/";)
- (license license:expat)))
-
-(define-public cl-conduit-packages
- (sbcl-package->cl-source-package sbcl-conduit-packages))
-
-(define-public ecl-conduit-packages
- (sbcl-package->ecl-package sbcl-conduit-packages))
-
-(define-public sbcl-constantfold
- (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
+(define-public sbcl-diff
+ (let ((commit "9c84befa598d4e07c3d223242b5b3f83cd94f301")
(revision "1"))
(package
- (name "sbcl-constantfold")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-diff")
+ (version (git-version "0.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/numcl/constantfold";)
+ (url "https://github.com/froydnj/diff";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-diff" version))
(sha256
- (base32
- "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
+ (base32 "1giafck8qfvb688kx5bn9g32rfc12jjywg8vdav36aqbd6lxf5z5"))))
(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
- (list sbcl-fiveam)))))
+ (list sbcl-cl-ppcre sbcl-trivial-gray-streams))
+ (home-page "https://github.com/froydnj/diff";)
+ (synopsis "Common Lisp library for computing differences between files")
+ (description
+ "DIFF is a package for computing various forms of differences between
+blobs of data and then doing neat things with those differences. Currently
diff
+knows how to compute three common forms of differences: \"unified\" format
+diffs, \"context\" format diffs, and \"vdelta\" format binary diffs.")
+ (license license:bsd-3))))
-(define-public cl-constantfold
- (sbcl-package->cl-source-package sbcl-constantfold))
+(define-public cl-diff
+ (sbcl-package->cl-source-package sbcl-diff))
-(define-public ecl-constantfold
- (sbcl-package->ecl-package sbcl-constantfold))
+(define-public ecl-diff
+ (sbcl-package->ecl-package sbcl-diff))
-(define-public sbcl-gtype
- (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18")
- (revision "2"))
+(define-public sbcl-dissect
+ (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
(package
- (name "sbcl-gtype")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-dissect")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/numcl/gtype";)
+ (url "https://github.com/Shinmera/dissect";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h"))))
+ (base32
+ "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
(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
- (list sbcl-fiveam)))))
+ (list sbcl-cl-ppcre))
+ (home-page "https://shinmera.github.io/dissect/";)
+ (synopsis
+ "Introspection library for the call stack and restarts")
+ (description
+ "Dissect is a small Common Lisp library for introspecting the call stack
+and active restarts.")
+ (license license:zlib))))
-(define-public cl-gtype
- (sbcl-package->cl-source-package sbcl-gtype))
+(define-public cl-dissect
+ (sbcl-package->cl-source-package sbcl-dissect))
-(define-public ecl-gtype
- (let ((pkg (sbcl-package->ecl-package sbcl-gtype)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; The tests fail on ECL with a COMPILE-FILE-ERROR for t/package.lisp.
- ((#:tests? _ #f) #f))))))
+(define-public ecl-dissect
+ (sbcl-package->ecl-package sbcl-dissect))
-(define-public sbcl-numcl
- (let ((commit "a28f612d072e5f93137584de5155a42243b3bd6b")
- (revision "3"))
+(define-public sbcl-distributions
+ (let ((commit "ea72622073ee7e005dfdc621ce1e5a83b22bb39e")
+ (revision "0"))
(package
- (name "sbcl-numcl")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-distributions")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/numcl/numcl";)
+ (url "https://github.com/Lisp-Stat/distributions";)
(commit commit)))
- (file-name (git-file-name "numcl" version))
+ (file-name (git-file-name "cl-distributions" version))
(sha256
- (base32 "15m4spbgayawnw5jjz04zfp0jnk9g6hgq5fmr648hzjzj50j1d78"))))
+ (base32 "1fkzigd0s0s0mvszgmv04yc8jp9gm4812445hfh6kpz6cjy5zpsk"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(;; Tests often fail because they require a dynamic-space-size much
- ;; bigger than the default one. Disable them for now.
- #:tests? #f))
- (native-inputs
- (list sbcl-fiveam))
+ ;; https://github.com/Lisp-Stat/distributions/issues/1
+ (arguments (list #:tests? #f))
+ (native-inputs (list sbcl-fiveam))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-randist" ,sbcl-cl-randist)
- ("constantfold" ,sbcl-constantfold)
- ("float-features" ,sbcl-float-features)
- ("function-cache" ,sbcl-function-cache)
- ("gtype" ,sbcl-gtype)
- ("iterate" ,sbcl-iterate)
- ("lisp-namespace" ,sbcl-lisp-namespace)
- ("specialized-function" ,sbcl-specialized-function)
- ("trivia" ,sbcl-trivia)
- ("type-r" ,sbcl-type-r)))
- (home-page "https://numcl.github.io/numcl/";)
- (synopsis "Numpy clone in Common Lisp")
- (description
- "This package is a Python Numpy clone implemented in pure Common Lisp.")
- (license license:lgpl3+))))
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-array-operations
+ sbcl-cephes
+ sbcl-float-features
+ sbcl-let-plus
+ sbcl-numerical-utilities
+ sbcl-special-functions))
+ (home-page "https://lisp-stat.dev/docs/manuals/distributions/";)
+ (synopsis "Statistical distributions for Common Lisp")
+ (description "The Distributions package provides a collection of
+probabilistic distributions and related functions")
+ (license license:ms-pl))))
-(define-public cl-numcl
- (sbcl-package->cl-source-package sbcl-numcl))
+(define-public cl-distributions
+ (sbcl-package->cl-source-package sbcl-distributions))
-(define-public ecl-numcl
- (sbcl-package->ecl-package sbcl-numcl))
+(define-public ecl-distributions
+ (sbcl-package->ecl-package sbcl-distributions))
-(define-public sbcl-pzmq
- (let ((commit "6f7b2ca02c23ea53510a9b0e0f181d5364ce9d32")
+(define-public sbcl-djula
+ (let ((commit "6f142594e0372437e64f610b796350ad89ba0be1")
(revision "2"))
(package
- (name "sbcl-pzmq")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-djula")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orivej/pzmq";)
+ (url "https://github.com/mmontone/djula";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-djula" version))
(sha256
- (base32 "19mdhxhzzghlmff1fic4chg5iz0psglkim09z6dgpijm26biny05"))))
+ (base32 "0yyg61hrql1vrwllyd23vidiff28ridh0avxyvnqb89v060d1j83"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("fiveam" ,sbcl-fiveam)
- ("let-plus" ,sbcl-let-plus)))
+ (list sbcl-fiveam))
(inputs
- `(("cffi" ,sbcl-cffi)
- ("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))))
+ (list sbcl-access
+ sbcl-alexandria
+ sbcl-anaphora
+ sbcl-babel
+ sbcl-cl-locale
+ sbcl-cl-ppcre
+ sbcl-cl-slice
+ sbcl-closer-mop
+ sbcl-gettext
+ sbcl-iterate
+ sbcl-local-time
+ sbcl-parser-combinators
+ sbcl-split-sequence
+ sbcl-trivial-backtrace))
+ (home-page "https://mmontone.github.io/djula/djula/";)
+ (synopsis "Common Lisp port of the Django templating language")
+ (description
+ "This package provides a Common Lisp templating system based on Python
+Django with a syntax similar to Python Jinja2.")
+ (license license:expat))))
-(define-public cl-pzmq
- (sbcl-package->cl-source-package sbcl-pzmq))
+(define-public cl-djula
+ (sbcl-package->cl-source-package sbcl-djula))
-(define-public ecl-pzmq
- (sbcl-package->ecl-package sbcl-pzmq))
+(define-public ecl-djula
+ (sbcl-package->ecl-package sbcl-djula))
-(define-public sbcl-clss
- (let ((revision "2")
- (commit "f62b849189c5d1be378f0bd3d403cda8d4fe310b"))
+(define-public sbcl-dns-client
+ (let ((commit "9f252e9c2bb61c57a6cd367e21ad366b0d3e87e0")
+ (revision "0"))
(package
- (name "sbcl-clss")
- (version (git-version "0.3.1" revision commit))
+ (name "sbcl-dns-client")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/clss";)
- (commit commit)))
- (sha256
- (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv"))
- (file-name (git-file-name name version))))
- (inputs
- (list sbcl-array-utils sbcl-plump))
+ (uri (git-reference
+ (url "https://github.com/Shinmera/dns-client";)
+ (commit commit)))
+ (file-name (git-file-name "cl-dns-client" version))
+ (sha256
+ (base32 "1b6g2wvydwmv1k68favjyq4gfalfxfyl5i0hyh640wdaz2rfvi4n"))))
(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";)
+ (arguments
+ ;; No tests provided.
+ `(#:tests? #f))
+ (inputs
+ (list sbcl-documentation-utils sbcl-usocket))
+ (home-page "https://shinmera.github.io/dns-client/";)
+ (synopsis "DNS protocol client for Common Lisp")
+ (description
+ "This package provides a pure-lisp implementation of a DNS client. It
can be
+used to resolve hostnames, reverse-lookup IP addresses, and fetch other kinds
of
+DNS records.")
(license license:zlib))))
-(define-public cl-clss
- (sbcl-package->cl-source-package sbcl-clss))
+(define-public cl-dns-client
+ (sbcl-package->cl-source-package sbcl-dns-client))
-(define-public ecl-clss
- (sbcl-package->ecl-package sbcl-clss))
+(define-public ecl-dns-client
+ (sbcl-package->ecl-package sbcl-dns-client))
-(define-public sbcl-lquery
- (let ((revision "1")
- (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
+(define-public sbcl-do-urlencode
+ (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a")
+ (revision "1"))
(package
- (name "sbcl-lquery")
- (version (git-version "3.2.1" revision commit))
+ (name "sbcl-do-urlencode")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/drdo/do-urlencode";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0k2i3d4k9cpci235mwfm0c5a4yqfkijr716bjv7cdlpzx88lazm9"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria sbcl-babel))
+ (synopsis "Percent Encoding (aka URL Encoding) Common Lisp library")
+ (description "This library provides trivial percent encoding and
+decoding functions for URLs.")
+ (license license:isc))))
+
+(define-public cl-do-urlencode
+ (sbcl-package->cl-source-package sbcl-do-urlencode))
+
+(define-public ecl-do-urlencode
+ (sbcl-package->ecl-package sbcl-do-urlencode))
+
+(define-public sbcl-documentation-utils
+ (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
+ (revision "0"))
+ (package
+ (name "sbcl-documentation-utils")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri
(git-reference
- (url "https://github.com/Shinmera/lquery";)
+ (url "https://github.com/Shinmera/documentation-utils";)
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
- (file-name (git-file-name name version))))
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-array-utils sbcl-form-fiddle sbcl-plump sbcl-clss))
+ (base32
+ "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq"))))
(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";)
+ (inputs
+ (list sbcl-trivial-indent))
+ (synopsis "Few simple tools to document Common Lisp libraries")
+ (description
+ "This is a small library to help you with managing the Common Lisp
+docstrings for your library.")
+ (home-page "https://shinmera.github.io/documentation-utils/";)
(license license:zlib))))
-(define-public cl-lquery
- (sbcl-package->cl-source-package sbcl-lquery))
+(define-public cl-documentation-utils
+ (sbcl-package->cl-source-package sbcl-documentation-utils))
-(define-public ecl-lquery
- (sbcl-package->ecl-package sbcl-lquery))
+(define-public ecl-documentation-utils
+ (sbcl-package->ecl-package sbcl-documentation-utils))
-(define-public sbcl-cl-mysql
- (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
- (revision "1"))
+(define-public sbcl-documentation-utils-extensions
+ (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750"))
(package
- (name "sbcl-cl-mysql")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-documentation-utils-extensions")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/hackinghat/cl-mysql";)
- (commit commit)))
+ (uri
+ (git-reference
+ (url
"https://github.com/sirherrbatka/documentation-utils-extensions/";)
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
+ (base32
+ "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list 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")
+ (list sbcl-documentation-utils))
+ (home-page
"https://github.com/sirherrbatka/documentation-utils-extensions";)
+ (synopsis "Set of extensions for documentation-utils")
(description
- "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.")
- (home-page "http://www.hackinghat.com/index.php/cl-mysql";)
+ "Use @code{rich-formatter} to format documentation with sections
@code{:syntax},
+@code{:arguments}, @code{:examples}, @code{:description}, @code{:returns},
+@code{:side-effects}, @code{:thread-safety}, @code{:affected-by},
+@code{:see-also} and @code{:notes}. Gather unformatted input by using
+@code{rich-aggregating-formatter} and @code{*DOCUMENTATION*} variable. Find
+gathered documentation with find-documentation function. Execute code stored
+in documentation with @code{execute-documentation}. See the examples in the
+@code{src/documentation.lisp} file. See the @code{documentation-utils} system
+for more information.")
(license license:expat))))
-(define-public cl-mysql
- (sbcl-package->cl-source-package sbcl-cl-mysql))
+(define-public cl-documentation-utils-extensions
+ (sbcl-package->cl-source-package sbcl-documentation-utils-extensions))
-(define-public ecl-cl-mysql
- (sbcl-package->ecl-package sbcl-cl-mysql))
+(define-public ecl-documentation-utils-extensions
+ (sbcl-package->ecl-package sbcl-documentation-utils-extensions))
-(define-public sbcl-postmodern
+(define-public sbcl-doplus
(package
- (name "sbcl-postmodern")
- (version "1.32.9")
+ (name "sbcl-doplus")
+ (version "1.1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marijnh/Postmodern";)
+ (url "https://github.com/alessiostalla/doplus";)
(commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-doplus" version))
(sha256
- (base32 "137jci4hn4vlxf48y39k0di27kc89kvxy3brmn3vl9xq56sy6mhz"))))
+ (base32 "1yvda9psw9m08d3bzdb8a2drvhrnr07a0rhza5ibk30v1dkwfw7c"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cl-base64" ,sbcl-cl-base64)
- ("cl-unicode" ,sbcl-cl-unicode)
- ("closer-mop" ,sbcl-closer-mop)
- ("global-vars" ,sbcl-global-vars)
- ("ironclad" ,sbcl-ironclad)
- ("local-time" ,sbcl-local-time)
- ("md5" ,sbcl-md5)
- ("split-sequence" ,sbcl-split-sequence)
- ("uax-15" ,sbcl-uax-15)
- ("usocket" ,sbcl-usocket)))
+ (list sbcl-parse-declarations sbcl-fset))
(arguments
- ;; TODO: (Sharlatan-20210114T171037+0000) tests still failing but on other
- ;; step, some functionality in `local-time' prevents passing tests.
- ;; Error:
- ;;
- ;; Can't create directory
- ;; /gnu/store
- ;; /4f47agf1kyiz057ppy6x5p98i7mcbfsv-sbcl-local-time-1.0.6-2.a177eb9
- ;; /lib/common-lisp/sbcl/local-time/src/integration/
- ;;
- ;; NOTE: (Sharlatan-20210124T191940+0000): When set env HOME to /tmp above
- ;; issue is resolved but it required live test database to connect to now.
- ;; Keep tests switched off.
- `(#:tests? #f
- #:asd-systems '("cl-postgres"
- "s-sql"
- "postmodern"
- "simple-date"
- "simple-date/postgres-glue")))
- (synopsis "Common Lisp library for interacting with PostgreSQL")
- (description
- "@code{postmodern} is a Common Lisp library for interacting with
-PostgreSQL databases. It provides the following features:
-
-@itemize
-@item Efficient communication with the database server without need for
-foreign libraries.
-@item Support for UTF-8 on Unicode-aware Lisp implementations.
-@item A syntax for mixing SQL and Lisp code.
-@item Convenient support for prepared statements and stored procedures.
-@item A metaclass for simple database-access objects.
-@end itemize\n
-
-This package produces 4 systems: postmodern, cl-postgres, s-sql, simple-date
-
-@code{SIMPLE-DATE} is a very basic implementation of date and time objects,
used
-to support storing and retrieving time-related SQL types. It is not loaded by
-default and you can use local-time (which has support for timezones) instead.
-
-@code{S-SQL} is used to compile s-expressions to strings of SQL code, escaping
-any Lisp values inside, and doing as much as possible of the work at compile
-time.
-
-@code{CL-POSTGRES} is the low-level library used for interfacing with a
PostgreSQL
-server over a socket.
+ '(#:asd-systems '("doplus" "doplus-fset")))
+ (synopsis "Iteration macro for Common Lisp")
+ (description "@code{doplus} is an iteration macro for Common Lisp.")
+ (home-page "https://github.com/alessiostalla/doplus";)
+ (license license:gpl3+)))
-@code{POSTMODERN} itself is a wrapper around these packages and provides higher
-level functions, a very simple data access object that can be mapped directly
to
-database tables and some convient utilities. It then tries to put all these
-things together into a convenient programming interface")
- (home-page "https://marijnhaverbeke.nl/postmodern/";)
- (license license:zlib)))
+(define-public cl-doplus
+ (sbcl-package->cl-source-package sbcl-doplus))
-(define-public cl-postmodern
- (sbcl-package->cl-source-package sbcl-postmodern))
+(define-public ecl-doplus
+ (sbcl-package->ecl-package sbcl-doplus))
-(define-public ecl-postmodern
+(define-public sbcl-drakma
(package
- (inherit (sbcl-package->ecl-package sbcl-postmodern))
- (arguments
- `(#:tests? #f
- #:asd-systems '("cl-postgres"
- "s-sql"
- "postmodern"
- "simple-date"
- "simple-date/postgres-glue")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (substitute* "cl-postgres.asd"
- ((":or :sbcl :allegro :ccl :clisp" all)
- (string-append all " :ecl")))
- #t)))))))
-
-(define-public sbcl-db3
- (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d")
- (revision "1"))
- (package
- (name "sbcl-db3")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/dimitri/cl-db3";)
- (commit commit)))
- (file-name (git-file-name "cl-db3" version))
- (sha256
- (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/dimitri/cl-db3";)
- (synopsis "Common Lisp library to read dBase III database files")
- (description
- "This is a Common Lisp library for processing data found in dBase III
-database files (dbf and db3 files).")
- (license license:public-domain))))
+ (name "sbcl-drakma")
+ (version "2.0.8")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/drakma";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-drakma" version))
+ (sha256
+ (base32
+ "1wf2zivfvhsh6zvd6wcwfd67bm8s8a1p2fismszc8xb819dqk9yl"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-puri
+ sbcl-cl-base64
+ sbcl-chunga
+ sbcl-flexi-streams
+ sbcl-cl-ppcre
+ sbcl-chipz
+ sbcl-usocket
+ sbcl-cl+ssl))
+ (native-inputs
+ (list 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)))
-(define-public ecl-db3
- (sbcl-package->ecl-package sbcl-db3))
+(define-public cl-drakma
+ (sbcl-package->cl-source-package sbcl-drakma))
-(define-public cl-db3
- (sbcl-package->cl-source-package sbcl-db3))
+(define-public ecl-drakma
+ (sbcl-package->ecl-package sbcl-drakma))
-(define-public sbcl-dbi
- (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227")
- (revision "2"))
+(define-public sbcl-draw-cons-tree
+ (let ((commit "04334f5885a85cd7127db8dda3f6d6686a0438b1")
+ (revision "0"))
(package
- (name "sbcl-dbi")
- (version (git-version "0.9.5" revision commit))
+ (name "sbcl-draw-cons-tree")
+ (version (git-version "1.0" revision commit))
+ ;; https://github.com/quicklisp/quicklisp-projects/issues/2149
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/cl-dbi";)
+ (url "https://github.com/phoe/draw-cons-tree";)
(commit commit)))
- (file-name (git-file-name "cl-dbi" version))
+ (file-name (git-file-name "cl-draw-cons-tree" version))
(sha256
- (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg"))))
+ (base32 "1523bdkq8a5qn0qp9q7r16w47y6jb0hkfj7hbjfj6mg3xv001s3x"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- `(("alexandria" ,sbcl-alexandria)
- ("rove" ,sbcl-rove)
- ("trivial-types" ,sbcl-trivial-types)))
+ (list sbcl-fiveam sbcl-split-sequence))
(inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cl-mysql" ,sbcl-cl-mysql)
- ("cl-sqlite" ,sbcl-cl-sqlite)
- ("closer-mop" ,sbcl-closer-mop)
- ("postmodern" ,sbcl-postmodern)
- ("split-sequence" ,sbcl-split-sequence)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (arguments
- `(#:asd-systems '("dbi"
- "dbd-mysql"
- "dbd-postgres"
- "dbd-sqlite3")))
- (synopsis "Database independent interface for Common Lisp")
+ (list sbcl-alexandria))
+ (synopsis "Draw an ascii picture of a cons tree")
(description
- "@code{dbi} is a Common Lisp library providing a database independent
-interface for MySQL, PostgreSQL and SQLite.")
- (home-page "https://github.com/fukamachi/cl-dbi";)
- (license license:llgpl))))
+ "@code{cl-draw-cons-tree} draws a cons tree in ASCII-art style.")
+ (home-page "https://github.com/phoe/draw-cons-tree/";)
+ (license license:unlicense))))
-(define-public cl-dbi
- (sbcl-package->cl-source-package sbcl-dbi))
+(define-public cl-draw-cons-tree
+ (sbcl-package->cl-source-package sbcl-draw-cons-tree))
-(define-public ecl-dbi
- (sbcl-package->ecl-package sbcl-dbi))
+(define-public ecl-draw-cons-tree
+ (sbcl-package->ecl-package sbcl-draw-cons-tree))
-(define-public sbcl-uffi
+(define-public sbcl-dufy
(package
- (name "sbcl-uffi")
- (version "2.1.2")
+ (name "sbcl-dufy")
+ (version "0.4.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://git.kpe.io/uffi.git";)
+ (url "https://github.com/privet-kitty/dufy";)
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
- (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))
- (modules '((guix build utils)))
- (snippet
- ;; The useless bundled debian folder drags `make' into the closure.
- `(begin
- (delete-file-recursively "debian")
- #t))))
+ (base32 "15vrp1kayhjb5c1vc9x8wlm8rimk73vpa7yc101cf0gsg1fjazl6"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-permissions
- (lambda _
- (make-file-writable "doc/html.tar.gz")
- #t)))))
- (synopsis "Universal foreign function library for Common Lisp")
+ (inputs
+ (list sbcl-alexandria sbcl-cl-ppcre))
+ (native-inputs
+ (list sbcl-fiveam sbcl-cl-csv sbcl-parse-float sbcl-lispbuilder-sdl
+ sbcl-lparallel))
+ (home-page "https://github.com/privet-kitty/dufy";)
+ (synopsis "Color library for Common Lisp")
(description
- "UFFI provides a universal foreign function interface (FFI)
- for Common Lisp.")
- (home-page "https://quickdocs.org/uffi/";)
- (license license:llgpl)))
+ "Dufy is a library for exact color manipulation and conversion in various
+color spaces, which supports many color models.")
+ (license license:expat)))
-(define-public cl-uffi
- (package
- (inherit (sbcl-package->cl-source-package sbcl-uffi))
- (arguments
- `(#:phases
- ;; asdf-build-system/source has its own phases and does not inherit
- ;; from asdf-build-system/sbcl phases.
- (modify-phases %standard-phases/source
- ;; Already done in SBCL package.
- (delete 'reset-gzip-timestamps))))))
+(define-public cl-dufy
+ (sbcl-package->cl-source-package sbcl-dufy))
-(define-public sbcl-clsql
- (package
- (name "sbcl-clsql")
- (version "6.7.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://git.kpe.io/clsql.git";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1v1k3s5bsy3lgd9gk459bzpb1r0kdjda25s29samxw4gsgf1fqvp"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; The useless bundled debian folder drags `make' into the closure.
- (delete-file-recursively "debian")
- ;; Other Makefiles that drag `make'.
- (for-each delete-file
- '("Makefile"
- "db-db2/Makefile"
- "db-mysql/Makefile"
- "db-odbc/Makefile"
- "db-oracle/Makefile"
- "db-sqlite/Makefile"
- "doc/Makefile"
- "examples/sqlite3/init-func/Makefile"
- "sql/Makefile"
- "tests/Makefile"
- "uffi/Makefile"
- "uffi/Makefile.32+64bits"))
- ;; Remove precompiled libraries.
- (delete-file "db-mysql/clsql_mysql.dll")
- (delete-file "uffi/clsql_uffi.dll")
- (delete-file "uffi/clsql_uffi.lib")
- #t))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- `(("rt" ,sbcl-rt)))
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("md5" ,sbcl-md5)
- ("mariadb-dev" ,mariadb "dev")
- ("mariadb-lib" ,mariadb "lib")
- ("postgresql" ,postgresql)
- ("postmodern" ,sbcl-postmodern)
- ("sqlite" ,sqlite)
- ("uffi" ,sbcl-uffi)
- ("zlib" ,zlib)))
- (arguments
- `(#:asd-systems '("clsql"
- "clsql-uffi"
- "clsql-sqlite3"
- "clsql-postgresql"
- "clsql-postgresql-socket3"
- "clsql-mysql")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-permissions
- (lambda _
- (make-file-writable "doc/html.tar.gz")
- #t))
- (add-after 'unpack 'fix-build
- (lambda _
- (substitute* "clsql-uffi.asd"
- (("\\(:version uffi \"2.0\"\\)")
- "uffi"))
- (substitute* "db-postgresql/postgresql-api.lisp"
- (("\\(data :cstring\\)")
- "(data :string)"))
- #t))
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (substitute* "db-sqlite3/sqlite3-loader.lisp"
- (("libsqlite3")
- (string-append (assoc-ref inputs "sqlite")
- "/lib/libsqlite3")))
- (substitute* "db-postgresql/postgresql-loader.lisp"
- (("libpq")
- (string-append (assoc-ref inputs "postgresql")
- "/lib/libpq")))
- (let ((lib (string-append "#p\""
- (assoc-ref outputs "out")
- "/lib/\"")))
- (substitute* "clsql-mysql.asd"
- (("#p\"/usr/lib/clsql/clsql_mysql\\.so\"")
- lib))
- (substitute* "db-mysql/mysql-loader.lisp"
- (("libmysqlclient" all)
- (string-append (assoc-ref inputs "mariadb-lib") "/lib/" all))
- (("clsql-mysql-system::\\*library-file-dir\\*")
- lib)))
- #t))
- (add-before 'build 'build-helper-library
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let* ((mariadb-dev (assoc-ref inputs "mariadb-dev"))
- (mariadb-lib (assoc-ref inputs "mariadb-lib"))
- (inc-dir (string-append mariadb-dev "/include/mysql"))
- (lib-dir (string-append mariadb-lib "/lib"))
- (shared-lib-dir (string-append (assoc-ref outputs "out")
- "/lib"))
- (shared-lib (string-append shared-lib-dir
- "/clsql_mysql.so")))
- (mkdir-p shared-lib-dir)
- (invoke "gcc" "-fPIC" "-shared"
- "-I" inc-dir
- "db-mysql/clsql_mysql.c"
- "-Wl,-soname=clsql_mysql"
- "-L" lib-dir "-lmariadb" "-lz"
- "-o" shared-lib)
- #t)))
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "clsql.asd"
- (("clsql-tests :force t")
- "clsql-tests"))
- #t)))))
- (synopsis "Common Lisp SQL Interface library")
- (description
- "@code{clsql} is a Common Lisp interface to SQL RDBMS based on the
-Xanalys CommonSQL interface for Lispworks. It provides low-level database
-interfaces as well as a functional and an object oriented interface.")
- (home-page "https://clsql.kpe.io/";)
- (license license:llgpl)))
-
-(define-public cl-clsql
- (package
- (inherit (sbcl-package->cl-source-package sbcl-clsql))
- (native-inputs
- `(("rt" ,cl-rt)))
- (inputs
- (list (list mariadb "dev") postgresql sqlite zlib))
- (propagated-inputs
- `(("cffi" ,cl-cffi)
- ("md5" ,cl-md5)
- ("postmodern" ,cl-postmodern)
- ("uffi" ,cl-uffi)))
- (arguments
- `(#:phases
- ;; asdf-build-system/source has its own phases and does not inherit
- ;; from asdf-build-system/sbcl phases.
- (modify-phases %standard-phases/source
- (add-after 'unpack 'fix-permissions
- (lambda _
- (make-file-writable "doc/html.tar.gz")
- #t)))))))
-
-(define-public ecl-clsql
- (let ((pkg (sbcl-package->ecl-package sbcl-clsql)))
- (package
- (inherit pkg)
- (inputs
- (alist-delete "uffi" (package-inputs pkg)))
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:asd-systems asd-systems '())
- `(cons "clsql-cffi" ,asd-systems)))))))
+(define-public ecl-dufy
+ (sbcl-package->ecl-package sbcl-dufy))
-(define-public sbcl-sycamore
- (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
+(define-public sbcl-duologue
+ (let ((commit "ea1ada244a81da65f85b548823c9a6d7c9c145e1")
+ (revision "0"))
(package
- (name "sbcl-sycamore")
- (version "0.0.20120604")
+ (name "sbcl-duologue")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ndantam/sycamore/";)
+ (url "https://github.com/mmontone/duologue";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-duologue" version))
(sha256
- (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
+ (base32 "1yg7f27im9h0m6jihcay1p7alfhzm9hafwm5dw5hsyacy8f2cwk2"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-stefil))
(inputs
- (list sbcl-alexandria sbcl-cl-ppcre))
- (synopsis "Purely functional data structure library in Common Lisp")
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-chronicity
+ sbcl-cl-ansi-text
+ sbcl-cl-fad
+ sbcl-clavier
+ sbcl-drakma))
+ (home-page "https://github.com/mmontone/duologue/";)
+ (synopsis "High level user interaction library")
(description
- "Sycamore is a fast, purely functional data structure library in Common
Lisp.
-If features:
-
-@itemize
-@item Fast, purely functional weight-balanced binary trees.
-@item Leaf nodes are simple-vectors, greatly reducing tree height.
-@item Interfaces for tree Sets and Maps (dictionaries).
-@item Ropes.
-@item Purely functional pairing heaps.
-@item Purely functional amortized queue.
-@end itemize\n")
- (home-page "https://ndantam.github.io/sycamore/";)
- (license license:bsd-3))))
+ "Duologue is high-level interaction library for Common Lisp. It
features
+coloured printing via @code{cl-ansi-text} and readline completion.")
+ (license (list license:expat
+ ;; https://github.com/mmontone/duologue/issues/9
+ license:gpl3+)))))
-(define-public cl-sycamore
- (sbcl-package->cl-source-package sbcl-sycamore))
+(define-public cl-duologue
+ (sbcl-package->cl-source-package sbcl-duologue))
-(define-public ecl-sycamore
- (sbcl-package->ecl-package sbcl-sycamore))
+(define-public ecl-duologue
+ (sbcl-package->ecl-package sbcl-duologue))
-(define-public sbcl-funds
- (let ((commit "39d425818876b898c20780a678803df506df8424")
- (revision "2"))
+(define-public sbcl-dynamic-classes
+ (let ((commit "ebd7405603f67b16e8f2bc08ce8e2bcfcf439501")
+ (revision "0"))
(package
- (name "sbcl-funds")
- (version (git-version "1" revision commit))
+ (name "sbcl-dynamic-classes")
+ (version (git-version "1.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charJe/funds";)
+ (url "https://github.com/hraban/dynamic-classes";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "dynamic-classes" version))
(sha256
- (base32 "13y1jhvnpzrs9daz6f3z67w6h2y21ggb10j3j4vnc5p3m8i7ps4p"))))
+ (base32 "1k9lkchwyi2xhygp2v8ifq3kg1l3wcnihhzgr06jrivjxgdqpc1a"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Purely functional data structure library in Common Lisp")
- (description
- "Funds provides portable, purely functional data structures in Common
-Lisp. It includes tree based implementations for Array, Hash, Queue, Stack,
and
-Heap.")
- (home-page "https://common-lisp.net/project/funds/";)
- (license license:asl2.0))))
+ (inputs
+ `(("metatilities-base" ,sbcl-metatilities-base)))
+ (arguments
+ ;; NOTE: (Sharlatan-20210106222900+0000) Circular dependencies and
failing
+ ;; test suites. lift-standard.config contains referances to deprecated
+ ;; functionality.
+ ;; See https://github.com/hraban/dynamic-classes/issues/2
+ `(#:tests? #f))
+ (home-page "https://common-lisp.net/project/dynamic-classes/";)
+ (synopsis "Dynamic class definition for Common Lisp")
+ (description "Dynamic-Classes helps to ease the prototyping process by
+bringing dynamism to class definition.")
+ (license license:expat))))
-(define-public cl-funds
- (sbcl-package->cl-source-package sbcl-funds))
+(define-public cl-dynamic-classes
+ (sbcl-package->cl-source-package sbcl-dynamic-classes))
-(define-public ecl-funds
- (sbcl-package->ecl-package sbcl-funds))
+(define-public ecl-dynamic-classes
+ (sbcl-package->ecl-package sbcl-dynamic-classes))
-(define-public sbcl-trivial-package-local-nicknames
- (package
- (name "sbcl-trivial-package-local-nicknames")
- (version "0.2")
- (home-page "https://github.com/phoe/trivial-package-local-nicknames";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
- (file-name (git-file-name name version))
- (sha256
- (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp compatibility library for package local nicknames")
- (description
- "This library is a portable compatibility layer around package local
nicknames (PLN).
-This was done so there is a portability library for the PLN API not included
-in DEFPACKAGE.")
- (license license:unlicense)))
+(define-public sbcl-dynamic-mixins
+ (let ((commit "7cc09bee7d68527f37406671fabe910e8235b746"))
+ (package
+ (name "sbcl-dynamic-mixins")
+ (version (git-version "0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/dynamic-mixins";)
+ (commit commit)))
+ (file-name (git-file-name "cl-dynamic-mixins" version))
+ (sha256
+ (base32 "00g3s509ysh2jp1qwsgb5bwl6qvhzcljwjz3z4mspbcak51484zj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-closer-mop))
+ (home-page "https://github.com/rpav/dynamic-mixins";)
+ (synopsis "Simple, dynamic class combination for CLOS")
+ (description
+ "Dynamic-mixins is for simple, dynamic class combination; it allows
+objects to be mixed and updated without manually defining many permutations.")
+ (license license:bsd-2))))
-(define-public cl-trivial-package-local-nicknames
- (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
+(define-public cl-dynamic-mixins
+ (sbcl-package->cl-source-package sbcl-dynamic-mixins))
-(define-public ecl-trivial-package-local-nicknames
- (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames))
+(define-public ecl-dynamic-mixins
+ (sbcl-package->ecl-package sbcl-dynamic-mixins))
-(define-public sbcl-enchant
- (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
+(define-public sbcl-eager-future2
+ (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30"))
(package
- (name "sbcl-enchant")
+ (name "sbcl-eager-future2")
(version (git-version "0.0.0" "1" commit))
- (home-page "https://github.com/tlikonen/cl-enchant";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
+ (base32
+ "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("enchant" ,enchant)
- ("cffi" ,sbcl-cffi)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "load-enchant.lisp"
- (("libenchant")
- (string-append
- (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
- (synopsis "Common Lisp interface for the Enchant spell-checker library")
+ (list sbcl-bordeaux-threads sbcl-trivial-garbage))
+ (synopsis "Futures promises synchronization mechanism for Common Lisp")
(description
- "Enchant is a Common Lisp interface for the Enchant spell-checker
-library. The Enchant library is a generic spell-checker library which uses
-other spell-checkers transparently as back-end. The library supports the
-multiple checkers, including Aspell and Hunspell.")
- (license license:public-domain))))
+ "Eager Future2 is a Common Lisp library that provides composable
+concurrency primitives that unify parallel and lazy evaluation, are integrated
+with the Common Lisp condition system, and have automatic resource
+management.")
+ (home-page "https://gitlab.common-lisp.net/vsedach/eager-future2";)
+ (license license:lgpl3+))))
-(define-public cl-enchant
- (sbcl-package->cl-source-package sbcl-enchant))
+(define-public cl-eager-future2
+ (sbcl-package->cl-source-package sbcl-eager-future2))
-(define-public ecl-enchant
- (sbcl-package->ecl-package sbcl-enchant))
+(define-public ecl-eager-future2
+ (sbcl-package->ecl-package sbcl-eager-future2))
-(define-public sbcl-cl-change-case
- (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022")
- (revision "1"))
+(define-public sbcl-easy-routes
+ (let ((commit "7832f8bf3d07825b5eb967a2ef04da7c40c18248")
+ (revision "0"))
(package
- (name "sbcl-cl-change-case")
- (version (git-version "0.2.0" revision commit))
- (home-page "https://github.com/rudolfochrist/cl-change-case";)
+ (name "sbcl-easy-routes")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/mmontone/easy-routes";)
(commit commit)))
- (file-name (git-file-name "cl-change-case" version))
+ (file-name (git-file-name "cl-easy-routes" version))
(sha256
- (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if"))))
+ (base32 "1banw54kz2llzb9h5sm47ckfc9l348m7qncm0npsy0w837rxkyzx"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode))
+ (arguments
+ '(#:asd-systems '("easy-routes"
+ "easy-routes+djula"
+ "easy-routes+errors")))
(native-inputs
- (list sbcl-fiveam))
- (synopsis
- "Convert Common Lisp strings between camelCase, PascalCase and more")
+ (list sbcl-stefil))
+ (inputs
+ (list sbcl-djula
+ sbcl-hunchentoot
+ sbcl-hunchentoot-errors
+ sbcl-routes))
+ (home-page "https://github.com/mmontone/easy-routes/";)
+ (synopsis "Routes handling utility on top of Hunchentoot")
(description
- "@code{cl-change-case} is a library to convert strings between
-camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.")
- (license license:llgpl))))
-
-(define-public cl-change-case
- (sbcl-package->cl-source-package sbcl-cl-change-case))
+ "EASY-ROUTES is yet another routes handling system on top of
+Hunchentoot. It's just glue code for Restas routing subsystem (CL-ROUTES).
-(define-public ecl-cl-change-case
- (sbcl-package->ecl-package sbcl-cl-change-case))
+It supports:
+@itemize
+@item dispatch based on HTTP method
+@item arguments extraction from the url path
+@item decorators
+@item URL generation from route names
+@end itemize
-(define-public sbcl-modularize
- (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba")
- (revision "1"))
- (package
- (name "sbcl-modularize")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/modularize";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1zys29rfkb649rkgl3snxhajk8d5yf7ryxkrwy020kwdh7zdsg7d"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("documentation-utils" ,sbcl-documentation-utils)
- ("trivial-package-local-nicknames"
,sbcl-trivial-package-local-nicknames)))
- (home-page "https://shinmera.github.io/modularize/";)
- (synopsis "Common Lisp modularization framework")
- (description
- "@code{MODULARIZE} is an attempt at providing a common interface to
-segregate major application components. This is achieved by adding special
-treatment to packages. Each module is a package that is specially registered,
-which allows it to interact and co-exist with other modules in better ways.
For
-instance, by adding module definition options you can introduce mechanisms to
-tie modules together in functionality, hook into each other and so on.")
- (license license:zlib))))
+This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS
+systems.")
+ (license license:expat))))
-(define-public ecl-modularize
- (sbcl-package->ecl-package sbcl-modularize))
+(define-public cl-easy-routes
+ (sbcl-package->cl-source-package sbcl-easy-routes))
-(define-public cl-modularize
- (sbcl-package->cl-source-package sbcl-modularize))
+(define-public ecl-easy-routes
+ (sbcl-package->ecl-package sbcl-easy-routes))
-(define-public sbcl-modularize-hooks
- (let ((commit "e0348ed3ffd59a9ec31ca4ab28289e748bfbf96a")
- (revision "1"))
+(define-public sbcl-eazy-gnuplot
+ (let ((commit "2eb900fe2557e6c066a9851c166e572c25bc0996")
+ (revision "0"))
(package
- (name "sbcl-modularize-hooks")
- (version (git-version "1.0.2" revision commit))
+ (name "sbcl-eazy-gnuplot")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/modularize-hooks";)
+ (url "https://github.com/guicho271828/eazy-gnuplot";)
(commit commit)))
- (file-name (git-file-name "modularize-hooks" version))
+ (file-name (git-file-name "cl-eazy-gnuplot" version))
(sha256
- (base32 "12kjvin8hxidwkzfb7inqv5b6g5qzcssnj9wc497v2ixc56fqdz7"))))
+ (base32 "0mpkx1z52riahydzvqv7kk15p0pv2k7k5a7j65fg571kcxmssx8s"))
+ (patches (search-patches "sbcl-eazy-gnuplot-skip-path-check.patch"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-closer-mop sbcl-lambda-fiddle sbcl-modularize
- sbcl-trivial-arguments))
- (home-page "https://shinmera.github.io/modularize-hooks/";)
- (synopsis "Generic hooks and triggers extension for Modularize")
+ (list gnuplot
+ sbcl-alexandria
+ sbcl-iterate
+ sbcl-trivia))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda _
+ (substitute* "src/package.lisp"
+ (("\"gnuplot\"")
+ (string-append "\"" (which "gnuplot") "\""))))))))
+ (home-page "https://github.com/guicho271828/eazy-gnuplot";)
+ (synopsis "Common Lisp interface to gnuplot")
(description
- "This is a simple extension to @code{MODULARIZE} that allows modules to
-define and trigger hooks, which other modules can hook on to.")
- (license license:zlib))))
+ "Eazy-Gnuplot is a Common Lisp interface to gnuplot which eschews CFFI,
+CLOS and structures. It communicates with @command{gnuplot} via
+@code{*standard-output*}, and users can plot data by printing to that
+stream.")
+ (license license:llgpl))))
-(define-public ecl-modularize-hooks
- (sbcl-package->ecl-package sbcl-modularize-hooks))
+(define-public cl-eazy-gnuplot
+ (sbcl-package->cl-source-package sbcl-eazy-gnuplot))
-(define-public cl-modularize-hooks
- (sbcl-package->cl-source-package sbcl-modularize-hooks))
+(define-public ecl-eazy-gnuplot
+ (sbcl-package->ecl-package sbcl-eazy-gnuplot))
-(define-public sbcl-modularize-interfaces
- (let ((commit "96353657afb8c7aeba7ef5b51eb04c5ed3bcb6ef")
- (revision "1"))
+(define-public sbcl-eclector
+ (let ((commit "d499b09142c7e39b4ef52e821fa767d5a8d606a0")
+ (revision "0"))
(package
- (name "sbcl-modularize-interfaces")
- (version (git-version "0.9.3" revision commit))
+ (name "sbcl-eclector")
+ (version (git-version "0.9.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/modularize-interfaces";)
+ (url "https://github.com/s-expressionists/Eclector";)
(commit commit)))
- (file-name (git-file-name "modularize-interfaces" version))
+ (file-name (git-file-name "cl-eclector" version))
(sha256
- (base32 "0bjf4wy39cwf75m7vh0r7mmcchs09yz2lrbyap98hnq8blq70fhc"))))
+ (base32 "1sg8wmdpm8pcjwk394way5vs2ya3r995lddmi51q9zfn9hmzb7gn"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-lambda-fiddle sbcl-modularize sbcl-trivial-arguments
- sbcl-trivial-indent))
- (home-page "https://shinmera.github.io/modularize-interfaces/";)
- (synopsis "Programmatical interfaces extension for Modularize")
+ (list sbcl-acclimation
+ sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-concrete-syntax-tree))
+ (arguments
+ '(#:asd-systems '("eclector"
+ "eclector-concrete-syntax-tree")))
+ (home-page "https://s-expressionists.github.io/Eclector/";)
+ (synopsis "Highly customizable, portable Common Lisp reader")
(description
- "This is an extension to @code{MODULARIZE} that allows your application
-to define interfaces in-code that serve both as a primary documentation and as
-compliance control.")
- (license license:zlib))))
+ "Eclector is a portable Common Lisp reader that is highly customizable,
+can recover from errors and can return concrete syntax trees.
-(define-public ecl-modularize-interfaces
- (sbcl-package->ecl-package sbcl-modularize-interfaces))
+In contrast to many other reader implementations, eclector can recover from
+most errors in the input supplied to it and continue reading. This capability
+is realized as a restart.
-(define-public cl-modularize-interfaces
- (sbcl-package->cl-source-package sbcl-modularize-interfaces))
+It can also produce instances of the concrete syntax tree classes provided by
+the concrete syntax tree library.")
+ (license license:bsd-2))))
-(define-public sbcl-moptilities
- (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
+(define-public cl-eclector
+ (sbcl-package->cl-source-package sbcl-eclector))
+
+(define-public ecl-eclector
+ (sbcl-package->ecl-package sbcl-eclector))
+
+(define-public sbcl-enchant
+ (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
(package
- (name "sbcl-moptilities")
- (version (git-version "0.3.13" "1" commit))
- (home-page "https://github.com/gwkkwg/moptilities/";)
+ (name "sbcl-enchant")
+ (version (git-version "0.0.0" "1" commit))
+ (home-page "https://github.com/tlikonen/cl-enchant";)
(source
(origin
(method git-fetch)
@@ -14625,352 +13934,431 @@ compliance control.")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
+ (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("closer-mop" ,sbcl-closer-mop)))
- (native-inputs
- (list sbcl-lift))
+ `(("enchant" ,enchant)
+ ("cffi" ,sbcl-cffi)))
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "lift-standard.config"
- ((":relative-to lift-test")
- ":relative-to moptilities-test"))
- #t))
- (add-after 'install 'remove-test-results
- ;; Otherwise the drag the SBCL package into the closure of the CL
- ;; package.
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (source-path (string-append out "/share/common-lisp/"
- (%lisp-type)
"/moptilities/")))
- (delete-file-recursively
- (string-append source-path "/test-results")))
- #t)))))
- (synopsis "Compatibility layer for Common Lisp MOP implementation
differences")
- (description
- "MOP utilities provide a common interface between Lisps and make the
-MOP easier to use.")
- (license license:expat))))
-
-(define-public cl-moptilities
- (sbcl-package->cl-source-package sbcl-moptilities))
-
-(define-public ecl-moptilities
- (let ((pkg (sbcl-package->ecl-package sbcl-moptilities)))
- (package
- (inherit pkg)
- (arguments
- ;; Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is
- ;; undefined" on ECL.
- '(#:tests? #f)))))
-
-(define-public sbcl-osicat
- (let ((commit "982327905b8980ff3173344ca87282e046565732")
- (revision "4"))
- (package
- (name "sbcl-osicat")
- (version (git-version "0.7.0" revision commit))
- (home-page "https://www.common-lisp.net/project/osicat/";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/osicat/osicat";)
- (commit commit)))
- (file-name (git-file-name "cl-osicat" version))
- (sha256
- (base32 "10q1dfkhrvp5ia860q10y4wdm11fmxf7xv8zl4viz2np9xzf5v22"))
- (snippet
- '(begin
- ;; The useless release.sh drags `bash' into the closure.
- (delete-file "scripts/release.sh")
- #t))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-cffi sbcl-trivial-features))
- (native-inputs
- (list sbcl-rt))
- (synopsis "Operating system interface for Common Lisp")
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "load-enchant.lisp"
+ (("libenchant")
+ (string-append
+ (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
+ (synopsis "Common Lisp interface for the Enchant spell-checker library")
(description
- "Osicat is a lightweight operating system interface for Common Lisp on
-Unix-platforms. It is not a POSIX-style API, but rather a simple lispy
-accompaniment to the standard ANSI facilities.")
- (license license:expat))))
-
-(define-public cl-osicat
- (sbcl-package->cl-source-package sbcl-osicat))
-
-(define-public ecl-osicat
- (sbcl-package->ecl-package sbcl-osicat))
-
-(define-public sbcl-clx-xembed
- (let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
- (revision "1"))
- (package
- (name "sbcl-clx-xembed")
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/laynor/clx-xembed";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/laynor/clx-xembed";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("xembed")))
- (inputs
- (list sbcl-clx))
- (synopsis "CL(x) xembed protocol implementation")
- (description "CL(x) xembed protocol implementation")
- ;; MIT License
- (license license:expat))))
-
-(define-public cl-clx-xembed
- (sbcl-package->cl-source-package sbcl-clx-xembed))
-
-(define-public ecl-clx-xembed
- (sbcl-package->ecl-package sbcl-clx-xembed))
-
-(define-public sbcl-mw-equiv
- (let ((commit "3ae871458685b1ef7cd6a996ee22c8c5e738a03d")
- (revision "1"))
- (package
- (name "sbcl-mw-equiv")
- (version (git-version "0.1.2" revision commit))
- (home-page "https://github.com/sharplispers/mw-equiv/";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/mw-equiv/";)
- (commit commit)))
- (file-name (git-file-name "cl-mw-equiv" version))
- (sha256
- (base32 "1fl90wp0jp7l90mps53fq0kzb28f10qfr739527h03xwqccyylad"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Extensible object equivalence protocol for Common Lisp")
- (description "Common Lisp comes with quite some functions to compare
-objects for equality, yet none is applicable in every situation and in general
-this is hard, as equality of objects depends on the semantics of operations on
-them. As consequence, users find themselves regularly in a situation where
-they have to roll their own specialized equality test.
-
-This module provides one of many possible equivalence relations between
-standard Common Lisp objects. However, it can be extended for new objects
-through a simple CLOS protocol. The rules when two objects are considered
-equivalent distinguish between @emph{mutating} and @emph{frozen objects}. A
-frozen object is promised not to be mutated in the future in a way that
-operations on it can notice the difference.
-
-We have chosen to compare mutating objects only for identity (pointer
-equality), to avoid various problems. Equivalence for frozen objects on the
-other hand is established by recursing on the objects' constituent parts and
-checking their equivalence. Hence, two objects are equivalent under the
-@code{OBJECT=} relation, if they are either identical, or if they are frozen
-and structurally equivalent, i.e. their constituents are point-wise
-equivalent.
-
-Since many objects are potentially mutable, but are not necessarily mutated
-from a certain point in their life time on, it is possible to promise to the
-equivalence relation that they remain frozen for the rest of their life time,
-thus enabling coarser equivalence than the often too fine-grained pointer
-equality.")
- (license license:bsd-2))))
+ "Enchant is a Common Lisp interface for the Enchant spell-checker
+library. The Enchant library is a generic spell-checker library which uses
+other spell-checkers transparently as back-end. The library supports the
+multiple checkers, including Aspell and Hunspell.")
+ (license license:public-domain))))
-(define-public cl-mw-equiv
- (sbcl-package->cl-source-package sbcl-mw-equiv))
+(define-public cl-enchant
+ (sbcl-package->cl-source-package sbcl-enchant))
-(define-public ecl-mw-equiv
- (sbcl-package->ecl-package sbcl-mw-equiv))
+(define-public ecl-enchant
+ (sbcl-package->ecl-package sbcl-enchant))
-(define-public sbcl-quantile-estimator
+(define-public sbcl-enhanced-boolean
(package
- (name "sbcl-quantile-estimator")
- (version "0.0.1")
+ (name "sbcl-enhanced-boolean")
+ (version "1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/deadtrickster/quantile-estimator.cl";)
- (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
- (file-name (git-file-name name version))
+ (url "https://github.com/Hexstream/enhanced-boolean";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-enhanced-boolean" version))
(sha256
- (base32
- "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
+ (base32 "17l18lz07fk2kg835vs6c3189d230n1rm9vghk3ls4i356gbq0gy"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-test-systems '("quantile-estimator.test")))
- (inputs
- (list sbcl-alexandria))
(native-inputs
- (list sbcl-mw-equiv sbcl-prove sbcl-log4cl))
- (home-page "https://github.com/deadtrickster/quantile-estimator.cl";)
- (synopsis
- "Effective computation of biased quantiles over data streams")
+ (list sbcl-parachute))
+ (home-page "https://www.hexstreamsoft.com/libraries/enhanced-boolean/";)
+ (synopsis "Convert generalized booleans to booleans")
(description
- "Common Lisp implementation of Graham Cormode and S.
-Muthukrishnan's Effective Computation of Biased Quantiles over Data
-Streams in ICDE’05.")
- (license license:expat)))
+ "This package provides a canonical way of converting generalized booleans
+to booleans.")
+ (license license:unlicense)))
-(define-public cl-quantile-estimator
- (sbcl-package->cl-source-package sbcl-quantile-estimator))
+(define-public cl-enhanced-boolean
+ (sbcl-package->cl-source-package sbcl-enhanced-boolean))
-(define-public ecl-quantile-estimator
- (sbcl-package->ecl-package sbcl-quantile-estimator))
+(define-public ecl-enhanced-boolean
+ (sbcl-package->ecl-package sbcl-enhanced-boolean))
-(define-public sbcl-prometheus
+(define-public sbcl-enhanced-defclass
(package
- (name "sbcl-prometheus")
- (version "0.4.1")
+ (name "sbcl-enhanced-defclass")
+ (version "2.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/deadtrickster/prometheus.cl";)
- (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
- (file-name (git-file-name name version))
+ (url "https://github.com/Hexstream/enhanced-defclass";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-enhanced-defclass" version))
(sha256
- (base32
- "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
+ (base32 "142s5c3pl3x7xdawzsj8pdxiqp4wh6fcajf4la5msvnxgf66d8wg"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("cl-fad" ,sbcl-cl-fad)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("drakma" ,sbcl-drakma)
- ("hunchentoot" ,sbcl-hunchentoot)
- ("local-time" ,sbcl-local-time)
- ("quantile-estimator" ,sbcl-quantile-estimator)
- ("salza2" ,sbcl-salza2)
- ("split-sequence" ,sbcl-split-sequence)
- ("trivial-utf-8" ,sbcl-trivial-utf-8)))
- (arguments
- '(#:asd-systems '("prometheus"
- "prometheus.collectors.sbcl"
- "prometheus.collectors.process"
- "prometheus.formats.text"
- "prometheus.exposers.hunchentoot"
- "prometheus.pushgateway")))
- (home-page "https://github.com/deadtrickster/prometheus.cl";)
- (synopsis "Prometheus.io Common Lisp client")
- (description "Prometheus.io Common Lisp client.")
- (license license:expat)))
+ (list sbcl-cesdi
+ sbcl-closer-mop
+ sbcl-compatible-metaclasses
+ sbcl-enhanced-eval-when
+ sbcl-object-class
+ sbcl-shared-preferences
+ sbcl-simple-guess))
+ (home-page "https://www.hexstreamsoft.com/libraries/enhanced-defclass/";)
+ (synopsis "Extensible implementation of defclass")
+ (description
+ "This package provides an extensible implementation of defclass that can
+accurately control the expansion according to the metaclass and automatically
+detect the suitable metaclass by analyzing the @code{defclass} form.")
+ (license license:unlicense)))
-(define-public cl-prometheus
- (sbcl-package->cl-source-package sbcl-prometheus))
+(define-public cl-enhanced-defclass
+ (sbcl-package->cl-source-package sbcl-enhanced-defclass))
-(define-public ecl-prometheus
- (sbcl-package->ecl-package sbcl-prometheus))
+(define-public ecl-enhanced-defclass
+ (sbcl-package->ecl-package sbcl-enhanced-defclass))
-(define-public sbcl-promise
- (let ((commit "801db8f853da7935ae2e487fd7f8763acbc5ad2a")
- (revision "0"))
- (package
- (name "sbcl-promise")
- (version (git-version "1.0.0" revision commit))
- (source
+(define-public sbcl-enhanced-eval-when
+ (package
+ (name "sbcl-enhanced-eval-when")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/enhanced-eval-when";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-enhanced-eval-when" version))
+ (sha256
+ (base32 "1ws1v297plcbqmcvckg7vqzzgnrwfyx5kd7281r1wrhc26998rx2"))))
+ (build-system asdf-build-system/sbcl)
+ ;; https://github.com/Hexstream/enhanced-eval-when/issues/1
+ (arguments
+ (list #:tests? #f)) ; There are no tests in version 1.0.
+ (home-page "https://www.hexstreamsoft.com/libraries/enhanced-eval-when/";)
+ (synopsis "Shortcuts for EVAL-WHEN")
+ (description
+ "This package provides an enhanced @code{EVAL-WHEN} macro that supports a
+shorthand for @code{(eval-when (:compile-toplevel :load-toplevel :execute)
...)},
+addressing concerns about verbosity.")
+ (license license:unlicense)))
+
+(define-public cl-enhanced-eval-when
+ (sbcl-package->cl-source-package sbcl-enhanced-eval-when))
+
+(define-public ecl-enhanced-eval-when
+ (sbcl-package->ecl-package sbcl-enhanced-eval-when))
+
+(define-public sbcl-enhanced-find-class
+ (package
+ (name "sbcl-enhanced-find-class")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/enhanced-find-class";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-enhanced-find-class" version))
+ (sha256
+ (base32 "1pf1mxb238zrmvgm9s0456s1x0m317ls23ls1d987riw69y3w9vx"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-closer-mop))
+ (home-page "https://www.hexstreamsoft.com/libraries/enhanced-find-class/";)
+ (synopsis "Canonical way of converting class designators to classes")
+ (description
+ "This package provides a canonical way of converting class designators
+to classes.")
+ (license license:unlicense)))
+
+(define-public cl-enhanced-find-class
+ (sbcl-package->cl-source-package sbcl-enhanced-find-class))
+
+(define-public ecl-enhanced-find-class
+ (sbcl-package->ecl-package sbcl-enhanced-find-class))
+
+(define-public sbcl-enhanced-typep
+ (package
+ (name "sbcl-enhanced-typep")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/enhanced-typep";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-enhanced-typep" version))
+ (sha256
+ (base32 "0b22gddkbxnhmi71wa2h51495737lrvsqxnri7g1qdsl1hraml21"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-enhanced-boolean sbcl-parachute))
+ (home-page "https://www.hexstreamsoft.com/libraries/enhanced-typep/";)
+ (synopsis "Enhanced version of typep")
+ (description
+ "This package provides an enhanced version of @code{typep} that is exactly
+like the one in the Lisp spec, except it can also accept a single type
argument,
+in which case it returns the appropriate closure.")
+ (license license:unlicense)))
+
+(define-public cl-enhanced-typep
+ (sbcl-package->cl-source-package sbcl-enhanced-typep))
+
+(define-public ecl-enhanced-typep
+ (sbcl-package->ecl-package sbcl-enhanced-typep))
+
+(define-public sbcl-envy
+ (let ((commit "26a7faadc981f2a047daa36f715a44faec5dd00c")
+ (revision "2"))
+ (package
+ (name "sbcl-envy")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/fukamachi/envy";)
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/promise";)
+ (url "https://github.com/fukamachi/envy";)
(commit commit)))
- (file-name (git-file-name "cl-promise" version))
+ (file-name (git-file-name "cl-envy" version))
(sha256
- (base32 "07cvz6vb5y1d9vndcwq7q1cp54aqvyqzv6wk8vmymbz3lawq2wsn"))))
+ (base32 "1r0wgimd7z57x8cv69sw76w3y5l70hq50882a9nq5l4v64lg55fq"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/promise/";)
- (synopsis "Promise mechanism for asynchronous operations")
- (description
- "This library implements a basic promise datastructure, which is useful
-for dealing with asynchronous behaviours. Importantly, this library does not
-use any other libraries or frameworks, and instead leaves the execution and
-state transition of promise objects in your control, making it easy to
-integrate.")
- (license license:zlib))))
+ (list sbcl-osicat sbcl-prove))
+ (arguments
+ `(#:asd-systems '("envy-test" "envy")
+ ;; FIXME: Tests fail with
+ ;; Component ENVY-ASD::ENVY-TEST not found, required by #<SYSTEM
"envy">
+ ;; https://github.com/fukamachi/envy/issues/10
+ #:tests? #f))
+ (synopsis "Common Lisp configuration switcher inspired by Perl's
Config::ENV")
+ (description "Envy is a configuration manager for various applications.
+Envy uses an environment variable to determine a configuration to use. This
+can separate configuration system from an implementation.")
+ (license license:bsd-2))))
-(define-public ecl-promise
- (sbcl-package->ecl-package sbcl-promise))
+(define-public cl-envy
+ (sbcl-package->cl-source-package sbcl-envy))
-(define-public cl-promise
- (sbcl-package->cl-source-package sbcl-promise))
+(define-public ecl-envy
+ (sbcl-package->ecl-package sbcl-envy))
-(define-public sbcl-uuid
- (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
+(define-public sbcl-eris
+ (package
+ (name "sbcl-eris")
+ (version "0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.ykonai.net/eris-cl";)
+ (commit version)))
+ (file-name (git-file-name "cl-eris" version))
+ (sha256
+ (base32 "0qm74ld70aic39giamvix88500flv86047a82rx9gkjwaisf58rc"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiveam))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-function-cache
+ sbcl-ironclad
+ sbcl-mmap
+ sbcl-osicat
+ sbcl-serapeum
+ sbcl-trivial-gray-streams))
+ (home-page "https://git.ykonai.net/eris-cl/";)
+ (synopsis "ERIS implementation for Common Lisp")
+ (description
+ "This is a Common Lisp implementation of the Encoding for Robust Immutable
+Storage specification (ERIS).")
+ (license license:lgpl3+)))
+
+(define-public cl-eris
+ (sbcl-package->cl-source-package sbcl-eris))
+
+(define-public sbcl-esrap
+ (let ((commit "d806138342a6b27327649fd5f36e0fe2e0966867")
+ (revision "4"))
(package
- (name "sbcl-uuid")
- (version (git-version "2012.12.26" "1" commit))
+ (name "sbcl-esrap")
+ (version (git-version "0.18" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dardoria/uuid";)
+ (url "https://github.com/scymtym/esrap";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-esrap" version))
(sha256
- (base32
- "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
+ (base32 "0gs0mfamldhaihnlk0qxg2q4bl8bamq68dif9js9fkl8apg3iykl"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-ironclad sbcl-trivial-utf-8))
- (home-page "https://github.com/dardoria/uuid";)
- (synopsis
- "Common Lisp implementation of UUIDs according to RFC4122")
+ (list sbcl-alexandria sbcl-trivial-with-current-source-form))
+ (synopsis "Common Lisp packrat parser")
(description
- "Common Lisp implementation of UUIDs according to RFC4122.")
- (license license:llgpl))))
+ "This is a packrat parser for Common Lisp.
+In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP
supports:
-(define-public cl-uuid
- (sbcl-package->cl-source-package sbcl-uuid))
+@itemize
+@item dynamic redefinition of nonterminals
+@item inline grammars
+@item semantic predicates
+@item introspective facilities (describing grammars, tracing, setting breaks)
+@item left-recursive grammars
+@item functions as terminals
+@item accurate, customizable parse error reports
+@end itemize\n")
+ (home-page "https://scymtym.github.io/esrap/";)
+ (license license:expat))))
-(define-public ecl-uuid
- (sbcl-package->ecl-package sbcl-uuid))
+(define-public cl-esrap
+ (sbcl-package->cl-source-package sbcl-esrap))
-(define-public sbcl-dissect
- (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
+(define-public ecl-esrap
+ (sbcl-package->ecl-package sbcl-esrap))
+
+(define-public sbcl-evaled-when
+ (let ((commit "c59f8ab20b846cac81d4be80d056a3d65676e8eb")
+ (revision "0"))
(package
- (name "sbcl-dissect")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-evaled-when")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/dissect";)
+ (url "https://github.com/Hexstream/evaled-when";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-evaled-when" version))
(sha256
- (base32
- "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
+ (base32 "07g1a50aairvsj57issb18si5a9r3skpbk05nlixmlj0mva3gkl3"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-enhanced-boolean sbcl-parachute))
(inputs
- (list sbcl-cl-ppcre))
- (home-page "https://shinmera.github.io/dissect/";)
- (synopsis
- "Introspection library for the call stack and restarts")
+ (list sbcl-trivial-cltl2))
+ (home-page "https://www.hexstreamsoft.com/libraries/evaled-when/";)
+ (synopsis "Extract and replicate the compile-time side-effects of forms")
(description
- "Dissect is a small Common Lisp library for introspecting the call stack
-and active restarts.")
- (license license:zlib))))
+ "This package provides a way of extracting and replicating the
+compile-time side-effects of forms.")
+ (license license:unlicense))))
-(define-public cl-dissect
- (sbcl-package->cl-source-package sbcl-dissect))
+(define-public cl-evaled-when
+ (sbcl-package->cl-source-package sbcl-evaled-when))
-(define-public ecl-dissect
- (sbcl-package->ecl-package sbcl-dissect))
+(define-public ecl-evaled-when
+ (sbcl-package->ecl-package sbcl-evaled-when))
+
+(define-public sbcl-event-emitter
+ (let ((commit "cb0e15f9de4c617cef3f5d5a22a41e28f9613d0b")
+ (revision "0"))
+ (package
+ (name "sbcl-event-emitter")
+ (version (git-version "0.0.1" revision commit))
+ (home-page "https://github.com/fukamachi/event-emitter";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/event-emitter";)
+ (commit commit)))
+ (file-name (git-file-name "cl-event-emitter" version))
+ (sha256
+ (base32 "1i18xzfr6334db9dzj0lsl7wxw1r1l0ixvn883mjbyqw0czp21h6"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove))
+ (synopsis "Event mechanism for Common Lisp objects")
+ (description "Event Emitter provides an event mechanism like Node.js for
+Common Lisp objects. It is mostly ported from Node.js @code{events} module.")
+ (license license:bsd-2))))
+
+(define-public cl-event-emitter
+ (sbcl-package->cl-source-package sbcl-event-emitter))
+
+(define-public ecl-event-emitter
+ (sbcl-package->ecl-package sbcl-event-emitter))
+
+(define-public sbcl-eventbus
+ (let ((commit "92c1fa3846ba0e3cc9e6d7605d765379c8658d84")
+ (revision "1"))
+ (package
+ (name "sbcl-eventbus")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/noloop/eventbus";)
+ (commit commit)))
+ (file-name (git-file-name "eventbus" version))
+ (sha256
+ (base32 "0slqx3zq6sbz3rg4g79j8y25sx4405y6ff3x6l5v8v4v42m1s0p2"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-simplet))
+ (home-page "https://github.com/noloop/eventbus";)
+ (synopsis "Event bus implementation in Common Lisp")
+ (description "This package provides a Common Lisp system implementing
event bus.")
+ (license license:gpl3))))
+
+(define-public cl-eventbus
+ (sbcl-package->cl-source-package sbcl-eventbus))
+
+(define-public ecl-eventbus
+ (sbcl-package->ecl-package sbcl-eventbus))
+
+(define-public sbcl-exit-hooks
+ ;; No release.
+ (let ((commit "78050f4f55c138fcea86a9d720928782021b6012"))
+ (package
+ (name "sbcl-exit-hooks")
+ (version (git-version "0.0.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ailisp/exit-hooks/";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "00rk0pr2cy3hy6giblh166b7yrg06d5lanipjcqv508gkfb0vi47"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/ailisp/exit-hooks";)
+ (synopsis "Call functions automatically when Common Lisp exits")
+ (description
+ "@code{exit-hooks} provides a portable way to automatically call some
+user-defined function when exiting Common Lisp (both @code{quit} from the REPL
+or a kill in a shell). Like @code{atexit} in C and Python or Java’s
+@code{Runtime.addShutdownHook()}. It currently supports SBCL, CCL, ECL, ABCL,
+Allegro CL, clisp and CMUCL. Before exit-hooks, there was no portable way of
+doing so and no staightforward way to use an exit hook on ABCL. It can be used
+for tasks like parmenantly save something when exiting Lisp.")
+ (license license:bsd-2))))
+
+(define-public cl-exit-hooks
+ (sbcl-package->cl-source-package sbcl-exit-hooks))
+
+(define-public ecl-exit-hooks
+ (sbcl-package->ecl-package sbcl-exit-hooks))
(define-public sbcl-exponential-backoff
(let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f"))
@@ -15002,9217 +14390,8902 @@ learn about each of the parameters.")
(define-public ecl-exponential-backoff
(sbcl-package->ecl-package sbcl-exponential-backoff))
-(define-public sbcl-sxql
- (let ((commit "cc3478cacb0557475a59cf619dad66c5dc8080ba")
- (revision "3"))
- (package
- (name "sbcl-sxql")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/sxql";)
- (commit commit)))
- (file-name (git-file-name "cl-sqxl" version))
- (sha256
- (base32 "011an993amy8q3gl4hyqrgnc93cgny3cv9gbp679rrmyyp8zmywr"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cl-package-locks
- sbcl-cl-syntax
- sbcl-iterate
- sbcl-optima
- sbcl-split-sequence
- sbcl-trivia
- sbcl-trivial-types))
- (native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/fukamachi/sxql";)
- (synopsis "SQL generator for Common Lisp")
- (description "SQL generator for Common Lisp.")
- (license license:bsd-3))))
-
-(define-public cl-sxql
- (sbcl-package->cl-source-package sbcl-sxql))
-
-(define-public ecl-sxql
- (sbcl-package->ecl-package sbcl-sxql))
-
-(define-public sbcl-cl-ascii-table
- (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
+(define-public sbcl-external-program
+ (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
(revision "1"))
(package
- (name "sbcl-cl-ascii-table")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-external-program")
+ (version (git-version "0.0.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/telephil/cl-ascii-table";)
+ (url "https://github.com/sellout/external-program";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
+ (base32
+ "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Library to make ascii-art tables")
+ (inputs
+ (list sbcl-trivial-features))
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "Common Lisp library for running external programs")
(description
- "This is a Common Lisp library to present tabular data in ascii-art
-tables.")
- (home-page "https://github.com/telephil/cl-ascii-table";)
- (license license:expat))))
+ "EXTERNAL-PROGRAM enables running programs outside the Lisp
+process. It is an attempt to make the RUN-PROGRAM functionality in
+implementations like SBCL and CCL as portable as possible without
+sacrificing much in the way of power.")
+ (home-page "https://github.com/sellout/external-program";)
+ (license license:llgpl))))
-(define-public cl-ascii-table
- (sbcl-package->cl-source-package sbcl-cl-ascii-table))
+(define-public cl-external-program
+ (sbcl-package->cl-source-package sbcl-external-program))
-(define-public ecl-cl-ascii-table
- (sbcl-package->ecl-package sbcl-cl-ascii-table))
+(define-public ecl-external-program
+ (sbcl-package->ecl-package sbcl-external-program))
-(define-public sbcl-cl-rdkafka
+(define-public sbcl-fakenil
(package
- (name "sbcl-cl-rdkafka")
- (version "1.1.0")
+ (name "sbcl-fakenil")
+ (version "1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/SahilKang/cl-rdkafka";)
+ (url "https://github.com/Hexstream/fakenil";)
(commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-fakenil" version))
(sha256
- (base32
- "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v"))))
+ (base32 "0ipqax3sgcs1dsgxz8d2pmfg324k6l35pn0nz89w5jl02fia61l3"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; Attempts to connect to locally running Kafka
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/low-level/librdkafka-bindings.lisp"
- (("librdkafka" all)
- (string-append (assoc-ref inputs "librdkafka") "/lib/"
- all))))))))
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("librdkafka" ,librdkafka)
- ("lparallel" ,sbcl-lparallel)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (home-page "https://github.com/SahilKang/cl-rdkafka";)
- (synopsis "Common Lisp client library for Apache Kafka")
- (description "A Common Lisp client library for Apache Kafka.")
- (license license:gpl3)))
+ (native-inputs
+ (list sbcl-parachute))
+ (home-page "https://www.hexstreamsoft.com/libraries/fakenil/";)
+ (synopsis "Provides a canonical stand-in for NIL")
+ (description
+ "This package provides a canonical stand-in for NIL for contexts where
+NIL means no value.")
+ (license license:unlicense)))
-(define-public cl-rdkafka
- (sbcl-package->cl-source-package sbcl-cl-rdkafka))
+(define-public cl-fakenil
+ (sbcl-package->cl-source-package sbcl-fakenil))
-(define-public ecl-cl-rdkafka
- (sbcl-package->ecl-package sbcl-cl-rdkafka))
+(define-public ecl-fakenil
+ (sbcl-package->ecl-package sbcl-fakenil))
-(define-public sbcl-acclimation
- (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
+(define-public sbcl-fare-csv
+ (let ((commit "f877a238dcbf587a89359cccf2128919a94a348c")
+ (revision "0"))
(package
- (name "sbcl-acclimation")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-fare-csv")
+ (version (git-version "1.0.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Acclimation";)
+ (url "https://gitlab.common-lisp.net/frideau/fare-csv";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-fare-csv" version))
(sha256
- (base32
- "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
+ (base32 "0k3mf968w94m4yff1k2jh7xlnpsm016qs4448bvklacjrr72vk8x"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/robert-strandh/Acclimation";)
- (synopsis "Internationalization library for Common Lisp")
- (description "This project is meant to provide tools for
-internationalizing Common Lisp programs.
+ (native-inputs (list sbcl-hu.dwim.stefil))
+ (home-page "https://gitlab.common-lisp.net/frideau/fare-csv/";)
+ (synopsis "Robust CSV parser and printer")
+ (description
+ "This package provides a robust CSV parser and printer that tries to
+follow the fine print of de facto standards. It can be configured to choose
+which standard exactly.")
+ (license license:expat))))
-One important aspect of internationalization is of course the language used in
-error messages, documentation strings, etc. But with this project we provide
-tools for all other aspects of internationalization as well, including dates,
-weight, temperature, names of physical quantitites, etc.")
- (license license:bsd-2))))
+(define-public cl-fare-csv
+ (sbcl-package->cl-source-package sbcl-fare-csv))
-(define-public cl-acclimation
- (sbcl-package->cl-source-package sbcl-acclimation))
-
-(define-public ecl-acclimation
- (sbcl-package->ecl-package sbcl-acclimation))
+(define-public ecl-fare-csv
+ (sbcl-package->ecl-package sbcl-fare-csv))
-(define-public sbcl-clump
- (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
+(define-public sbcl-fare-mop
+ (let ((commit "538aa94590a0354f382eddd9238934763434af30")
+ (revision "1"))
(package
- (name "sbcl-clump")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-fare-mop")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Clump";)
+ (url "https://github.com/fare/fare-mop";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "fare-mop" version))
(sha256
(base32
- "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
- (inputs
- (list sbcl-acclimation))
+ "0maxs8392953fhnaa6zwnm2mdbhxjxipp4g4rvypm06ixr6pyv1c"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/robert-strandh/Clump";)
- (synopsis "Collection of tree implementations for Common Lisp")
- (description "The purpose of this library is to provide a collection of
-implementations of trees.
-
-In contrast to existing libraries such as cl-containers, it does not impose a
-particular use for the trees. Instead, it aims for a stratified design,
-allowing client code to choose between different levels of abstraction.
-
-As a consequence of this policy, low-level interfaces are provided where
-the concrete representation is exposed, but also high level interfaces
-where the trees can be used as search trees or as trees that represent
-sequences of objects.")
- (license license:bsd-2))))
+ (inputs
+ (list sbcl-closer-mop sbcl-fare-utils))
+ (home-page "https://github.com/fare/fare-mop";)
+ (synopsis "General purpose Common Lisp utilities using the MOP")
+ (description
+ "FARE-MOP is a small collection of utilities using the MetaObject
+Protocol. It notably contains a SIMPLE-PRINT-OBJECT method, and
+a SIMPLE-PRINT-OBJECT-MIXIN mixin that allow you to trivially define
+PRINT-OBJECT methods that print the interesting slots in your objects, which is
+great for REPL interaction and debugging.")
+ (license license:unlicense))))
-(define-public cl-clump
- (sbcl-package->cl-source-package sbcl-clump))
+(define-public ecl-fare-mop
+ (sbcl-package->ecl-package sbcl-fare-mop))
-(define-public ecl-clump
- (sbcl-package->ecl-package sbcl-clump))
+(define-public cl-fare-mop
+ (sbcl-package->cl-source-package sbcl-fare-mop))
-(define-public sbcl-cluffer
- (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
+(define-public sbcl-fare-quasiquote
+ (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
+ (revision "1"))
(package
- (name "sbcl-cluffer")
- (version (git-version "0.0.0" "1" commit))
+ (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 "https://github.com/robert-strandh/cluffer";)
+ (url (string-append "https://gitlab.common-lisp.net/frideau/";
+ "fare-quasiquote.git"))
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
- (build-system asdf-build-system/sbcl)
+ (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
(inputs
- (list sbcl-acclimation sbcl-clump))
+ `(("fare-utils" ,sbcl-fare-utils)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("optima" ,sbcl-optima)))
(arguments
- `(#:phases
+ ;; XXX: Circular dependencies: Tests depend on subsystems,
+ ;; which depend on the main systems.
+ `(#:tests? #f
+ #:asd-systems '("fare-quasiquote"
+ "fare-quasiquote-extras")
+ #:phases
(modify-phases %standard-phases
- (add-after 'install 'unpatch-shebangs
- (lambda* (#:key outputs #:allow-other-keys)
- ;; The documentation Makefile rely on shell scripts.
- ;; TODO: Build it!
- ;; In the mean time, remove the shabang as it adds bash to the
- ;; closure.
- (let* ((out (assoc-ref outputs "out"))
- (build-aux (string-append
- out "/share/")))
- (substitute* (find-files build-aux)
- (("^#!.*/bin/sh") "#!/bin/sh")
- (("^#!.*/bin/bash") "#!/bin/bash"))))))))
- (home-page "https://github.com/robert-strandh/cluffer";)
- (synopsis "Common Lisp library providing a protocol for text-editor
buffers")
- (description "Cluffer is a library for representing the buffer of a text
-editor. As such, it defines a set of CLOS protocols for client code to
-interact with the buffer contents in various ways, and it supplies different
-implementations of those protocols for different purposes.")
- (license license:bsd-2))))
+ ;; 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\""))
+ (substitute* "fare-quasiquote-optima.asd"
+ (("\\(:version \"optima\" \"1\\.0\"\\)")
+ "\"optima\""))
+ #t)))))
+ (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-cluffer
- (sbcl-package->cl-source-package sbcl-cluffer))
+(define-public cl-fare-quasiquote
+ (sbcl-package->cl-source-package sbcl-fare-quasiquote))
-(define-public ecl-cluffer
- (sbcl-package->ecl-package sbcl-cluffer))
+(define-public ecl-fare-quasiquote
+ (sbcl-package->ecl-package sbcl-fare-quasiquote))
-(define-public sbcl-cl-libsvm-format
- (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
- (revision "0"))
+(define-public sbcl-fare-utils
+ (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724")
+ (revision "1"))
(package
- (name "sbcl-cl-libsvm-format")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-fare-utils")
+ (version (git-version "1.0.0.5" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/masatoi/cl-libsvm-format";)
- (commit commit)))
+ (uri
+ (git-reference
+ (url
+ "https://gitlab.common-lisp.net/frideau/fare-utils.git";)
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
+ "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-prove))
- (inputs
- (list sbcl-alexandria))
- (synopsis "LibSVM data format reader for Common Lisp")
+ (list sbcl-hu.dwim.stefil))
+ (synopsis "Collection of utilities and data structures")
(description
- "This Common Lisp library provides a fast reader for data in LibSVM
-format.")
- (home-page "https://github.com/masatoi/cl-libsvm-format";)
+ "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-libsvm-format
- (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
+(define-public cl-fare-utils
+ (sbcl-package->cl-source-package sbcl-fare-utils))
-(define-public ecl-cl-libsvm-format
- (sbcl-package->ecl-package sbcl-cl-libsvm-format))
+(define-public ecl-fare-utils
+ (sbcl-package->ecl-package sbcl-fare-utils))
-(define-public sbcl-cl-online-learning
- (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964")
- (revision "1"))
+(define-public sbcl-fast-generic-functions
+ (let ((commit "9c307cd28af6453e45038ac3510de3123ff23743"))
(package
- (name "sbcl-cl-online-learning")
- (version (git-version "0.5" revision commit))
+ (name "sbcl-fast-generic-functions")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/masatoi/cl-online-learning";)
+ (url "https://github.com/marcoheisig/fast-generic-functions/";)
(commit commit)))
- (file-name (git-file-name "cl-online-learning" version))
+ (file-name (git-file-name "cl-fast-generic-functions" version))
(sha256
- (base32
- "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9"))))
+ (base32 "16hf9bi2p5s77p3m3aqsihcd9iicqjhhxxpsarjv93c41qs54yad"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
(inputs
- `(("cl-libsvm-format" ,sbcl-cl-libsvm-format)
- ("cl-store" ,sbcl-cl-store)))
- (home-page "https://github.com/masatoi/cl-online-learning";)
- (synopsis "Online Machine Learning for Common Lisp")
+ (list sbcl-closer-mop
+ sbcl-sealable-metaobjects
+ sbcl-trivial-macroexpand-all))
+ (arguments
+ ;; Tests fail:
https://github.com/marcoheisig/fast-generic-functions/issues/10
+ '(#:tests? #f))
+ (home-page "https://github.com/marcoheisig/fast-generic-functions/";)
+ (synopsis "Seal generic functions to boost performance")
(description
- "This library contains a collection of machine learning algorithms for
-online linear classification written in Common Lisp.")
+ "This library introduces @emph{fast generic functions}, i.e. functions
+that behave just like regular generic functions, except that the can be sealed
+on certain domains. If the compiler can then statically detect that the
+arguments to a fast generic function fall within such a domain, it will
+perform a variety of optimizations.")
(license license:expat))))
-(define-public cl-online-learning
- (sbcl-package->cl-source-package sbcl-cl-online-learning))
+(define-public cl-fast-generic-functions
+ (sbcl-package->cl-source-package sbcl-fast-generic-functions))
-(define-public ecl-cl-online-learning
- (sbcl-package->ecl-package sbcl-cl-online-learning))
+(define-public ecl-fast-generic-functions
+ (sbcl-package->ecl-package sbcl-fast-generic-functions))
-(define-public sbcl-cl-mpg123
- (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d")
- (revision "1"))
+(define-public sbcl-fast-http
+ (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
+ (revision "2"))
(package
- (name "sbcl-cl-mpg123")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-fast-http")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-mpg123";)
+ (url "https://github.com/fukamachi/fast-http";)
(commit commit)))
- (file-name (git-file-name "cl-mpg123" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; Remove bundled pre-compiled libraries.
- (delete-file-recursively "static")
- #t))))
+ (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("cl-mpg123" "cl-mpg123-example")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "low-level.lisp"
- (("libmpg123.so" all)
- (string-append (assoc-ref inputs "libmpg123")
- "/lib/" all))))))))
+ '(#:asd-systems '("fast-http-test" "fast-http")))
+ (native-inputs
+ `(("sbcl-prove" ,sbcl-prove)
+ ("cl-syntax" ,sbcl-cl-syntax)))
(inputs
- `(("cffi" ,sbcl-cffi)
- ("cl-out123" ,sbcl-cl-out123)
- ("documentation-utils" ,sbcl-documentation-utils)
- ("libmpg123" ,mpg123)
- ("trivial-features" ,sbcl-trivial-features)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("verbose" ,sbcl-verbose)))
- (home-page "https://shirakumo.github.io/cl-mpg123/";)
- (synopsis "Common Lisp bindings to libmpg123")
+ (list sbcl-alexandria sbcl-proc-parse sbcl-xsubseq
+ sbcl-smart-buffer sbcl-cl-utilities))
+ (home-page "https://github.com/fukamachi/fast-http";)
+ (synopsis "HTTP request/response parser for Common Lisp")
(description
- "This is a bindings and wrapper library to @code{libmpg123} allowing for
-convenient, extensive, and fast decoding of MPEG1/2/3 (most prominently mp3)
-files.")
- (license license:zlib))))
+ "@code{fast-http} is a HTTP request/response protocol parser for Common
+Lisp.")
+ ;; Author specified the MIT license
+ (license license:expat))))
-(define-public ecl-cl-mpg123
- (sbcl-package->ecl-package sbcl-cl-mpg123))
+(define-public cl-fast-http
+ (sbcl-package->cl-source-package sbcl-fast-http))
-(define-public cl-mpg123
- (sbcl-package->cl-source-package sbcl-cl-mpg123))
+(define-public ecl-fast-http
+ (sbcl-package->ecl-package sbcl-fast-http))
-(define-public sbcl-cl-out123
- (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7")
- (revision "2"))
+(define-public sbcl-fast-io
+ (let ((commit "a4c5ad600425842e8b6233b1fa22610ffcd874c3")
+ (revision "3"))
(package
- (name "sbcl-cl-out123")
+ (name "sbcl-fast-io")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/fast-io";)
+ (commit commit)))
+ (file-name (git-file-name "cl-fast-io" version))
+ (sha256
+ (base32 "0wh02yagbqahy9z6787jz5ggpagvr18qd0z13wvwq1vjf8xd2530"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam sbcl-checkl))
+ (inputs
+ (list sbcl-alexandria sbcl-trivial-gray-streams sbcl-static-vectors))
+ (home-page "https://github.com/rpav/fast-io";)
+ (synopsis "Fast octet-vector/stream I/O for Common Lisp")
+ (description
+ "Fast-io is about improving performance to octet-vectors and octet
+streams (though primarily the former, while wrapping the latter).")
+ ;; Author specifies this as NewBSD which is an alias
+ (license license:bsd-3))))
+
+(define-public cl-fast-io
+ (sbcl-package->cl-source-package sbcl-fast-io))
+
+(define-public ecl-fast-io
+ (sbcl-package->ecl-package sbcl-fast-io))
+
+(define-public sbcl-fast-websocket
+ (let ((commit "baeeaddf1447015863d708f840ef9dfc5ff5b7a2")
+ (revision "1"))
+ (package
+ (name "sbcl-fast-websocket")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/fukamachi/fast-websocket";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/fast-websocket";)
+ (commit commit)))
+ (file-name (git-file-name "cl-fast-websoclet" version))
+ (sha256
+ (base32 "1j7v00gbkzx4mq2v8y44jm4jx321hgrv9igfw23cvzzlyd3dzp6y"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Test system must be loaded before, otherwise tests fail with:
+ ;; Component FAST-WEBSOCKET-ASD::FAST-WEBSOCKET-TEST not found,
+ ;; required by #<SYSTEM "fast-websocket">.
+ '(#:asd-systems '("fast-websocket-test"
+ "fast-websocket")))
+ (inputs
+ (list sbcl-fast-io
+ sbcl-babel
+ sbcl-alexandria))
+ (native-inputs
+ (list sbcl-prove
+ sbcl-trivial-utf-8))
+ (synopsis "WebSocket protocol parser for Common Lisp")
+ (description
+ "@code{fast-websocket} is an optimized low-level WebSocket protocol
+parser/composer.")
+ (license license:bsd-2))))
+
+(define-public cl-fast-websocket
+ (sbcl-package->cl-source-package sbcl-fast-websocket))
+
+(define-public ecl-fast-websocket
+ (sbcl-package->ecl-package sbcl-fast-websocket))
+
+(define-public sbcl-feeder
+ ;; No release.
+ (let ((commit "b05f517d7729564575cc809e086c262646a94d34")
+ (revision "1"))
+ (package
+ (name "sbcl-feeder")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-out123";)
+ (url "https://github.com/Shinmera/feeder";)
(commit commit)))
- (file-name (git-file-name "cl-out123" version))
+ (file-name (git-file-name "feeder" version))
(sha256
- (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; Remove bundled pre-compiled libraries.
- (delete-file-recursively "static")))))
+ (base32 "1dpbzhycg50snl3j01c8dh8gdvhfhz0hnfl54xy55a3wbr3m6rp7"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; No tests
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "low-level.lisp"
- (("libout123.so")
- (search-input-file inputs "/lib/libout123.so"))))))))
(inputs
- (list mpg123
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-documentation-utils
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (home-page "https://shirakumo.github.io/cl-out123/";)
- (synopsis "Common Lisp bindings to libout123")
+ (list sbcl-documentation-utils sbcl-local-time sbcl-plump))
+ (home-page "https://shinmera.github.io/feeder/";)
+ (synopsis "RSS, Atom and general feed parsing and generating")
(description
- "This is a bindings library to @code{libout123} which allows easy
-cross-platform audio playback.")
+ "Feeder is a syndication feed library. It presents a general protocol
+for representation of feed items, as well as a framework to translate these
+objects from and to external formats. It also implements the RSS 2.0 and Atom
+formats within this framework.")
(license license:zlib))))
-(define-public ecl-cl-out123
- (sbcl-package->ecl-package sbcl-cl-out123))
+(define-public cl-feeder
+ (sbcl-package->cl-source-package sbcl-feeder))
-(define-public cl-out123
- (sbcl-package->cl-source-package sbcl-cl-out123))
+(define-public ecl-feeder
+ (sbcl-package->ecl-package sbcl-feeder))
-(define-public sbcl-cl-portaudio
- (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f")
+(define-public sbcl-ffa
+ (let ((commit "b7012f51c4c37d1e759ff9cf78cea178504d8e07")
(revision "1"))
(package
- (name "sbcl-cl-portaudio")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-ffa")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/filonenko-mikhail/cl-portaudio";)
+ (url "https://github.com/tpapp/ffa";)
(commit commit)))
- (file-name (git-file-name "cl-portaudio" version))
+ (file-name (git-file-name "cl-ffa" version))
(sha256
- (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb"))))
+ (base32 "0l7kqcjp3sn1129hpwq6zhjqc0ydx9gc53z7k13i38x3z1asap7a"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list portaudio sbcl-cffi sbcl-ffa))
- (arguments
- (list #:tests? #f ; Tests need access to sound cards
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/portaudio.lisp"
- (("libportaudio\\.so")
- (search-input-file inputs
"/lib/libportaudio.so"))))))))
- (synopsis "Common Lisp bindings to portaudio")
+ (list sbcl-cffi sbcl-cl-utilities sbcl-iterate sbcl-metabang-bind))
+ (synopsis "Foreign friendly arrays for Common Lisp")
(description
- "This package provides audio input and output functions to Common Lisp
-using bindings to the portaudio library.")
- (home-page "https://github.com/filonenko-mikhail/cl-portaudio";)
- (license license:expat))))
+ "This package provides a macro that allows foreign functions to access
+the contents of the array at a given pointer, using the best available method
+given the Common Lisp implementation.")
+ (home-page "https://cliki.net/ffa";)
+ (license license:llgpl))))
-(define-public cl-portaudio
- (sbcl-package->cl-source-package sbcl-cl-portaudio))
+(define-public cl-ffa
+ (sbcl-package->cl-source-package sbcl-ffa))
-(define-public ecl-cl-portaudio
- (sbcl-package->ecl-package sbcl-cl-portaudio))
+(define-public ecl-ffa
+ (sbcl-package->ecl-package sbcl-ffa))
-(define-public sbcl-cl-random-forest
- (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
- (revision "1"))
+(define-public sbcl-file-attributes
+ (let ((commit "bbde396438f37d676de9775239115410bec4da2d"))
(package
- (name "sbcl-cl-random-forest")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-file-attributes")
+ (version (git-version "1.0.0" "2" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/masatoi/cl-random-forest";)
+ (url "https://github.com/Shinmera/file-attributes/";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
+ (base32 "0n8q818ry2shggjfhp8gjby8v5mla9pg97c5g19pcglpnwim7a74"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-libsvm-format" ,sbcl-cl-libsvm-format)
- ("cl-online-learning" ,sbcl-cl-online-learning)
- ("lparallel" ,sbcl-lparallel)))
- (arguments
- `(#:tests? #f)) ; The tests download data from the Internet
- (synopsis "Random Forest and Global Refinement for Common Lisp")
+ (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-features))
+ (home-page "https://shinmera.github.io/file-attributes/";)
+ (synopsis "Access to common file attributes in Common Lisp")
(description
- "CL-random-forest is an implementation of Random Forest for multiclass
-classification and univariate regression written in Common Lisp. It also
-includes an implementation of Global Refinement of Random Forest.")
- (home-page "https://github.com/masatoi/cl-random-forest";)
- (license license:expat))))
+ "This is a small OS portability library to retrieve and set file
+attributes not supported by the Common Lisp standard functions.")
+ (license license:zlib))))
-(define-public cl-random-forest
- (sbcl-package->cl-source-package sbcl-cl-random-forest))
+(define-public ecl-file-attributes
+ (sbcl-package->ecl-package sbcl-file-attributes))
-(define-public ecl-cl-random-forest
- (sbcl-package->ecl-package sbcl-cl-random-forest))
+(define-public cl-file-attributes
+ (sbcl-package->cl-source-package sbcl-file-attributes))
-(define-public sbcl-bordeaux-fft
- (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
+(define-public sbcl-file-notify
+ (let ((commit "f12dc2f2aae5fee13355cd93a8cae0c4c412b76d")
(revision "0"))
(package
- (name "sbcl-bordeaux-fft")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-file-notify")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ahefner/bordeaux-fft";)
+ (url "https://github.com/Shinmera/file-notify";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-file-notify" version))
(sha256
- (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
+ (base32 "0788d98rqm1krl8nbfh8qshvyf6g336i9bqrdhkx06cfvbh0wcny"))))
(build-system asdf-build-system/sbcl)
- (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/";)
- (synopsis "Fast Fourier Transform for Common Lisp")
- (description
- "The Bordeaux-FFT library provides a reasonably efficient implementation
-of the Fast Fourier Transform and its inverse for complex-valued inputs, in
-portable Common Lisp.")
- (license license:gpl2+))))
+ (inputs
+ (list sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-trivial-features))
+ (home-page "https://github.com/Shinmera/file-notify";)
+ (synopsis "Get notifications for file accesses and changes")
+ (description
+ "File-Notify is a Common Lisp library for getting notifications for file
+accesses and changes.")
+ (license license:zlib))))
-(define-public cl-bordeaux-fft
- (sbcl-package->cl-source-package sbcl-bordeaux-fft))
+(define-public cl-file-notify
+ (sbcl-package->cl-source-package sbcl-file-notify))
-(define-public ecl-bordeaux-fft
- (sbcl-package->ecl-package sbcl-bordeaux-fft))
+(define-public ecl-file-notify
+ (sbcl-package->ecl-package sbcl-file-notify))
-(define-public sbcl-napa-fft3
- (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
- (revision "0"))
+(define-public sbcl-file-select
+ (let ((commit "ef25f6d7c78ed9e0b62119979af8c4b5b0f8c774")
+ (revision "1"))
(package
- (name "sbcl-napa-fft3")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-file-select")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pkhuong/Napa-FFT3";)
+ (url "https://github.com/Shinmera/file-select";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "file-select" version))
(sha256
- (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
+ (base32 "1qh32ymljw5c98zzbvjfq6jzwlzs4qxi8gh4gw8pixir6y1inxaa"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pkhuong/Napa-FFT3";)
- (synopsis "Fast Fourier Transform routines in Common Lisp")
+ (inputs
+ (list sbcl-cffi
+ sbcl-documentation-utils
+ sbcl-float-features))
+ (home-page "https://shinmera.github.io/file-select/";)
+ (synopsis "Invoke the native file selection dialogs to open or save
files")
(description
- "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
-buildings blocks to express common operations that involve DFTs: filtering,
-convolutions, etc.")
- (license license:bsd-3))))
+ "This library allows you to open native file dialogs to open and save
+files. This is useful if you have an application that's primarily text based
+and would like a more convenient file selection utility, or if you are working
+with a UI toolkit that does not offer a way to access the native file dialogs
+directly.")
+ (license license:zlib))))
-(define-public cl-napa-fft3
- (sbcl-package->cl-source-package sbcl-napa-fft3))
+(define-public cl-file-select
+ (sbcl-package->cl-source-package sbcl-file-select))
-(define-public sbcl-cl-tga
- (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
- (revision "0"))
+(define-public ecl-file-select
+ (sbcl-package->ecl-package sbcl-file-select))
+
+(define-public sbcl-filesystem-utils
+ (let ((commit "a07e8b61b89d4b46408fb9294d9b8130e8c8a02e")
+ (revision "2"))
(package
- (name "sbcl-cl-tga")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-filesystem-utils")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fisxoj/cl-tga";)
+ (url "https://github.com/Shinmera/filesystem-utils/";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-filesystem-utils" version))
(sha256
- (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
+ (base32 "1zv2i2gndnbs7hz3bgkkq1qfx604wbndpc7qqlqvg23fssn9w59f"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/fisxoj/cl-tga";)
- (synopsis "TGA file loader for Common Lisp")
+ (inputs
+ (list sbcl-documentation-utils
+ sbcl-pathname-utils
+ sbcl-trivial-features))
+ (home-page "https://shinmera.github.io/filesystem-utils/";)
+ (synopsis "Collection of utilities for filesystem interaction")
(description
- "Cl-tga was written to facilitate loading @emph{.tga} files into OpenGL
-programs. It's a very simple library, and, at the moment, only supports
-non-RLE encoded forms of the files.")
- (license license:expat))))
+ "This is an extension library to @code{pathname-utils}, to allow
+dealing with common problems with filesystems, such as listing files, probing
+file types, determining default directories, etc.")
+ (license license:zlib))))
-(define-public cl-tga
- (sbcl-package->cl-source-package sbcl-cl-tga))
+(define-public cl-filesystem-utils
+ (sbcl-package->cl-source-package sbcl-filesystem-utils))
-(define-public ecl-cl-tga
- (sbcl-package->ecl-package sbcl-cl-tga))
+(define-public ecl-filesystem-utils
+ (sbcl-package->ecl-package sbcl-filesystem-utils))
-(define-public sbcl-com.gigamonkeys.binary-data
- (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
- (revision "0"))
+(define-public sbcl-filtered-functions
+ (let ((commit "130f69e7b9e1051bf569ef63364b09a3873f0ced"))
(package
- (name "sbcl-com.gigamonkeys.binary-data")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-filtered-functions")
+ (version (git-version "0.2.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/gigamonkey/monkeylib-binary-data";)
+ (url "https://github.com/pcostanza/filtered-functions";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-filtered-functions" version))
(sha256
- (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
+ (base32 "0m13k8pl0gfll8ss83c0z3gax7zrrw2i4s26451jfbka1xr4fgy9"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/gigamonkey/monkeylib-binary-data";)
- (synopsis "Common Lisp library for reading and writing binary data")
+ (list sbcl-closer-mop))
+ (home-page "https://github.com/pcostanza/filtered-functions";)
+ (synopsis "Extension of CLOS generic function invocation")
(description
- "This a Common Lisp library for reading and writing binary data. It is
-based on code from chapter 24 of the book @emph{Practical Common Lisp}.")
- (license license:bsd-3))))
+ "Filtered functions provide an extension of CLOS generic function
+invocation that add a simple preprocessing step before the actual method
+dispatch is performed and thus enable the use of arbitrary predicates for
+selecting and applying methods. See
+@url{http://www.p-cos.net/documents/filtered-dispatch.pdf} for a paper that
+introduces and explains filtered functions in detail.")
+ (license license:expat))))
-(define-public cl-com.gigamonkeys.binary-data
- (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
+(define-public cl-filtered-functions
+ (sbcl-package->cl-source-package sbcl-filtered-functions))
-(define-public ecl-com.gigamonkeys.binary-data
- (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
+(define-public ecl-filtered-functions
+ (sbcl-package->ecl-package sbcl-filtered-functions))
-(define-public sbcl-deflate
- (package
- (name "sbcl-deflate")
- (version "1.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/pmai/Deflate";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pmai/Deflate";)
- (synopsis "Native deflate decompression for Common Lisp")
- (description
- "This library is an implementation of Deflate (RFC 1951) decompression,
-with optional support for ZLIB-style (RFC 1950) and gzip-style (RFC 1952)
-wrappers of deflate streams. It currently does not handle compression.")
- (license license:expat)))
+(define-public sbcl-find-port
+ (let ((commit "811727f88d7f000623bf92fdb0e64678a7112a28")
+ (revision "2"))
+ (package
+ (name "sbcl-find-port")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "0.1" revision commit))
+ (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
+ "1fw6q7d2bxxb7fqk548ylq8mx4sz95yc0q5h0rwd0mnqjrbwbari"))))
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list 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-deflate
- (sbcl-package->cl-source-package sbcl-deflate))
+(define-public cl-find-port
+ (sbcl-package->cl-source-package sbcl-find-port))
-(define-public ecl-deflate
- (sbcl-package->ecl-package sbcl-deflate))
+(define-public ecl-find-port
+ (sbcl-package->ecl-package sbcl-find-port))
-(define-public sbcl-skippy
- (let ((commit "e456210202ca702c792292c5060a264d45e47090")
+(define-public sbcl-flamegraph
+ (let ((commit "1ed7a718eae88bd35e1649a1c716d46c59dc0a24")
(revision "0"))
(package
- (name "sbcl-skippy")
- (version (git-version "1.3.12" revision commit))
+ (name "sbcl-flamegraph")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/xach/skippy";)
+ ;; This is a fork with fixes for latest SBCL.
+ (url "https://github.com/ruricolist/cl-flamegraph";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-flamegraph" version))
(sha256
- (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
+ (base32 "1aj7hhvav9j9c66ssy11ry3p6xqb912yafi91g6sin6pdx84c2lw"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://xach.com/lisp/skippy/";)
- (synopsis "Common Lisp library for GIF images")
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://github.com/40ants/cl-flamegraph";)
+ (synopsis "Generate flamegraphs of Common Lisp code")
(description
- "Skippy is a Common Lisp library to read and write GIF image files.")
- (license license:bsd-2))))
-
-(define-public cl-skippy
- (sbcl-package->cl-source-package sbcl-skippy))
+ "@code{cl-flamegraph} is a wrapper around SBCL's statistical profiler.
+It saves stack traces of profiled code in a form suitable for processing by
+the @command{flamegraph.pl} script, which is available in the Guix package
+@code{flamegraph}.")
+ (license license:bsd-3))))
-(define-public ecl-skippy
- (sbcl-package->ecl-package sbcl-skippy))
+(define-public cl-flamegraph
+ (sbcl-package->cl-source-package sbcl-flamegraph))
-(define-public sbcl-cl-freetype2
- (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04")
+(define-public sbcl-flare
+ (let ((commit "4f9f17a4fc5b368c2a1988b9a20288695b8d8c48")
(revision "1"))
(package
- (name "sbcl-cl-freetype2")
- (version (git-version "1.1" revision commit))
+ (name "sbcl-flare")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/cl-freetype2";)
+ (url "https://github.com/Shinmera/flare";)
(commit commit)))
- (file-name (git-file-name "cl-freetype2" version))
+ (file-name (git-file-name "flare" version))
(sha256
- (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q"))))
+ (base32 "00nm3sjngbflj2gd5q0xs2m136w4kix6krww23nk64pkkyq2fs86"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list freetype
- sbcl-alexandria
- sbcl-cffi
+ (list sbcl-3d-vectors
+ sbcl-array-utils
+ sbcl-documentation-utils
+ sbcl-for
+ sbcl-lambda-fiddle
sbcl-trivial-garbage))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/ffi/ft2-lib.lisp"
- (("\"libfreetype\"")
- (string-append "\"" (assoc-ref inputs "freetype")
- "/lib/libfreetype\"")))
- (substitute* "src/ffi/grovel/grovel-freetype2.lisp"
- (("-I/usr/include/freetype")
- (string-append "-I" (assoc-ref inputs "freetype")
- "/include/freetype")))
- #t)))))
- (home-page "https://github.com/rpav/cl-freetype2";)
- (synopsis "Common Lisp bindings for Freetype 2")
+ (home-page "https://shinmera.github.io/flare/";)
+ (synopsis "Easy particle systems with fine grained control")
(description
- "This is a general Freetype 2 wrapper for Common Lisp using CFFI. It's
-geared toward both using Freetype directly by providing a simplified API, as
-well as providing access to the underlying C structures and functions for use
-with other libraries which may also use Freetype.")
- (license license:bsd-3))))
+ "FLARE is a library designed to allow quick and precise particle effect
+creations. It does not concern itself with displaying and only with the
+management and movement of particles. As such, it can easily be integrated
into
+any existing or future application.")
+ (license license:zlib))))
-(define-public cl-freetype2
- (sbcl-package->cl-source-package sbcl-cl-freetype2))
+(define-public cl-flare
+ (sbcl-package->cl-source-package sbcl-flare))
-(define-public ecl-cl-freetype2
- (sbcl-package->ecl-package sbcl-cl-freetype2))
+(define-public ecl-flare
+ (sbcl-package->ecl-package sbcl-flare))
-(define-public sbcl-opticl-core
- (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
+(define-public sbcl-flexi-streams
+ (let ((commit "74a1027311371a57258eba1bc908e050f5702277")
(revision "0"))
(package
- (name "sbcl-opticl-core")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-flexi-streams")
+ (version (git-version "1.0.19" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slyrus/opticl-core";)
+ (url "https://github.com/edicl/flexi-streams";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-flexi-streams" version))
(sha256
- (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
+ (base32 "04azqvz11s8dngy49bjl19hrfn0ip1b7m0szm4hlppq364msil7b"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'make-git-checkout-writable
+ (lambda _
+ (for-each make-file-writable (find-files ".")))))))
(inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/slyrus/opticl-core";)
- (synopsis "Core classes and pixel access macros for Opticl")
- (description
- "This Common Lisp library contains the core classes and pixel access
-macros for the Opticl image processing library.")
- (license license:bsd-2))))
+ (list sbcl-trivial-gray-streams))
+ (synopsis "Implementation of virtual bivalent streams for Common Lisp")
+ (description "Flexi-streams is an implementation of \"virtual\" bivalent
+streams that can be layered atop real binary or bivalent streams and that can
+be used to read and write character data in various single- or multi-octet
+encodings which can be changed on the fly. It also supplies in-memory binary
+streams which are similar to string streams.")
+ (home-page "http://weitz.de/flexi-streams/";)
+ (license license:bsd-3))))
-(define-public cl-opticl-core
- (sbcl-package->cl-source-package sbcl-opticl-core))
+(define-public cl-flexi-streams
+ (sbcl-package->cl-source-package sbcl-flexi-streams))
-(define-public ecl-opticl-core
- (sbcl-package->ecl-package sbcl-opticl-core))
+(define-public ecl-flexi-streams
+ (sbcl-package->ecl-package sbcl-flexi-streams))
-(define-public sbcl-retrospectiff
- (let ((commit "2fbf8c687799487654d988c7036d19d75a7fc67d")
- (revision "1"))
+(define-public sbcl-flexichain
+ ;; There are no releases.
+ (let ((commit "9af644a6323f303a936a391b956babcbfe7b0c67")
+ (revision "2"))
(package
- (name "sbcl-retrospectiff")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-flexichain")
+ (version (git-version "1.5.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slyrus/retrospectiff";)
+ (url "https://github.com/robert-strandh/Flexichain";)
(commit commit)))
- (file-name (git-file-name "cl-retrospectiff" version))
+ (file-name (git-file-name "cl-flexichain" version))
(sha256
- (base32 "1vfcbfzhkm2wkxnjg7y6gg93wlib9cqpbdbhyqcm5kc7170ci3vz"))))
+ (base32 "1ivkffnkc1iqmpl1p1rgyfbbgjmjcid4iszvdql1jjz324lq94g6"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-cl-jpeg
- sbcl-com.gigamonkeys.binary-data
- sbcl-deflate
- sbcl-flexi-streams
- sbcl-ieee-floats
- sbcl-opticl-core))
- (home-page "https://github.com/slyrus/retrospectiff";)
- (synopsis "Common Lisp library for TIFF images")
+ (list sbcl-trivial-garbage))
+ (home-page "https://github.com/robert-strandh/Flexichain.git";)
+ (synopsis "Dynamically add elements to or remove them from sequences")
(description
- "Retrospectiff is a common lisp library for reading and writing images
-in the TIFF (Tagged Image File Format) format.")
- (license license:bsd-2))))
+ "This package provides an implementation of the flexichain protocol,
+allowing client code to dynamically add elements to, and delete elements from
+a sequence (or chain) of such elements.")
+ (license license:lgpl2.1+))))
-(define-public cl-retrospectif
- (sbcl-package->cl-source-package sbcl-retrospectiff))
+(define-public ecl-flexichain
+ (sbcl-package->ecl-package sbcl-flexichain))
-(define-public ecl-retrospectiff
- (sbcl-package->ecl-package sbcl-retrospectiff))
+(define-public cl-flexichain
+ (sbcl-package->cl-source-package sbcl-flexichain))
-(define-public sbcl-mmap
- (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
- (revision "0"))
+(define-public sbcl-float-features
+ (let ((commit "c1f86aea91cfaa3aa59799162be23ef8a12b199d")
+ (revision "2"))
(package
- (name "sbcl-mmap")
+ (name "sbcl-float-features")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/mmap";)
+ (url "https://github.com/Shinmera/float-features";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "float-features" version))
(sha256
- (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
+ (base32 "0vqm9xhn2i4vbjrxnp4hr1l3lydjflhjykdz6cmqg2j48c5kh3g3"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria sbcl-cffi sbcl-parachute
- sbcl-trivial-features))
- (inputs
- (list sbcl-cffi sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/mmap/";)
- (synopsis "File memory mapping for Common Lisp")
+ (synopsis "Common Lisp IEEE float portability library")
(description
- "This is a utility library providing access to the @emph{mmap} family of
-functions in a portable way. It allows you to directly map a file into the
-address space of your process without having to manually read it into memory
-sequentially. Typically this is much more efficient for files that are larger
-than a few Kb.")
- (license license:zlib))))
+ "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
+ `(#:tests? #f)))))
-(define-public cl-mmap
- (sbcl-package->cl-source-package sbcl-mmap))
+(define-public cl-float-features
+ (sbcl-package->cl-source-package sbcl-float-features))
-(define-public ecl-mmap
- (sbcl-package->ecl-package sbcl-mmap))
+(define-public ecl-float-features
+ (sbcl-package->ecl-package sbcl-float-features))
-(define-public sbcl-marray
- (let ((commit "0352f316b6830f0b119088ba9be836e4726bd7d8")
- (revision "0"))
+(define-public sbcl-flow
+ (let ((commit "6d925af009cdfe033650d7048197a5e6ee937d15")
+ (revision "1"))
(package
- (name "sbcl-marray")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-flow")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/death/marray";)
+ (url "https://github.com/Shinmera/flow";)
(commit commit)))
- (file-name (git-file-name "cl-marray" version))
+ (file-name (git-file-name "flow" version))
(sha256
- (base32 "0l4kvzpiw14vqhlsaflp3c7y51vznjjgbdi0q3axqk1wxvzy1zlx"))))
+ (base32 "0ysw1kwiqlf8kzllhnz8v3q40dmvwf83fzq8bfkbmwy5hfjh3pxp"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-dependencies
- (lambda _
- (substitute* "marray.asd"
- ((":components")
- ":depends-on (#+sbcl \"sb-posix\")\n :components")))))))
- (home-page "https://github.com/death/marray";)
- (synopsis "Memory-mapped files as Common Lisp arrays")
+ ;; FIXME: (Sharlatan-20210527T203118+0100): FLOW-VISUALIZER requires
+ ;; COMMONQT which is not packed yet and required tweaks with QT. Remove
+ ;; this when it's ready.
+ (inputs
+ `(("closer-mop" ,sbcl-closer-mop)
+ ("documentation-utils" ,sbcl-documentation-utils)))
+ (home-page "https://shinmera.github.io/flow/";)
+ (synopsis "Tools for the representation of graphs and flowcharts")
(description
- "MARRAY is a library which provides access to memory-mapped files
-through Common Lisp arrays.")
- (license license:expat))))
+ "FLOW is a flowchart graph library. Unlike other graphing libraries,
+this one focuses on nodes in a graph having distinct @code{ports} through which
+connections to other nodes are formed. This helps in many concrete scenarios
+where it is important to distinguish not only which nodes are connected, but
+also how they are connected to each other.
-(define-public cl-marray
- (sbcl-package->cl-source-package sbcl-marray))
+Particularly, a lot of data flow and exchange problems can be reduced to such
+a @code{flowchart}. For example, an audio processing library may present its
+pipeline as a flowchart of segments that communicate with each other through
+audio sample buffers. Flow gives a convenient view onto this kind of problem,
+and even allows the generic visualisation of graphs in this format.")
+ (license license:zlib))))
-;; ECL support not implemented yet.
-;; (define-public ecl-marray
-;; (sbcl-package->ecl-package sbcl-marray))
+(define-public cl-flow
+ (sbcl-package->cl-source-package sbcl-flow))
-(define-public sbcl-3bz
- (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad")
+(define-public ecl-flow
+ (sbcl-package->ecl-package sbcl-flow))
+
+(define-public sbcl-flute
+ (let ((commit "90ebcd6e82f637f49b6de7d625ccc51ec4c92900")
(revision "1"))
(package
- (name "sbcl-3bz")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-flute")
+ (version (git-version "0.2-dev" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/3bz";)
+ (url "https://github.com/ailisp/flute";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-flute" version))
(sha256
- (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4"))))
+ (base32 "0q8jhp040cvpppyn820mm6a550yfxyr1lar298x13c42mm807f4f"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cffi
- sbcl-mmap
- sbcl-nibbles
- sbcl-trivial-features))
- (home-page "https://github.com/3b/3bz";)
- (synopsis "Deflate decompression for Common Lisp")
+ (list sbcl-assoc-utils sbcl-let-over-lambda))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/ailisp/flute";)
+ (synopsis "HTML5 generation library in Common Lisp")
(description
- "3bz is an implementation of Deflate decompression (RFC 1951) optionally
-with zlib (RFC 1950) or gzip (RFC 1952) wrappers, with support for reading from
-foreign pointers (for use with mmap and similar, etc), and from CL octet
-vectors and streams.")
+ "Flute is an easily composable HTML5 generation library in Common
+Lisp.")
(license license:expat))))
-(define-public cl-3bz
- (sbcl-package->cl-source-package sbcl-3bz))
+(define-public cl-flute
+ (sbcl-package->cl-source-package sbcl-flute))
-(define-public ecl-3bz
- (sbcl-package->ecl-package sbcl-3bz))
+(define-public ecl-flute
+ (sbcl-package->ecl-package sbcl-flute))
-(define-public sbcl-zpb-exif
- (package
- (name "sbcl-zpb-exif")
- (version "1.2.5")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/xach/zpb-exif";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name "cl-zpb-exif" version))
- (sha256
- (base32 "0h1n36lfl8xn8rfyl5jxz9m8zlg0if2avmryas79f684yczrvdnd"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://xach.com/lisp/zpb-exif/";)
- (synopsis "EXIF information extractor for Common Lisp")
- (description
- "This is a Common Lisp library to extract EXIF information from image
-files.")
- (license license:bsd-2)))
+(define-public sbcl-fn
+ (let ((commit "8d8587d03a7b5e26b306fc90018e385d9e5acc2c")
+ (revision "1"))
+ (package
+ (name "sbcl-fn")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cbaggers/fn";)
+ (commit commit)))
+ (file-name (git-file-name "fn" version))
+ (sha256
+ (base32 "0yyp9z6iwx476whz0n1rpjznjyqqhlylhzwpgg5xx92lxmskl752"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-named-readtables))
+ (home-page "https://github.com/cbaggers/fn";)
+ (synopsis "Macros for lambda brevity")
+ (description
+ "This is a Common Lisp library providing lambda shorthand macros aiming
+to be used in cases where the word @emph{lambda} and the arguments are longer
+than the body of the lambda.")
+ (license license:public-domain))))
-(define-public cl-zpb-exif
- (sbcl-package->cl-source-package sbcl-zpb-exif))
+(define-public cl-fn
+ (sbcl-package->cl-source-package sbcl-fn))
-(define-public ecl-zpb-exif
- (sbcl-package->ecl-package sbcl-zpb-exif))
+(define-public ecl-fn
+ (sbcl-package->ecl-package sbcl-fn))
-(define-public sbcl-pngload
- (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f")
- (revision "2"))
+(define-public sbcl-fof
+ (let ((commit "522879e7da110ecf2e841998b197b34062c54b29")
+ (revision "1"))
(package
- (name "sbcl-pngload")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-fof")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.mfiano.net/mfiano/pngload.git";)
+ (url "https://gitlab.com/ambrevar/fof";)
(commit commit)))
- (file-name (git-file-name "pngload" version))
+ (file-name (git-file-name "cl-fof" version))
(sha256
- (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1"))))
+ (base32 "0ipy51q2fw03xk9rqcyzbq2b9c32npc1gl3c53rdjywpak7zwwg6"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("3bz" ,sbcl-3bz)
- ("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("mmap" ,sbcl-mmap)
- ("parse-float" ,sbcl-parse-float)
- ("static-vectors" ,sbcl-static-vectors)
- ("swap-bytes" ,sbcl-swap-bytes)
- ("zpb-exif" ,sbcl-zpb-exif)))
(arguments
- ;; Test suite disabled because of a dependency cycle.
- ;; pngload tests depend on opticl which depends on pngload.
- '(#:tests? #f))
- (home-page "https://git.mfiano.net/mfiano/pngload.git";)
- (synopsis "PNG image decoder for Common Lisp")
+ `(#:asd-systems '("fof" "fof/mf")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "ffprobe.lisp"
+ (("\\(defvar \\*ffprobe-command\\* \"ffprobe\"\\)")
+ (format #f "(defvar *ffprobe-command* \"~a/bin/ffprobe\")"
+ (assoc-ref inputs "ffmpeg")))))))))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cl-json
+ sbcl-cl-str
+ sbcl-hu.dwim.defclass-star
+ sbcl-local-time
+ sbcl-magicffi
+ sbcl-named-readtables
+ sbcl-osicat
+ sbcl-serapeum
+ sbcl-trivia
+ sbcl-trivial-package-local-nicknames
+ ;; Non-CL deps:
+ ffmpeg))
+ (home-page "https://gitlab.com/ambrevar/fof";)
+ (synopsis "File object finder library for Common Lisp")
(description
- "This is a Common Lisp library to load images in the PNG image format,
-both from files on disk, or streams in memory.")
- (license license:expat))))
+ "This library enable rapid file search, inspection and manipulation
+straight from the REPL.
+It aims at replacing Unix tools such as @code{find} or @code{du}.
+It also offers a replacement to the @code{pathname} Common Lisp API.
+Slot writers which commit changes to disk, e.g. permissions, modification
+time, etc.")
+ (license license:gpl3+))))
-(define-public cl-pngload
- (sbcl-package->cl-source-package sbcl-pngload))
+(define-public cl-fof
+ (sbcl-package->cl-source-package sbcl-fof))
-(define-public ecl-pngload
- (sbcl-package->ecl-package sbcl-pngload))
+(define-public ecl-fof
+ (sbcl-package->ecl-package sbcl-fof))
-(define-public sbcl-opticl
- (let ((commit "f6fc4dc5fa61ae3f2527b77e4bda99001ba37dcb")
+(define-public sbcl-font-discovery
+ (let ((commit "5101ca79151055f3ec9839aae73b8af42b884528")
(revision "1"))
(package
- (name "sbcl-opticl")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-font-discovery")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slyrus/opticl";)
+ (url "https://github.com/Shinmera/font-discovery";)
(commit commit)))
- (file-name (git-file-name "cl-opticl" version))
+ (file-name (git-file-name "font-discovery" version))
(sha256
- (base32 "1jx9n78d4lf53iz24yid34l92zrpqxfihv6049ixcy0xigf7j4ac"))))
+ (base32 "1p9wkwc23rnif8vcjaj5ih1fmr5g57sidqjlz08qw6k0z4f6bia1"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-alexandria
- sbcl-cl-jpeg
- sbcl-cl-tga
- sbcl-opticl-core
- sbcl-png-read
- sbcl-pngload
- sbcl-retrospectiff
- sbcl-skippy
- sbcl-zpng))
- (home-page "https://github.com/slyrus/opticl";)
- (synopsis "Image processing library for Common Lisp")
+ (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-indent))
+ (home-page "https://shinmera.github.io/font-discovery/";)
+ (synopsis "Find system font files matching a font spec")
(description
- "Opticl is a Common Lisp library for representing, processing, loading,
-and saving 2-dimensional pixel-based images.")
- (license license:bsd-2))))
+ "This is a library to find system font files. It works on systems with
+FontConfig on Linux, BSD. It does not have any foreign dependencies that
+aren't already directly available on the system.")
+ (license license:zlib))))
-(define-public cl-opticl
- (sbcl-package->cl-source-package sbcl-opticl))
+(define-public cl-font-discovery
+ (sbcl-package->cl-source-package sbcl-font-discovery))
-(define-public ecl-opticl
- (sbcl-package->ecl-package sbcl-opticl))
+(define-public ecl-font-discovery
+ (sbcl-package->ecl-package sbcl-font-discovery))
-(define-public sbcl-cl-dejavu
- (let ((commit "9d68ced4edee6f96fead42cb4835d0ff4a158373")
+(define-public sbcl-for
+ (let ((commit "a39782991292e44ee3b5e2e25cddaa8115f6d363")
(revision "1"))
(package
- (name "sbcl-cl-dejavu")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-for")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dkochmanski/cl-dejavu";)
+ (url "https://github.com/Shinmera/for";)
(commit commit)))
- (file-name (git-file-name "cl-dejavu" version))
+ (file-name (git-file-name "cl-for" version))
(sha256
- (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0"))))
+ (base32 "07jdwqkyb3qd65mng60cs723z7p0bv2769hhalz4c0mfzn8qrn99"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/dkochmanski/cl-dejavu";)
- (synopsis "DejaVu fonts for Common Lisp")
+ (inputs
+ (list sbcl-documentation-utils sbcl-form-fiddle sbcl-lambda-fiddle))
+ (home-page "https://shinmera.github.io/for/";)
+ (synopsis "Extensible iteration macro library")
(description
- "This is a repackage of the original DejaVu Fonts with some convenience
-functions.")
- (license (list license:cc0
- (license:x11-style "http://dejavu-fonts.org/";))))))
+ "For is a library for an extensible iteration macro. It allows you to
write
+concise looping constructs similar to @code{loop} and @code{iterate}. Unlike
+loop however it is extensible and sensible, and unlike iterate it does not
+require code-walking and is easier to extend.")
+ (license license:zlib))))
-(define-public cl-dejavu
- (sbcl-package->cl-source-package sbcl-cl-dejavu))
+(define-public cl-for
+ (sbcl-package->cl-source-package sbcl-for))
-(define-public ecl-dejavu
- (sbcl-package->ecl-package sbcl-cl-dejavu))
+(define-public ecl-for
+ (sbcl-package->ecl-package sbcl-for))
-(define-public sbcl-mcclim
- (package
- (name "sbcl-mcclim")
- (version "0.9.8")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://codeberg.org/McCLIM/McCLIM";)
- (commit (string-append version "-yule"))))
- (file-name (git-file-name "cl-mcclim" version))
- (sha256
- (base32 "0gbi61jnnsz6fvhv18mf57jkq46bvcd0355vqdcnrni7xyi10sk8"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam pkg-config))
- (inputs
- (list fontconfig
- freetype
- harfbuzz
- sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-cl-base64
- sbcl-cl-dejavu
- sbcl-cl-freetype2
- sbcl-cl-pdf
- sbcl-cl-unicode
- sbcl-cl-vectors
- sbcl-cl-who
- sbcl-closer-mop
- sbcl-cluffer
- sbcl-clx
- sbcl-flexi-streams
- sbcl-flexichain
- sbcl-log4cl
- sbcl-lorem-ipsum
- sbcl-opticl
- sbcl-slime-swank
- sbcl-spatial-trees
- sbcl-trivial-features
- sbcl-trivial-garbage
- sbcl-trivial-gray-streams
- sbcl-zpb-ttf))
- (arguments
- '(#:asd-systems '("mcclim"
- "clim-examples"
- ;; clim-debugger is required by cleavir.
- "clim-debugger")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "Extensions/fontconfig/src/functions.lisp"
- (("libfontconfig\\.so")
- (search-input-file inputs "/lib/libfontconfig.so")))
- (substitute* "Extensions/harfbuzz/src/functions.lisp"
- (("libharfbuzz\\.so")
- (search-input-file inputs "/lib/libharfbuzz.so"))))))))
- (home-page "https://mcclim.common-lisp.dev/";)
- (synopsis "Common Lisp GUI toolkit")
- (description
- "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
-specification}, a toolkit for writing GUIs in Common Lisp.")
- (license license:lgpl2.1+)))
-
-(define-public cl-mcclim
- (sbcl-package->cl-source-package sbcl-mcclim))
-
-(define-public ecl-mcclim
- (let ((pkg (sbcl-package->ecl-package sbcl-mcclim)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; Tests fail with "FUNCTION: Not a valid argument (R1
- ;; (GENERATE-REGION))." on ECL.
- ((#:tests? _ #f) #f))))))
-
-(define-public sbcl-cl-inflector
- (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
+(define-public sbcl-forge
+ (let ((commit "012324e251d91436f4a610e2fe2eb50674c3c3ce")
(revision "1"))
(package
- (name "sbcl-cl-inflector")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-forge")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/cl-inflector";)
+ (url "https://github.com/Shinmera/forge/";)
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
+ (base32 "006vi2ihrn28pzrwa8b7axmv98bdaxzx7lacnh9pbacbjg3b7hb0"))
+ (file-name (git-file-name "forge" version))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit2))
+ (arguments
+ '(#:asd-systems '("forge-support"
+ "forge-communication"
+ "forge")))
(inputs
- (list sbcl-alexandria sbcl-cl-ppcre))
- (home-page "https://github.com/AccelerationNet/cl-inflector";)
- (synopsis "Library to pluralize/singularize English and Portuguese
words")
- (description
- "This is a common lisp library to easily pluralize and singularize
-English and Portuguese words. This is a port of the ruby ActiveSupport
-Inflector module.")
- (license license:expat))))
-
-(define-public cl-inflector
- (sbcl-package->cl-source-package sbcl-cl-inflector))
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-cl-ppcre
+ sbcl-closer-mop
+ sbcl-documentation-utils
+ sbcl-ironclad
+ sbcl-pathname-utils
+ sbcl-promise
+ sbcl-usocket
+ sbcl-verbose))
+ (synopsis "General, modular build system")
+ (description "Forge is a generic build system. Refer to documentation
+for the specific kind of project you're building to get the full picture.")
+ (home-page "https://github.com/shinmera/forge";)
+ (license license:zlib))))
-(define-public ecl-cl-inflector
- (sbcl-package->ecl-package sbcl-cl-inflector))
+(define-public cl-forge
+ (sbcl-package->cl-source-package sbcl-forge))
-(define-public sbcl-ixf
- (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183")
- (revision "1"))
+(define-public sbcl-form-fiddle
+ (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
+ (revision "0"))
(package
- (name "sbcl-ixf")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-form-fiddle")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/dimitri/cl-ixf";)
- (commit commit)))
- (file-name (git-file-name "cl-ixf" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/form-fiddle";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa"))))
+ (base32
+ "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cl-ppcre
- sbcl-ieee-floats
- sbcl-local-time
- sbcl-md5
- sbcl-split-sequence))
- (home-page "https://github.com/dimitri/cl-ixf";)
- (synopsis "Parse IBM IXF file format")
+ (list sbcl-documentation-utils))
+ (synopsis "Utilities to destructure Common Lisp lambda forms")
(description
- "This is a Common Lisp library to handle the IBM PC version of the IXF
-(Integration Exchange Format) file format.")
- (license license:public-domain))))
+ "Often times we need to destructure a form definition in a Common Lisp
+macro. This library provides a set of simple utilities to help with that.")
+ (home-page "https://shinmera.github.io/form-fiddle/";)
+ (license license:zlib))))
-(define-public ecl-ixf
- (sbcl-package->ecl-package sbcl-ixf))
+(define-public cl-form-fiddle
+ (sbcl-package->cl-source-package sbcl-form-fiddle))
-(define-public cl-ixf
- (sbcl-package->cl-source-package sbcl-ixf))
+(define-public ecl-form-fiddle
+ (sbcl-package->ecl-package sbcl-form-fiddle))
-(define-public sbcl-qbase64
- (package
- (name "sbcl-qbase64")
- (version "0.3.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/chaitanyagupta/qbase64";)
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-metabang-bind sbcl-trivial-gray-streams))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/chaitanyagupta/qbase64";)
- (synopsis "Base64 encoder and decoder for Common Lisp")
- (description "@code{qbase64} provides a fast and flexible base64 encoder
-and decoder for Common Lisp.")
- (license license:bsd-3)))
+(define-public sbcl-format-colors
+ (let ((commit "fecb1d8c6e7a07ff9f10a7a4eb4c3bd629d4969f")
+ (revision "0"))
+ (package
+ (name "sbcl-format-colors")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/vindarel/format-colors";)
+ (commit commit)))
+ (sha256
+ (base32 "084ydjhic2dq0gb7wfm6plnjq3l7485hb3yhxl03mm64a6sr3fxv"))
+ (file-name (git-file-name "cl-format-colors" version))))
+ (build-system asdf-build-system/sbcl)
+ (inputs (list sbcl-cl-ansi-text))
+ (synopsis "Custom format functions for colorful output")
+ (description "This package provides simple format directives to
+ print in colors.")
+ (home-page "https://github.com/vindarel/format-colors";)
+ (license license:llgpl))))
-(define-public cl-qbase64
- (sbcl-package->cl-source-package sbcl-qbase64))
+(define-public cl-format-colors
+ (sbcl-package->cl-source-package sbcl-format-colors))
-(define-public ecl-qbase64
- (sbcl-package->ecl-package sbcl-qbase64))
+(define-public ecl-format-colors
+ (sbcl-package->ecl-package sbcl-format-colors))
-(define-public sbcl-lw-compat
- ;; No release since 2013.
- (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d"))
+(define-public sbcl-formgrep
+ (let ((commit "91238cdbdd0ad815ff5d574d032b4a502febd190")
+ (revision "0"))
(package
- (name "sbcl-lw-compat")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-formgrep")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pcostanza/lw-compat/";)
+ (url "https://github.com/death/formgrep";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-formgrep" version))
(sha256
- (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav"))))
+ (base32 "1rqzkmz6nddg5ywvs3v0k8cvxdwas38mfwgbr3rs4fdsbps90k9r"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pcostanza/lw-compat/";)
- (synopsis "LispWorks utilities ported to other Common Lisp
implementations")
- (description "This package contains a few utility functions from the
-LispWorks library that are used in software such as ContextL.")
+ (inputs
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cl-fad
+ sbcl-cl-ppcre
+ sbcl-eclector))
+ (home-page "https://github.com/death/formgrep";)
+ (synopsis "Find top-level Lisp forms matching an operator pattern")
+ (description
+ "This library provides the @code{FORMGREP} function and related
+utilities which find top-level Lisp forms matching the regular expression
+corresponding to an operator name, returning the matched forms and the names
+of the files and the line numbers where they were found.")
(license license:expat))))
-(define-public cl-lw-compat
- (sbcl-package->cl-source-package sbcl-lw-compat))
+(define-public cl-formgrep
+ (sbcl-package->cl-source-package sbcl-formgrep))
-(define-public ecl-lw-compat
- (sbcl-package->ecl-package sbcl-lw-compat))
+(define-public ecl-formgrep
+ (sbcl-package->ecl-package sbcl-formgrep))
-(define-public sbcl-contextl
- ;; No release since 2013.
- (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb")
- (revision "2"))
+(define-public sbcl-fset
+ (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
+ (revision "1"))
(package
- (name "sbcl-contextl")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-fset")
+ (version (git-version "1.3.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pcostanza/contextl/";)
+ (url "https://github.com/slburson/fset";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0"))))
+ (base32
+ "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
+ (snippet '(begin
+ ;; Remove obsolete copy of system definition.
+ (delete-file "Code/fset.asd")
+ #t))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-closer-mop sbcl-lw-compat))
- (home-page "https://github.com/pcostanza/contextl";)
- (synopsis "Context-oriented programming for Common Lisp")
- (description "ContextL is a CLOS extension for Context-Oriented
-Programming (COP).
+ (list sbcl-misc-extensions sbcl-mt19937 sbcl-named-readtables))
+ (synopsis "Functional set-theoretic collections library")
+ (description
+ "FSet is a functional set-theoretic collections library for Common Lisp.
+Functional means that all update operations return a new collection rather than
+modifying an existing one in place. Set-theoretic means that collections may
+be nested arbitrarily with no additional programmer effort; for instance, sets
+may contain sets, maps may be keyed by sets, etc.")
+ (home-page "https://common-lisp.net/project/fset/Site/index.html";)
+ (license license:llgpl))))
-Find overview of ContextL's features in an overview paper:
-@url{http://www.p-cos.net/documents/contextl-soa.pdf}. See also this general
-overview article about COP which also contains some ContextL examples:
-@url{http://www.jot.fm/issues/issue_2008_03/article4/}.";)
- (license license:expat))))
+(define-public cl-fset
+ (sbcl-package->cl-source-package sbcl-fset))
-(define-public cl-contextl
- (sbcl-package->cl-source-package sbcl-contextl))
+(define-public ecl-fset
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-fset))
+ (arguments
+ ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined".
+ '(#:tests? #f))))
-(define-public ecl-contextl
- (sbcl-package->ecl-package sbcl-contextl))
+(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";)
+ (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
+ `(#:tests? #f))))
-(define-public sbcl-hu.dwim.common-lisp
- (let ((commit "90558195773383142a57a16687d5e7f4adea6418"))
+(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-funds
+ (let ((commit "39d425818876b898c20780a678803df506df8424")
+ (revision "2"))
(package
- (name "sbcl-hu.dwim.common-lisp")
- (version "2021-01-27")
+ (name "sbcl-funds")
+ (version (git-version "1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.common-lisp/";)
+ (url "https://github.com/charJe/funds";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk"))))
+ (base32 "13y1jhvnpzrs9daz6f3z67w6h2y21ggb10j3j4vnc5p3m8i7ps4p"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.asdf))
- (home-page "http://dwim.hu/project/hu.dwim.common-lisp";)
- (synopsis "Redefine some standard Common Lisp names")
- (description "This library is a redefinition of the standard Common Lisp
-package that includes a number of renames and shadows.")
- (license license:public-domain))))
-
-(define-public cl-hu.dwim.common-lisp
- (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
-
-(define-public ecl-hu.dwim.common-lisp
- (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp))
-
-(define-public sbcl-hu.dwim.common
- (package
- (name "sbcl-hu.dwim.common")
- (version "2015-07-09")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "http://beta.quicklisp.org/archive/hu.dwim.common/";
- version "/hu.dwim.common-"
- (string-replace-substring version "-" "")
- "-darcs.tgz"))
- (sha256
- (base32 "12l1rr6w9m99w0b5gc6hv58ainjfhbc588kz6vwshn4gqsxyzbhp"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.asdf))
- (inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-closer-mop
- sbcl-hu.dwim.common-lisp
- sbcl-iterate
- sbcl-metabang-bind))
- (home-page "https://dwim.hu/";)
- (synopsis "Common Lisp library shared by other hu.dwim systems")
- (description "This package contains a support library for other
-hu.dwim systems.")
- (license license:public-domain)))
+ (synopsis "Purely functional data structure library in Common Lisp")
+ (description
+ "Funds provides portable, purely functional data structures in Common
+Lisp. It includes tree based implementations for Array, Hash, Queue, Stack,
and
+Heap.")
+ (home-page "https://common-lisp.net/project/funds/";)
+ (license license:asl2.0))))
-(define-public cl-hu.dwim.common
- (sbcl-package->cl-source-package sbcl-hu.dwim.common))
+(define-public cl-funds
+ (sbcl-package->cl-source-package sbcl-funds))
-(define-public ecl-hu.dwim.common
- (sbcl-package->ecl-package sbcl-hu.dwim.common))
+(define-public ecl-funds
+ (sbcl-package->ecl-package sbcl-funds))
-(define-public sbcl-hu.dwim.defclass-star
- (let ((commit "3086878a485074f9b2913c58267a9b764cd632fd"))
+(define-public sbcl-fxml
+ ;; No release.
+ (let ((commit "a0e73bb48ef03adea94a55986cc27f522074c8e1"))
(package
- (name "sbcl-hu.dwim.defclass-star")
- ;; We used to set version from the date when it was a darcs repo, so we
- ;; keep the year so that package gets updated on previous installs.
- (version (git-version "2021" "2" commit))
+ (name "sbcl-fxml")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.defclass-star";)
+ (url "https://github.com/ruricolist/fxml/";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "19ipds9r71qymfdp4izg0l7zmvinp06adr8rdalhaq7v7mzpg83z"))))
+ (base32 "1vxdb1cjjqi986f72bggnw1s4yzv12g4li7vn4y49b6lphshr8lm"))))
(build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-babel
+ sbcl-named-readtables
+ sbcl-serapeum
+ sbcl-quri
+ sbcl-flexi-streams
+ sbcl-split-sequence
+ sbcl-alexandria
+ sbcl-trivial-gray-streams))
(native-inputs
- (list ;; These 2 inputs are only needed tests which are disabled, see
below.
- ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
- ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank
system.
- ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
- sbcl-hu.dwim.asdf))
- (arguments
- `(;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
- ;; -> hu.dwim.util -> hu.dwim.defclass-star.
- #:tests? #f))
- (home-page "https://github.com/hu-dwim/hu.dwim.defclass-star";)
- (synopsis "Simplify definitions with defclass* and friends in Common
Lisp")
- (description "@code{defclass-star} provides defclass* and defcondition*
to
-simplify class and condition declarations. Features include:
+ (list sbcl-fiveam sbcl-cxml sbcl-cxml-rng sbcl-xpath))
+ (home-page "https://github.com/ruricolist/fxml";)
+ (synopsis "XML parser and serializer in Common Lisp")
+ (description
+ "FXML is a secure-by-default, error-recovering XML parser and
serializer.
+It is a fork of CXML.
+You should use FXML instead of CXML if:
@itemize
-@item Automatically export all or select slots at compile time.
-@item Define the @code{:initarg} and @code{:accessor} automatically.
-@item Specify a name transformer for both the @code{:initarg} and
-@code{:accessor}, etc.
-@item Specify the @code{:initform} as second slot value.
+@item You are parsing potentially ill-formed XML.
+@item You are parsing potentially malicious XML.
+@item You need to use Klacks with namespaces.
@end itemize
-See
-@url{https://common-lisp.net/project/defclass-star/configuration.lisp.html}
-for an example.")
- (license license:public-domain))))
-
-(define-public cl-hu.dwim.defclass-star
- (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
+FXML’s API is very close to CXML's, and for the most part you can refer to the
+CXML documentation for usage.")
+ (license license:llgpl))))
-(define-public ecl-hu.dwim.defclass-star
- (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star))
+(define-public cl-fxml
+ (sbcl-package->cl-source-package sbcl-fxml))
-(define-public sbcl-livesupport
- (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a")
- (revision "1"))
+(define-public sbcl-garbage-pools
+ (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790")
+ (revision "1"))
(package
- (name "sbcl-livesupport")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-garbage-pools")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cbaggers/livesupport";)
+ (url "https://github.com/archimag/garbage-pools";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg"))))
+ (base32 "04jqwr6j138him6wc4nrwjzm4lvyj5j31xqab02nkf8h9hmsf5v1"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/cbaggers/livesupport";)
- (synopsis "Some helpers that make livecoding a little easier")
- (description "This package provides a macro commonly used in livecoding
to
-enable continuing when errors are raised. Simply wrap around a chunk of code
-and it provides a restart called @code{continue} which ignores the error and
-carrys on from the end of the body.")
- (license license:bsd-2))))
+ (home-page "https://github.com/archimag/garbage-pools";)
+ (synopsis "Resource management pools for Common Lisp")
+ (description "GARBAGE-POOLS is Common Lisp re-implementation of the APR
+Pools for resource management.")
+ (license license:expat))))
-(define-public cl-livesupport
- (sbcl-package->cl-source-package sbcl-livesupport))
+(define-public cl-garbage-pools
+ (sbcl-package->cl-source-package sbcl-garbage-pools))
-(define-public ecl-livesupport
- (sbcl-package->ecl-package sbcl-livesupport))
+(define-public ecl-garbage-pools
+ (sbcl-package->ecl-package sbcl-garbage-pools))
-(define-public sbcl-envy
- (let ((commit "26a7faadc981f2a047daa36f715a44faec5dd00c")
- (revision "2"))
+(define-public sbcl-geco
+ (let ((commit "db13c9384491092975f46f6a837ccdc04681a93a")
+ (revision "1"))
(package
- (name "sbcl-envy")
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/fukamachi/envy";)
+ (name "sbcl-geco")
+ (version (git-version "2.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/envy";)
+ (url "https://github.com/gpwwjr/GECO";)
(commit commit)))
- (file-name (git-file-name "cl-envy" version))
+ (file-name (git-file-name "cl-geco" version))
(sha256
- (base32 "1r0wgimd7z57x8cv69sw76w3y5l70hq50882a9nq5l4v64lg55fq"))))
+ (base32 "1ncaf9ab7jz59zmga0p97blsjjb1m6db0qih57wipfhqdb5ylz17"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-osicat sbcl-prove))
- (arguments
- `(#:asd-systems '("envy-test" "envy")
- ;; FIXME: Tests fail with
- ;; Component ENVY-ASD::ENVY-TEST not found, required by #<SYSTEM
"envy">
- ;; https://github.com/fukamachi/envy/issues/10
- #:tests? #f))
- (synopsis "Common Lisp configuration switcher inspired by Perl's
Config::ENV")
- (description "Envy is a configuration manager for various applications.
-Envy uses an environment variable to determine a configuration to use. This
-can separate configuration system from an implementation.")
- (license license:bsd-2))))
-
-(define-public cl-envy
- (sbcl-package->cl-source-package sbcl-envy))
+ (home-page "https://github.com/gpwwjr/GECO";)
+ (synopsis "Genetic algorithm toolkit for Common Lisp")
+ (description
+ "GECO (Genetic Evolution through Combination of Objects) is an
+extensible, object-oriented framework for prototyping genetic algorithms in
+Common Lisp.")
+ (license license:lgpl2.0+))))
-(define-public ecl-envy
- (sbcl-package->ecl-package sbcl-envy))
+(define-public cl-geco
+ (sbcl-package->cl-source-package sbcl-geco))
-(define-public sbcl-mito
- (let ((commit "47ba4865ca4bb2894b53703a49a299e973f8eb86")
- (revision "3"))
- (package
- (name "sbcl-mito")
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/fukamachi/mito";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name "mito" version))
- (sha256
- (base32 "0313nxlj1zqw6zyc23xpf85v0jk32sg0543ql8363jki0pmg7yhs"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-package-locks" ,sbcl-cl-package-locks)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("cl-reexport" ,sbcl-cl-reexport)
- ("closer-mop" ,sbcl-closer-mop)
- ("dbi" ,sbcl-dbi)
- ("dissect" ,sbcl-dissect)
- ("esrap" ,sbcl-esrap)
- ("local-time" ,sbcl-local-time)
- ("sxql" ,sbcl-sxql)
- ("trivia" ,sbcl-trivia)
- ("uuid" ,sbcl-uuid)))
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'remove-non-functional-tests
- (lambda _
- (substitute* "mito-test.asd"
- (("\\(:test-file \"db/mysql\"\\)") "")
- (("\\(:test-file \"db/postgres\"\\)") "")
- (("\\(:test-file \"dao\"\\)") "")
- ;; TODO: migration/sqlite3 should work, re-enable once
- ;; upstream has fixed it:
- ;; https://github.com/fukamachi/mito/issues/70
- (("\\(:test-file \"migration/sqlite3\"\\)") "")
- (("\\(:test-file \"migration/mysql\"\\)") "")
- (("\\(:test-file \"migration/postgres\"\\)") "")
- (("\\(:test-file \"postgres-types\"\\)") "")
- (("\\(:test-file \"mixin\"\\)") ""))
- #t)))
- #:asd-systems '("mito-test" "mito")))
- (synopsis "ORM for Common Lisp with migrations and relationships
support")
- (description "Mito is yet another object relational mapper, and it aims
-to be a successor of Integral.
+(define-public ecl-geco
+ (sbcl-package->ecl-package sbcl-geco))
-@itemize
-@item Support MySQL, PostgreSQL and SQLite3.
-@item Add id (serial/uuid primary key), created_at and updated_at by default
-like Ruby's ActiveRecord.
-@item Migrations.
-@item Database schema versioning.
-@end itemize\n")
- (license license:llgpl))))
+(define-public sbcl-generic-cl
+ (package
+ (name "sbcl-generic-cl")
+ (version "0.9")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/generic-cl";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1c40vqb49g0adfv17jxgk0ds1n6a2dph30cibq01sicmqdgrrbi8"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; Tests fail because SBCL head size is not high enough.
+ ;; https://github.com/alex-gutev/generic-cl/issues/6
+ `(#:tests? #f))
+ (inputs
+ (list sbcl-agutil
+ sbcl-alexandria
+ sbcl-anaphora
+ sbcl-arrows
+ sbcl-cl-form-types
+ sbcl-custom-hash-table
+ sbcl-static-dispatch
+ sbcl-trivia))
+ (native-inputs
+ (list sbcl-prove))
+ (home-page "https://alex-gutev.github.io/generic-cl/";)
+ (synopsis "Generic function interface to standard Common Lisp functions")
+ (description "@code{generic-cl} provides a generic function wrapper over
+various functions in the Common Lisp standard, such as equality predicates and
+sequence operations. The goal of this wrapper is to provide a standard
+interface to common operations, such as testing for the equality of two
+objects, which is extensible to user-defined types.")
+ (license license:expat)))
-(define-public cl-mito
- (sbcl-package->cl-source-package sbcl-mito))
+(define-public cl-generic-cl
+ (sbcl-package->cl-source-package sbcl-generic-cl))
-(define-public ecl-mito
- (sbcl-package->ecl-package sbcl-mito))
+(define-public ecl-generic-cl
+ (sbcl-package->ecl-package sbcl-generic-cl))
-(define-public sbcl-kebab
- (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b")
+(define-public sbcl-generic-comparability
+ (let ((commit "53fc2846319a6eb46b36581e203e1f1542a8acff")
(revision "1"))
(package
- (name "sbcl-kebab")
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/pocket7878/kebab";)
+ (name "sbcl-generic-comparability")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/pnathan/generic-comparability";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "generic-comparability" version))
(sha256
- (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b"))))
+ (base32 "01ma0cwirxarwwmdwflnh8kmysmr2smh5kyvzhb2074ljxg8yq2p"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("alexandria" ,sbcl-alexandria)
- ("cl-interpol" ,sbcl-cl-interpol)
- ("split-sequence" ,sbcl-split-sequence)))
+ (list sbcl-alexandria))
(native-inputs
- (list sbcl-prove))
- (arguments
- ;; Tests passes but the phase fails with
- ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #<SYSTEM
"kebab">.
- `(#:tests? #f))
- (synopsis "Common Lisp case converter")
- (description "This Common Lisp library converts strings, symbols and
-keywords between any of the following typographical cases: PascalCase,
-camelCase, snake_case, kebab-case (lisp-case).")
+ (list sbcl-fiveam))
+ (home-page "https://github.com/pnathan/generic-comparability";)
+ (synopsis "Implementation of cdr-8")
+ (description
+ "GENERIC-COMPARABILITY is an implementation of CDR-8 (Generic Equality
+and Comparison for Common Lisp). CDR-8 provides an interface for the EQUALS
+function, which is defined as a general equality predicate, as well as a set of
+ordering (COMPARE) functions for comparison. The semantics are described in
+the CDR-8 standard.")
(license license:llgpl))))
-(define-public cl-kebab
- (sbcl-package->cl-source-package sbcl-kebab))
+(define-public cl-generic-comparability
+ (sbcl-package->cl-source-package sbcl-generic-comparability))
-(define-public ecl-kebab
- (sbcl-package->ecl-package sbcl-kebab))
+(define-public ecl-generic-comparability
+ (sbcl-package->ecl-package sbcl-generic-comparability))
-(define-public sbcl-datafly
- (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d")
+(define-public sbcl-genhash
+ (let ((commit "220ae1af8361dbd2005177f2ee11072b6a33934f")
(revision "1"))
(package
- (name "sbcl-datafly")
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/fukamachi/datafly";)
+ (name "sbcl-genhash")
+ (version (git-version "1.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/pnathan/genhash";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-genhash" version))
(sha256
- (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv"))))
+ (base32 "1jnk1fix1zydhy0kn3cvlp6dy0241x7v8ahq001nlr6v152z1cwk"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("iterate" ,sbcl-iterate)
- ("optima" ,sbcl-optima)
- ("trivial-types" ,sbcl-trivial-types)
- ("closer-mop" ,sbcl-closer-mop)
- ("cl-syntax" ,sbcl-cl-syntax)
- ("sxql" ,sbcl-sxql)
- ("dbi" ,sbcl-dbi)
- ("babel" ,sbcl-babel)
- ("local-time" ,sbcl-local-time)
- ("function-cache" ,sbcl-function-cache)
- ("jonathan" ,sbcl-jonathan)
- ("kebab" ,sbcl-kebab)
- ("log4cl" ,sbcl-log4cl)))
- (native-inputs
- (list sbcl-prove))
- (arguments
- ;; TODO: Tests fail with
- ;; While evaluating the form starting at line 22, column 0
- ;; of
#P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp":
- ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main
thread" RUNNING
- ;; {10009F8083}>:
- ;; Error when binding parameter 1 to value NIL.
- ;; Code RANGE: column index out of range.
- `(#:tests? #f))
- (synopsis "Lightweight database library for Common Lisp")
- (description "Datafly is a lightweight database library for Common
Lisp.")
- (license license:bsd-3))))
+ (home-page "https://github.com/pnathan/genhash";)
+ (synopsis "Generic hash tables for Common Lisp")
+ (description
+ "This an implementation of CDR 2: generic hash tables for Common Lisp")
+ (license license:public-domain))))
-(define-public cl-datafly
- (sbcl-package->cl-source-package sbcl-datafly))
+(define-public cl-genhash
+ (sbcl-package->cl-source-package sbcl-genhash))
-(define-public ecl-datafly
- (sbcl-package->ecl-package sbcl-datafly))
+(define-public ecl-genhash
+ (sbcl-package->ecl-package sbcl-genhash))
-(define-public sbcl-do-urlencode
- (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a")
- (revision "1"))
+(define-public sbcl-germinal
+ (let ((commit "5bfb371ea57dae8985c0e1c6f184f0338487d684")
+ (revision "0"))
(package
- (name "sbcl-do-urlencode")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/drdo/do-urlencode";)
+ (name "sbcl-germinal")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://git.carcosa.net/jmcbray/germinal";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-germinal" version))
(sha256
- (base32 "0k2i3d4k9cpci235mwfm0c5a4yqfkijr716bjv7cdlpzx88lazm9"))))
+ (base32 "12jypa8m10825lp5yxfcm1fyk3r4ziwcri7ndxa0m5dz0y7hggck"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-babel))
- (synopsis "Percent Encoding (aka URL Encoding) Common Lisp library")
- (description "This library provides trivial percent encoding and
-decoding functions for URLs.")
- (license license:isc))))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cl+ssl
+ sbcl-cl-fad
+ sbcl-cl-interpol
+ sbcl-cl-ppcre
+ sbcl-cl-str
+ sbcl-local-time
+ sbcl-osicat
+ sbcl-ppath
+ sbcl-quri
+ sbcl-trivial-mimes
+ sbcl-uax-15
+ sbcl-usocket))
+ (home-page "https://git.carcosa.net/jmcbray/germinal";)
+ (synopsis "Gemini protocol server")
+ (description "Germinal is a server for the Gemini protocol, written in
+Common Lisp.")
+ (license license:agpl3))))
-(define-public cl-do-urlencode
- (sbcl-package->cl-source-package sbcl-do-urlencode))
+(define-public cl-germinal
+ (sbcl-package->cl-source-package sbcl-germinal))
-(define-public ecl-do-urlencode
- (sbcl-package->ecl-package sbcl-do-urlencode))
+(define-public ecl-germinal
+ (sbcl-package->ecl-package sbcl-germinal))
-(define-public sbcl-cl-emb
- (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840")
+(define-public sbcl-gettext
+ (let ((commit "a432020cbad99fc22cbe6bb9aa8a83a35000d7aa")
(revision "1"))
(package
- (name "sbcl-cl-emb")
- (version (git-version "0.4.3" revision commit))
- (home-page "https://common-lisp.net/project/cl-emb/";)
+ (name "sbcl-gettext")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/38a938c2/cl-emb";)
+ (url "https://github.com/rotatef/gettext";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "gettext" version))
(sha256
- (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk"))))
+ (base32 "1pzhamgni6k5hi6bbvlb3dm659pcllrrr3vhhn3rpjn238zxg5ar"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-stefil))
(inputs
- (list sbcl-cl-ppcre))
- (synopsis "Templating system for Common Lisp")
- (description "A mixture of features from eRuby and HTML::Template. You
-could name it \"Yet Another LSP\" (LispServer Pages) but it's a bit more than
-that and not limited to a certain server or text format.")
- (license license:llgpl))))
+ (list sbcl-flexi-streams sbcl-split-sequence sbcl-cl-yacc))
+ (home-page "https://github.com/rotatef/gettext";)
+ (synopsis "Common Lisp implementation of Gettext")
+ (description
+ "This package provides GNU @code{gettext} completely implemented in
+Common Lisp without any C library bindings.")
+ (license license:lgpl3+))))
-(define-public cl-emb
- (sbcl-package->cl-source-package sbcl-cl-emb))
+(define-public cl-gettext
+ (sbcl-package->cl-source-package sbcl-gettext))
-(define-public ecl-cl-emb
- (sbcl-package->ecl-package sbcl-cl-emb))
+(define-public ecl-gettext
+ (sbcl-package->ecl-package sbcl-gettext))
-(define-public sbcl-cl-project
- (let ((commit "151107014e534fc4666222d57fec2cc8549c8814")
- (revision "1"))
+(define-public sbcl-glkit
+ (let ((commit "0d8e7c5fed4231f2177afcf0f3ff66f196ed6a46"))
(package
- (name "sbcl-cl-project")
- (version (git-version "0.3.1" revision commit))
- (home-page "https://github.com/fukamachi/cl-project";)
+ (name "sbcl-glkit")
+ (version (git-version "0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/lispgames/glkit/";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-glkit" version))
(sha256
- (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y"))))
+ (base32 "1x3y5jcr1f0v9sgn3y5b7b8fhgd6vv37nz73016gdwh511idi8jn"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("cl-emb" ,sbcl-cl-emb)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)
- ("prove" ,sbcl-prove)))
- (arguments
- ;; Tests depend on caveman, which in turns depends on cl-project.
- '(#:tests? #f))
- (synopsis "Generate a skeleton for modern Common Lisp projects")
- (description "This library provides a modern project skeleton generator.
-In contract with other generators, CL-Project generates one package per file
-and encourages unit testing by generating a system for unit testing, so you
-can begin writing unit tests as soon as the project is generated.")
- (license license:llgpl))))
+ (list sbcl-alexandria
+ sbcl-cl-opengl
+ sbcl-defpackage-plus
+ sbcl-mathkit
+ sbcl-sb-cga
+ sbcl-sdl2
+ sbcl-static-vectors))
+ (home-page "https://github.com/lispgames/glkit/";)
+ (synopsis "OpenGL utilities for math, shaders, and more")
+ (description
+ "This is a utility kit for functionality related to OpenGL. It
provides the following:
-(define-public cl-project
- (sbcl-package->cl-source-package sbcl-cl-project))
+@itemize
+@item @code{kit.glm}: This re-exports @code{sb-cga} and @code{mathkit} for
+convenience.
+@item @code{kit.gl.shader}: This provides shader dictionary and compilation
+functionality similar to what was originally found in @code{sdl2kit}.
+@item @code{kit.gl.vao}: This provides an interface for Vertex Array Objects.
+@end itemize\n")
+ (license license:expat))))
-(define-public ecl-cl-project
- (sbcl-package->ecl-package sbcl-cl-project))
+(define-public cl-glkit
+ (sbcl-package->cl-source-package sbcl-glkit))
-(define-public sbcl-caveman
- (let ((commit "35cd8bc6c322f9d88498405fc26168a1fb42ae1c") ; No release since
2012
- (revision "2"))
+(define-public ecl-glkit
+ (sbcl-package->ecl-package sbcl-glkit))
+
+(define-public sbcl-global-vars
+ (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
+ (revision "0"))
(package
- (name "sbcl-caveman")
- (version (git-version "2.4.0" revision commit))
- (home-page "https://8arrow.org/caveman/";)
+ (name "sbcl-global-vars")
+ (version (git-version "1.0.0" revision commit))
+ (home-page "https://github.com/lmj/global-vars";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/caveman/";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-caveman" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1wvjm9m1fnapg0r9imhhcwgnhhqkkccnj3c0iw9yg1f72d7zhm2w"))))
+ (base32
+ "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("ningle" ,cl-ningle)
- ("lack" ,sbcl-lack)
- ("cl-project" ,sbcl-cl-project)
- ("dbi" ,sbcl-dbi)
- ("sxql" ,sbcl-sxql)
- ("cl-syntax" ,sbcl-cl-syntax)
- ("myway" ,sbcl-myway)
- ("quri" ,sbcl-quri)))
- (native-inputs
- `(("usocket" ,sbcl-usocket)
- ("dexador" ,sbcl-dexador)
- ("lack" ,sbcl-lack)
- ("trivial-types" ,sbcl-trivial-types)
- ("prove" ,sbcl-prove)))
- (arguments
- `(#:asd-systems '("caveman2"
- "caveman2-db"
- "caveman2-test"
- "caveman-middleware-dbimanager")
- ;; TODO: Tests fail with:
- ;; writing
/gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
- ;; While evaluating the form starting at line 38, column 0
- ;; of
#P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
- ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread
#<SB-THREAD:THREAD "main thread" RUNNING
- ;;
{10009F8083}>:
- ;; Component "myapp573" not found
- ;;
- ;; The above myapp573 component name is randomly generated by
- ;; gensym on each test run. `(asdf:load-system *app-name*)` tries
- ;; to load this component and fails.
- ;; TODO: Ask fukamachi how to go around this.
- #:tests? #f))
- (synopsis "Lightweight web application framework in Common Lisp")
- (description "Caveman is intended to be a collection of common parts for
-web applications. Caveman2 has three design goals:
+ (synopsis "Efficient global variables in Common Lisp")
+ (description
+ "In Common Lisp, a special variable that is never dynamically bound
+typically serves as a stand-in for a global variable. The @code{global-vars}
+library provides true global variables that are implemented by some compilers.
+An attempt to rebind a global variable properly results in a compiler error.
+That is, a global variable cannot be dynamically bound.
-@itemize
-@item Be extensible.
-@item Be practical.
-@item Don't force anything.
-@end itemize\n")
- (license license:llgpl))))
+Global variables therefore allow us to communicate an intended usage that
+differs from special variables. Global variables are also more efficient than
+special variables, especially in the presence of threads.")
+ (license license:expat))))
-(define-public cl-caveman
- (package
- (inherit
- (sbcl-package->cl-source-package sbcl-caveman))
- (propagated-inputs
- `(("ningle" ,cl-ningle)))))
+(define-public cl-global-vars
+ (sbcl-package->cl-source-package sbcl-global-vars))
-(define-public ecl-caveman
- (sbcl-package->ecl-package sbcl-caveman))
+(define-public ecl-global-vars
+ (sbcl-package->ecl-package sbcl-global-vars))
-(define-public sbcl-lambda-fiddle
- (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch
- (revision "1"))
+(define-public sbcl-glop
+ (let ((commit "45e722ab4a0cd2944d550bf790206b3326041e38")
+ (revision "1"))
(package
- (name "sbcl-lambda-fiddle")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-glop")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/lambda-fiddle";)
+ (url "https://github.com/lispgames/glop";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "glop" version))
(sha256
- (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand"))))
+ (base32 "1nm35kvigflfjlmsa8zwdajc61f02fh4sq08jv0wnqylhx8yg2bv"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/Shinmera/lambda-fiddle";)
- (synopsis "Collection of utilities to process lambda-lists")
- (description "This collection of utilities is useful in contexts where
-you want a macro that uses lambda-lists in some fashion but need more precise
-processing.")
- (license license:zlib))))
-
-(define-public cl-lambda-fiddle
- (sbcl-package->cl-source-package sbcl-lambda-fiddle))
-
-(define-public ecl-lambda-fiddle
- (sbcl-package->ecl-package sbcl-lambda-fiddle))
-
-(define-public sbcl-xmls
- (package
- (name "sbcl-xmls")
- (version "3.2.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rpgoldman/xmls";)
- (commit version)))
- (file-name (git-file-name "cl-xmls" version))
- (sha256
- (base32 "10406sgap9kdaip7blxldnv6kabiczd6890jgic4pacsrfx6jypk"))))
- (native-inputs
- (list sbcl-fiveam))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/rpgoldman/xmls";)
- (synopsis "Non-validating XML parser for Common Lisp")
- (description "Xmls is a self-contained, easily embedded parser that
-recognizes a useful subset of the XML spec. It provides a simple mapping from
-XML to Lisp structures or s-expressions and back.")
- (license license:bsd-2)))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'patch-lib-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/x11/xcomposite.lisp"
+ (("libXcomposite.so")
+ (search-input-file inputs "/lib/libXcomposite.so")))
+ (substitute* "src/x11/xlib.lisp"
+ (("libX11")
+ (string-drop-right
+ (search-input-file inputs "/lib/libX11.so") 3)))
+ (substitute* "src/utils.lisp"
+ (("libX11")
+ (string-drop-right
+ (search-input-file inputs "/lib/libX11.so") 3)))
+ (substitute* "src/utils.lisp"
+ (("libGL.so")
+ (search-input-file inputs "/lib/libGL.so.1")))
+ (substitute* "src/x11/glx.lisp"
+ (("libGL.so")
+ (search-input-file inputs "/lib/libGL.so")))
+ (substitute* "src/x11/display-ctrl.lisp"
+ (("libXrandr")
+ (string-drop-right
+ (search-input-file inputs "/lib/libXrandr.so")
3))))))))
+ (native-inputs
+ (list sbcl-cl-opengl))
+ (inputs
+ (list libx11
+ libxcomposite
+ libxrandr
+ mesa
+ sbcl-cffi
+ sbcl-split-sequence
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/lispgames/glop";)
+ (synopsis "Direct FFI bindings for OpenGL window and context management")
+ (description
+ "This package provides Common Lisp bindings to create OpenGL window and
+context manipulation code as well as system input handling. Direct FFI
+bindings to system functions are used so no third party C lib is required
+except system libraries.")
+ (license license:expat))))
-(define-public cl-xmls
- (sbcl-package->cl-source-package sbcl-xmls))
+(define-public cl-glop
+ (sbcl-package->cl-source-package sbcl-glop))
-(define-public ecl-xmls
- (sbcl-package->ecl-package sbcl-xmls))
+(define-public ecl-glop
+ (sbcl-package->ecl-package sbcl-glop))
-(define-public sbcl-geco
- (let ((commit "db13c9384491092975f46f6a837ccdc04681a93a")
+(define-public sbcl-glsl-packing
+ (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a")
(revision "1"))
(package
- (name "sbcl-geco")
- (version (git-version "2.1.2" revision commit))
+ (name "sbcl-glsl-packing")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/gpwwjr/GECO";)
+ (url "https://github.com/3b/glsl-packing/";)
(commit commit)))
- (file-name (git-file-name "cl-geco" version))
+ (file-name (git-file-name "glsl-packing" version))
(sha256
- (base32 "1ncaf9ab7jz59zmga0p97blsjjb1m6db0qih57wipfhqdb5ylz17"))))
+ (base32 "0k2f1771wd9kdrcasldy1r00k5bdgi9fd07in52zmjggc0i7dd80"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/gpwwjr/GECO";)
- (synopsis "Genetic algorithm toolkit for Common Lisp")
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://github.com/3b/glsl-packing/";)
+ (synopsis "Common Lisp utilities to calculate OpenGL layouts")
(description
- "GECO (Genetic Evolution through Combination of Objects) is an
-extensible, object-oriented framework for prototyping genetic algorithms in
-Common Lisp.")
- (license license:lgpl2.0+))))
+ "This is a Common Lisp library to calculate std140 or std430 layouts for
+a glsl UBO/SSBO.")
+ (license license:expat))))
-(define-public cl-geco
- (sbcl-package->cl-source-package sbcl-geco))
+(define-public cl-glsl-packing
+ (sbcl-package->cl-source-package sbcl-glsl-packing))
-(define-public ecl-geco
- (sbcl-package->ecl-package sbcl-geco))
+(define-public ecl-glsl-packing
+ (sbcl-package->ecl-package sbcl-glsl-packing))
-(define-public sbcl-html-entities
- (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb"))
+(define-public sbcl-glsl-spec
+ (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d")
+ (revision "1"))
(package
- (name "sbcl-html-entities")
- (version (git-version "0.02" "1" commit))
+ (name "sbcl-glsl-spec")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/BnMcGn/html-entities/";)
+ (url "https://github.com/cbaggers/glsl-spec";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "glsl-spec" version))
(sha256
- (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr"))))
+ (base32 "01ipspr22fgfj3w8wq2y81lzrjc4vpfiwnr3dqhjlpzzra46am8c"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-ppcre))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/BnMcGn/html-entities/";)
- (synopsis "Encode and decode entities in HTML with Common Lisp")
- (description "Html-entities is a Common Lisp library that lets you
-encode and decode entities in HTML.")
- (license license:expat))))
+ (arguments
+ `(#:asd-systems '("glsl-spec" "glsl-symbols" "glsl-docs")))
+ (home-page "https://github.com/cbaggers/glsl-spec";)
+ (synopsis "Common Lisp GLSL specification as a datastructure")
+ (description
+ "This package contains the specification of all functions and variables
+from GLSL as data.")
+ (license license:unlicense))))
-(define-public cl-html-entities
- (sbcl-package->cl-source-package sbcl-html-entities))
+(define-public cl-glsl-spec
+ (sbcl-package->cl-source-package sbcl-glsl-spec))
-(define-public ecl-html-entities
- (sbcl-package->ecl-package sbcl-html-entities))
+(define-public ecl-glsl-spec
+ (sbcl-package->ecl-package sbcl-glsl-spec))
-(define-public sbcl-quicksearch
- (let ((commit "fb02ecf7c876ec580ab18c7d2c8c7814c06af599"))
+(define-public sbcl-glsl-toolkit
+ (let ((commit "4c4889e75c635772c4df70b11d6f14e7a596da43")
+ (revision "2"))
(package
- (name "sbcl-quicksearch")
- (version (git-version "0.01.04" "1" commit))
+ (name "sbcl-glsl-toolkit")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tkych/quicksearch/";)
+ (url "https://github.com/Shirakumo/glsl-toolkit";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-glsl-toolkit" version))
(sha256
- (base32 "16k19zjkhh7r64vjq371k5jwjs7cdfjz83flh561n4h4v1z89fps"))))
+ (base32 "0vrk8nqijqdi1rwf85rhd93yj7q8qkxnigxn3bw0cbrzvzrks9rl"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-bordeaux-threads
- sbcl-iterate
- sbcl-alexandria
- sbcl-anaphora
- sbcl-cl-ppcre
- sbcl-drakma
- sbcl-html-entities
- sbcl-yason
- sbcl-flexi-streams
- sbcl-do-urlencode))
- (home-page "https://github.com/tkych/quicksearch/";)
- (synopsis "Search Engine Interface for Common Lisp packages")
- (description "Quicksearch is a search-engine-interface for Common Lisp.
-The goal of Quicksearch is to find the Common Lisp library quickly. For
-example, if you will find the library about json, just type @code{(qs:?
-'json)} at REPL.
-
-The function @code{quicksearch} searches for Common Lisp projects in
-Quicklisp, Cliki, GitHub and BitBucket, then outputs results in REPL. The
-function @code{?} is abbreviation wrapper for @code{quicksearch}.")
- (license license:expat))))
+ (list sbcl-cl-ppcre sbcl-documentation-utils sbcl-parse-float
+ sbcl-trivial-indent))
+ (home-page "https://shirakumo.github.io/glsl-toolkit/";)
+ (synopsis "Parser for OpenGL Shader Language source files")
+ (description
+ "This package provides Common Lisp system collecting tools written to
+wrangle OpenGL Shader Language (GLSL) source files.")
+ (license license:zlib))))
-(define-public cl-quicksearch
- (sbcl-package->cl-source-package sbcl-quicksearch))
+(define-public cl-glsl-toolkit
+ (sbcl-package->cl-source-package sbcl-glsl-toolkit))
-(define-public ecl-quicksearch
- (sbcl-package->ecl-package sbcl-quicksearch))
+(define-public ecl-glsl-toolkit
+ (sbcl-package->ecl-package sbcl-glsl-toolkit))
-(define-public sbcl-agutil
- (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68"))
+(define-public sbcl-glyphs
+ (let ((commit "1ff5714e8c1dca327bc604dfe3e3d1f4b7755373"))
(package
- (name "sbcl-agutil")
- (version (git-version "0.0.1" "1" commit))
+ (name "sbcl-glyphs")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/alex-gutev/agutil/";)
+ (url "https://github.com/ahungry/glyphs/";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf"))))
+ (base32 "17kai1anbkk5dj5sbrsin2fc019cmcbglb900db60v38myj0y0wf"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-trivia))
- (home-page "https://github.com/alex-gutev/agutil/";)
- (synopsis "Collection of Common Lisp utilities")
- (description "A collection of Common Lisp utility functions and macros
-mostly not found in other utility packages.")
- (license license:expat))))
+ (list sbcl-cl-ppcre sbcl-parenscript sbcl-named-readtables))
+ (home-page "https://github.com/ahungry/glyphs/";)
+ (synopsis "Reduce Common Lisp verbosity")
+ (description
+ "This library is a little experiment in reducing verbosity in Common
+Lisp, inspired by BODOL (@url{https://github.com/bodil/BODOL}).")
+ (license license:gpl3))))
-(define-public cl-agutil
- (sbcl-package->cl-source-package sbcl-agutil))
+(define-public cl-glyphs
+ (sbcl-package->cl-source-package sbcl-glyphs))
-(define-public ecl-agutil
- (sbcl-package->ecl-package sbcl-agutil))
+(define-public ecl-glyphs
+ (sbcl-package->ecl-package sbcl-glyphs))
-(define-public sbcl-custom-hash-table
- (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa"))
+(define-public sbcl-golden-utils
+ (let ((commit "e43914ad2bdb0c8e1b1f10ef591aafc3c55b89e7")
+ (revision "4"))
(package
- (name "sbcl-custom-hash-table")
- (version (git-version "0.3" "1" commit))
+ (name "sbcl-golden-utils")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/lisp-mirror/golden-utils";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/metawilm/cl-custom-hash-table";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-golden-utils" version))
(sha256
- (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5"))))
+ (base32 "09vq29wjr3x7h3fshwxg8h1psy4p73yl61cjljarpqjhsgz7lmbp"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-custom-hash-table")))
- (home-page "https://github.com/metawilm/cl-custom-hash-table";)
- (synopsis "Custom hash tables for Common Lisp")
- (description "This library allows creation of hash tables with arbitrary
-@code{test}/@code{hash} functions, in addition to the @code{test} functions
-allowed by the standard (@code{EQ}, @code{EQL}, @code{EQUAL} and
-@code{EQUALP}), even in implementations that don't support this functionality
-directly.")
+ (inputs
+ (list sbcl-alexandria))
+ (synopsis "Common Lisp utility library")
+ (description
+ "This is a Common Lisp library providing various utilities.")
(license license:expat))))
-(define-public cl-custom-hash-table
- (sbcl-package->cl-source-package sbcl-custom-hash-table))
+(define-public cl-golden-utils
+ (sbcl-package->cl-source-package sbcl-golden-utils))
-(define-public ecl-custom-hash-table
- (sbcl-package->ecl-package sbcl-custom-hash-table))
+(define-public ecl-golden-utils
+ (sbcl-package->ecl-package sbcl-golden-utils))
-(define-public sbcl-concurrent-hash-tables
- (let ((commit "6ad539b8970ff94b1e1369b59065ed7d0660904c")
- (revision "1"))
+(define-public sbcl-graph
+ (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f")
+ (revision "0"))
(package
- (name "sbcl-concurrent-hash-tables")
+ (name "sbcl-graph")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url
"https://github.com/no-defun-allowed/concurrent-hash-tables";)
- (commit commit)))
- (file-name (git-file-name "cl-concurrent-hash-tables" version))
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/graph";)
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0wgbv3wl33rlfbywmjag0gk7igzfksmib30r8cbnd5n47ic09iip"))))
+ (base32
+ "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-stefil))
(inputs
- (list sbcl-atomics sbcl-bordeaux-threads))
- (home-page "https://github.com/no-defun-allowed/concurrent-hash-tables";)
- (synopsis "Portability library for concurrent hash tables in Common
Lisp")
- (description "@code{concurrent-hash-tables} is a Common Lisp portability
-library wrapping some implementations of concurrent hash tables which do not
-have to be entirely locked in their operation, including
-@code{42nd-at-threadmill}, @code{luckless}, and a fallback, segmented hash
-table.")
- (license license:bsd-2))))
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-heap" ,sbcl-cl-heap)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("curry-compose-reader-macros" ,sbcl-curry-compose-reader-macros)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("yason" ,sbcl-yason)))
+ (arguments
+ '(#:asd-systems '("graph"
+ "graph/dot"
+ "graph/json")))
+ (synopsis "Graph data structure and algorithms for Common Lisp")
+ (description
+ "The GRAPH Common Lisp library provides a data structures to represent
+graphs, as well as some graph manipulation and analysis algorithms (shortest
+path, maximum flow, minimum spanning tree, etc.).")
+ (home-page "https://eschulte.github.io/graph/";)
+ (license license:gpl3+))))
-(define-public cl-concurrent-hash-tables
- (sbcl-package->cl-source-package sbcl-concurrent-hash-tables))
+(define-public cl-graph
+ (sbcl-package->cl-source-package sbcl-graph))
-(define-public ecl-concurrent-hash-tables
- (sbcl-package->ecl-package sbcl-concurrent-hash-tables))
+(define-public ecl-graph
+ (sbcl-package->ecl-package sbcl-graph))
-(define-public sbcl-collectors
- (let ((commit "4c5e70cf399381de8fb485d4ed5a5c8fd7555146")
- (revision "2"))
+(define-public sbcl-green-threads
+ (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
+ (revision "1"))
(package
- (name "sbcl-collectors")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-green-threads")
+ (version (git-version "0.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/collectors";)
+ (url "https://github.com/thezerobit/green-threads";)
(commit commit)))
- (file-name (git-file-name "cl-collectors" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1kc9q05wyp8yjz5wqc73nar7l49vcnfhj4924li81v76hlb03665"))))
+ (base32
+ "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-closer-mop sbcl-symbol-munger))
+ `(("cl-async-future" ,sbcl-cl-async-future)
+ ("cl-cont" ,sbcl-cl-cont)))
(native-inputs
- (list sbcl-lisp-unit2))
- (home-page "https://github.com/AccelerationNet/collectors/";)
- (synopsis "Common lisp library providing collector macros")
- (description "A small collection of common lisp macros to make
-collecting values easier.")
+ (list sbcl-prove))
+ (arguments
+ `(;; TODO: Fix the tests. They fail with:
+ ;; "The function BLACKBIRD::PROMISE-VALUES is undefined"
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "green-threads-test.asd"
+ (("cl-test-more")
+ "prove"))
+ #t)))))
+ (synopsis "Cooperative multitasking library for Common Lisp")
+ (description
+ "This library allows for cooperative multitasking with help of cl-cont
+for continuations. It tries to mimic the API of bordeaux-threads as much as
+possible.")
+ (home-page "https://github.com/thezerobit/green-threads";)
(license license:bsd-3))))
-(define-public cl-collectors
- (sbcl-package->cl-source-package sbcl-collectors))
+(define-public cl-green-threads
+ (sbcl-package->cl-source-package sbcl-green-threads))
-(define-public ecl-collectors
- (sbcl-package->ecl-package sbcl-collectors))
+(define-public ecl-green-threads
+ (sbcl-package->ecl-package sbcl-green-threads))
-(define-public sbcl-cl-environments
- (package
- (name "sbcl-cl-environments")
- (version "0.4")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/alex-gutev/cl-environments";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-environments" version))
- (sha256
- (base32 "10jxj043d2dw5vc0i0lz0lsa4qszn8him5is8jdhl4nsyfcazmky"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-anaphora sbcl-collectors sbcl-optima))
- (native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/alex-gutev/cl-environments";)
- (synopsis "Implements the Common Lisp standard environment access API")
- (description
- "This library provides a uniform API, as specified in Common Lisp the
-Language 2, for accessing information about variable and function bindings
-from implementation-defined lexical environment objects. All major Common
-Lisp implementations are supported, even those which don't support the CLTL2
-environment access API.")
- (license license:expat)))
+(define-public sbcl-gsll
+ (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
+ (revision "1"))
+ (package
+ (name "sbcl-gsll")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/antik/gsll.git";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lisp-unit))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("antik-base" ,sbcl-antik-base)
+ ("cffi" ,sbcl-cffi)
+ ("gsl" ,gsl)
+ ("metabang-bind" ,sbcl-metabang-bind)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
+ (arguments
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-cffi-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gsll.asd"
+ ((":depends-on \\(#:foreign-array")
+ ":depends-on (#:foreign-array #:cffi-libffi"))
+ (substitute* "init/init.lisp"
+ (("libgslcblas.so" all)
+ (string-append
+ (assoc-ref inputs "gsl") "/lib/" all)))
+ (substitute* "init/init.lisp"
+ (("libgsl.so" all)
+ (string-append
+ (assoc-ref inputs "gsl") "/lib/" all))))))))
+ (synopsis "GNU Scientific Library for Lisp")
+ (description
+ "The GNU Scientific Library for Lisp (GSLL) allows the use of the
+GNU Scientific Library (GSL) from Common Lisp. This library provides a
+full range of common mathematical operations useful to scientific and
+engineering applications. The design of the GSLL interface is such
+that access to most of the GSL library is possible in a Lisp-natural
+way; the intent is that the user not be hampered by the restrictions
+of the C language in which GSL has been written. GSLL thus provides
+interactive use of GSL for getting quick answers, even for someone not
+intending to program in Lisp.")
+ (home-page "https://common-lisp.net/project/gsll/";)
+ (license license:gpl3))))
-(define-public cl-environments
- (sbcl-package->cl-source-package sbcl-cl-environments))
+(define-public cl-gsll
+ (sbcl-package->cl-source-package sbcl-gsll))
-(define-public ecl-cl-environments
- (sbcl-package->ecl-package sbcl-cl-environments))
+(define-public ecl-gsll
+ (sbcl-package->ecl-package sbcl-gsll))
-(define-public sbcl-static-dispatch
+(define-public sbcl-gtwiwtg
(package
- (name "sbcl-static-dispatch")
- (version "0.5.1")
+ (name "sbcl-gtwiwtg")
+ (version "0.1.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/alex-gutev/static-dispatch";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "static-dispatch" version))
+ (url "https://github.com/cbeo/gtwiwtg/";)
+ (commit version)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1602vx6ybp0n8mbrrp6q8397fkkyvhrqpahc302pjdb57qildajz"))))
+ (base32 "0lkraw0dwh4is4x5sp5rjrw6f93m0gr9849abrbi12s25ws7jbw4"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-agutil
- sbcl-alexandria
- sbcl-anaphora
- sbcl-arrows
- sbcl-cl-environments
- sbcl-closer-mop
- sbcl-iterate
- sbcl-optima))
- (home-page "https://github.com/alex-gutev/static-dispatch";)
- (synopsis "Static generic function dispatch for Common Lisp")
- (description "Static dispatch is a Common Lisp library, inspired by
-@code{inlined-generic-function}, which allows standard Common Lisp generic
-function dispatch to be performed statically (at compile time) rather than
-dynamically (runtime). This is similar to what is known as \"overloading\" in
-languages such as C++ and Java.
+ (list sbcl-osicat sbcl-prove))
+ (home-page "https://github.com/cbeo/gtwiwtg/";)
+ (synopsis "Naive generators for Common Lisp")
+ (description
+ "The GTWIWTG library (Generators The Way I Want Them Generated --
+technically not generators, but iterators) is meant to be small, explorable,
+and understandable.")
+ (license license:gpl3)))
-The purpose of static dispatch is to provide an optimization in cases where
-the usual dynamic dispatch is too slow, and the dynamic features of generic
-functions, such as adding/removing methods at runtime are not required. An
-example of such a case is a generic equality comparison function. Currently
-generic functions are considered far too slow to implement generic arithmetic
-and comparison operations when used heavily in numeric code.")
- (license license:expat)))
+(define-public cl-gtwiwtg
+ (sbcl-package->cl-source-package sbcl-gtwiwtg))
-(define-public cl-static-dispatch
- (sbcl-package->cl-source-package sbcl-static-dispatch))
+(define-public ecl-gtwiwtg
+ (sbcl-package->ecl-package sbcl-gtwiwtg))
-(define-public ecl-static-dispatch
- (sbcl-package->ecl-package sbcl-static-dispatch))
-
-(define-public sbcl-cl-form-types
- (package
- (name "sbcl-cl-form-types")
- (version "0.3.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/alex-gutev/cl-form-types";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0k4j657vfh4zblp9a7d3z15r82yyz4fzqh8vfn2s7ljsj1dmhp2n"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-agutil
- sbcl-anaphora
- sbcl-arrows
- sbcl-cl-environments
- sbcl-introspect-environment
- sbcl-optima))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/alex-gutev/cl-form-types";)
- (synopsis "Determine the types of Common Lisp forms")
- (description "This library provides functions for determining the value
-types of Common Lisp forms, based on type information contained in the
-environment.
-
-In order for this library to work the values types of variables and return
-types of functions have to be declared.
-
-Macros and symbol-macros are fully expanded and all special forms, except
-@code{CATCH}, are supported.")
- (license license:expat)))
-
-(define-public cl-form-types
- (sbcl-package->cl-source-package sbcl-cl-form-types))
-
-(define-public ecl-cl-form-types
- (let ((pkg (sbcl-package->ecl-package sbcl-cl-form-types)))
- (package
- (inherit pkg)
- (arguments
- ;; FIXME: Syntax error in declaration (TYPE T (FORM &KEY STRICT
- ;; EXPAND-COMPILER-MACROS (TEST (QUOTE FORM-TYPE=))))
- ;; An error occurred during initialization: COMPILE-FILE-ERROR while...
- ;; See <https://github.com/alex-gutev/cl-form-types/issues/22>.
- '(#:tests? #f)))))
-
-(define-public sbcl-generic-cl
- (package
- (name "sbcl-generic-cl")
- (version "0.9")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/alex-gutev/generic-cl";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "1c40vqb49g0adfv17jxgk0ds1n6a2dph30cibq01sicmqdgrrbi8"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Tests fail because SBCL head size is not high enough.
- ;; https://github.com/alex-gutev/generic-cl/issues/6
- `(#:tests? #f))
- (inputs
- (list sbcl-agutil
- sbcl-alexandria
- sbcl-anaphora
- sbcl-arrows
- sbcl-cl-form-types
- sbcl-custom-hash-table
- sbcl-static-dispatch
- sbcl-trivia))
- (native-inputs
- (list sbcl-prove))
- (home-page "https://alex-gutev.github.io/generic-cl/";)
- (synopsis "Generic function interface to standard Common Lisp functions")
- (description "@code{generic-cl} provides a generic function wrapper over
-various functions in the Common Lisp standard, such as equality predicates and
-sequence operations. The goal of this wrapper is to provide a standard
-interface to common operations, such as testing for the equality of two
-objects, which is extensible to user-defined types.")
- (license license:expat)))
-
-(define-public cl-generic-cl
- (sbcl-package->cl-source-package sbcl-generic-cl))
-
-(define-public ecl-generic-cl
- (sbcl-package->ecl-package sbcl-generic-cl))
-
-(define-public sbcl-defpackage-plus
- (let ((revision "0")
- (commit "5492e27e0bdb7b75fa5177ea4388519dc7a75f11"))
+(define-public sbcl-gtype
+ (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18")
+ (revision "2"))
(package
- (name "sbcl-defpackage-plus")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-gtype")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/defpackage-plus";)
+ (url "https://github.com/numcl/gtype";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq"))))
+ (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/rpav/defpackage-plus";)
- (synopsis "Extensible @code{DEFPACKAGE} variant with version support")
+ (synopsis "C++/Julia-like parametric types in Common Lisp")
(description
- "@code{DEFPACKAGE-PLUS} is an extensible @code{DEFPACKAGE} variant with
-predictable cross-platform behavior and some utilities useful for versioning.")
- (license license:bsd-2))))
+ "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
+ (list sbcl-fiveam)))))
-(define-public cl-defpackage-plus
- (sbcl-package->cl-source-package sbcl-defpackage-plus))
+(define-public cl-gtype
+ (sbcl-package->cl-source-package sbcl-gtype))
-(define-public ecl-defpackage-plus
- (sbcl-package->ecl-package sbcl-defpackage-plus))
+(define-public ecl-gtype
+ (let ((pkg (sbcl-package->ecl-package sbcl-gtype)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; The tests fail on ECL with a COMPILE-FILE-ERROR for t/package.lisp.
+ ((#:tests? _ #f) #f))))))
-(define-public sbcl-deploy
- (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8")
- (revision "2"))
+(define-public sbcl-harmony
+ (let ((commit "0b57483cc0341936c201b620f82a8542c606991f")
+ (revision "0"))
(package
- (name "sbcl-deploy")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-harmony")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/deploy";)
+ (url "https://github.com/Shirakumo/harmony";)
(commit commit)))
- (file-name (git-file-name "deploy" version))
+ (file-name (git-file-name "cl-harmony" version))
(sha256
- (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1"))))
+ (base32 "0pqmfi3yi3gi7b7dyayrb621hp60rn7hasq0cl0fis3vg0fp5dja"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-cl-mpg123 sbcl-cl-out123))
(inputs
- (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-features))
- (home-page "https://shinmera.github.io/deploy/";)
- (synopsis "Deployment tools for standalone Common Lisp application")
+ (list sbcl-atomics
+ sbcl-bordeaux-threads
+ sbcl-cl-mixed
+ sbcl-stealth-mixin
+ sbcl-trivial-features))
+ (home-page "https://shirakumo.github.io/harmony/";)
+ (synopsis "Common Lisp sound server and sound processing library")
(description
- "This is a system to help you easily and quickly deploy standalone
-common lisp applications as binaries. Specifically it is geared towards
-applications with foreign library dependencies that run some kind of GUI.")
- (license license:artistic2.0))))
+ "HARMONY is a library that provides you with audio processing tools as
+well as an audio server to play back music, sfx, and so forth. It is most
+suited for use in a game engine, but may feasibly also be used for more
+advanced things such as a DAW")
+ (license license:zlib))))
-(define-public cl-deploy
- (sbcl-package->cl-source-package sbcl-deploy))
+(define-public cl-harmony
+ (sbcl-package->cl-source-package sbcl-harmony))
-(define-public ecl-deploy
- (sbcl-package->ecl-package sbcl-deploy))
+(define-public ecl-harmony
+ (sbcl-package->ecl-package sbcl-harmony))
-(define-public sbcl-deeds
- ;; taged branch is outdated
- (let ((revision "1")
- (commit "f5df54eac79b58a34030e0eb8acf3952c788410d"))
+(define-public sbcl-hash-set
+ (let ((commit "6feb20de457f14e24a83815be1097aa02cca5986")
+ (revision "0"))
(package
- (name "sbcl-deeds")
- (version (git-version "1.1.1" revision commit))
+ (name "sbcl-hash-set")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/deeds";)
+ (url "https://github.com/samebchase/hash-set";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-hash-set" version))
(sha256
- (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k"))))
+ (base32 "0a966y9yfarhmki4wwzg371ziaygnp13yc6r13w9zz327fkhz8na"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bordeaux-threads sbcl-closer-mop sbcl-form-fiddle
- sbcl-lambda-fiddle))
- (home-page "https://github.com/Shinmera/deeds";)
- (synopsis "Extensible Event Delivery System")
- (description
- "@code{deeds} allows for efficient event delivery to multiple handlers
-with a complex event filtering system.")
- (license license:zlib))))
+ (native-inputs (list sbcl-fiveam))
+ (inputs (list sbcl-alexandria))
+ (home-page "https://github.com/samebchase/hash-set/";)
+ (synopsis "Implementation of a hash-set")
+ (description "This package provides an implementation of the
+hash-set data structure. It has constant time lookup, insertion and
+deletion.")
+ (license license:unlicense))))
-(define-public cl-deeds
- (sbcl-package->cl-source-package sbcl-deeds))
+(define-public cl-hash-set
+ (sbcl-package->cl-source-package sbcl-hash-set))
-(define-public ecl-deeds
- (sbcl-package->ecl-package sbcl-deeds))
+(define-public ecl-hash-set
+ (sbcl-package->ecl-package sbcl-hash-set))
-(define-public sbcl-eventbus
- (let ((commit "92c1fa3846ba0e3cc9e6d7605d765379c8658d84")
+(define-public sbcl-hdf5-cffi
+ (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
(revision "1"))
(package
- (name "sbcl-eventbus")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-hdf5-cffi")
+ (version (git-version "1.8.18" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/noloop/eventbus";)
+ (url "https://github.com/hdfgroup/hdf5-cffi";)
(commit commit)))
- (file-name (git-file-name "eventbus" version))
+ (file-name (git-file-name "cl-hdf5-cffi" version))
(sha256
- (base32 "0slqx3zq6sbz3rg4g79j8y25sx4405y6ff3x6l5v8v4v42m1s0p2"))))
+ (base32 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-simplet))
- (home-page "https://github.com/noloop/eventbus";)
- (synopsis "Event bus implementation in Common Lisp")
- (description "This package provides a Common Lisp system implementing
event bus.")
- (license license:gpl3))))
-
-(define-public ecl-eventbus
- (sbcl-package->ecl-package sbcl-eventbus))
+ (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
+ (list hdf5-1.10 sbcl-cffi))
+ (native-inputs
+ (list sbcl-fiveam))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libhdf5.so")
+ (search-input-file inputs "/lib/libhdf5.so")))))
+ (add-after 'fix-paths 'fix-newer-hdf5-compatibility
+ (lambda _
+ (substitute* (list "src/h5-grovel.lisp"
+ "src/h5a-grovel.lisp"
+ "src/h5d-grovel.lisp"
+ "src/h5f-grovel.lisp"
+ "src/h5g-grovel.lisp"
+ "src/h5i-grovel.lisp"
+ "src/h5l-grovel.lisp"
+ "src/h5o-grovel.lisp"
+ "src/h5p-grovel.lisp"
+ "src/h5pl-grovel.lisp"
+ "src/h5r-grovel.lisp"
+ "src/h5s-grovel.lisp"
+ "src/h5t-grovel.lisp"
+ "src/h5z-grovel.lisp")
+ (("_H5private_H")
+ "H5private_H"))))
+ (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-eventbus
- (sbcl-package->cl-source-package sbcl-eventbus))
+(define-public cl-hdf5-cffi
+ (sbcl-package->cl-source-package sbcl-hdf5-cffi))
-(define-public sbcl-make-hash
- ;; no tagged branch
- (let ((revision "1")
- (commit "ae0909cd8e697520a1085fac6f54ac2b448ebd21"))
+(define-public ecl-hdf5-cffi
+ (sbcl-package->ecl-package sbcl-hdf5-cffi))
+
+(define-public sbcl-helambdap
+ (let ((commit "5bf65f57a36ee094cadb096caca6e90eb3ba46c4")
+ (revision "0"))
(package
- (name "sbcl-make-hash")
- (version (git-version "1.0.2" revision commit))
+ (name "sbcl-helambdap")
+ (version (git-version "20220103" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/genovese/make-hash";)
+ (url "https://git.code.sf.net/p/helambdap/code";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-helambdap" version))
(sha256
- (base32 "1qa4mcmb3pv44py0j129dd8hjx09c2akpnds53b69151mgwv5qz8"))))
+ (base32 "1kzapbf9l2bw8i9m9sxv0dfnkksrxq81d5hbn34pm25abk0i937j"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/genovese/make-hash";)
- (synopsis "Common Lisp package for flexible hash table creation")
- (description
- "This is a Common Lisp package for hash table creation with flexible,
-extensible initializers.")
- (license license:bsd-3))))
-
-(define-public cl-make-hash
- (sbcl-package->cl-source-package sbcl-make-hash))
+ (inputs
+ (list sbcl-cl-fad
+ sbcl-clad
+ sbcl-split-sequence
+ sbcl-xhtmlambda))
+ (synopsis "Common Lisp documentation system")
+ (description "HELambdap is a Common Lisp documentation system which
+strives to be simple to use, yet easily customizable.")
+ (home-page "https://helambdap.sourceforge.net";)
+ (license license:expat))))
-(define-public ecl-make-hash
- (sbcl-package->ecl-package sbcl-make-hash))
+(define-public cl-helambdap
+ (sbcl-package->cl-source-package sbcl-helambdap))
-(define-public sbcl-claw-support
+(define-public sbcl-history-tree
(package
- (name "sbcl-claw-support")
- (version "1.0.0")
+ (name "sbcl-history-tree")
+ (version "0.1.2")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/borodust/claw-support";)
- (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b")))
- (file-name (git-file-name name version))
+ (url "https://github.com/atlas-engineer/history-tree";)
+ (commit version)))
+ (file-name (git-file-name "cl-history-tree" version))
(sha256
- (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23"))))
+ (base32 "1n3q6aqh0wm24pksj8371j5iinxpzy2kcnz97kmpndm1yhv4x5f2"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/borodust/claw-support";)
- (synopsis "Support routines for claw")
+ (inputs
+ (list
+ sbcl-alexandria
+ sbcl-custom-hash-table
+ sbcl-local-time
+ sbcl-nclasses
+ sbcl-trivial-package-local-nicknames))
+ (native-inputs (list sbcl-lisp-unit2))
+ (home-page "https://github.com/atlas-engineer/history-tree";)
+ (synopsis "Store the history of a browser's visited paths")
(description
- "This package provides support routines for the @code{claw} Common Lisp
-package.")
- (license license:expat)))
+ "This data structure can be used to store the history of visited paths or
+URLs with a file or web browser, in a way that no “forward” element is ever
+forgotten.
-(define-public cl-claw-support
- (sbcl-package->cl-source-package sbcl-claw-support))
+The history tree is “global” in the sense that multiple owners (e.g. tabs) can
+have overlapping histories. On top of that, an owner can spawn another one,
+starting from one of its nodes (typically when you open a URL in a new tab).")
+ (license license:bsd-3)))
-(define-public ecl-claw-support
- (sbcl-package->ecl-package sbcl-claw-support))
+(define-public cl-history-tree
+ (sbcl-package->cl-source-package sbcl-history-tree))
-(define-public sbcl-claw
- (let ((revision "0")
- (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250"))
- (package
- (name "sbcl-claw")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/borodust/claw";)
- (commit commit)))
- (file-name (git-file-name "claw" version))
- (sha256
- (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cffi
- sbcl-cl-json
- sbcl-cl-ppcre
- sbcl-claw-support
- sbcl-local-time
- sbcl-trivial-features))
- (home-page "https://github.com/borodust/claw";)
- (synopsis "Autowrapper for Common Lisp")
- (description
- "This is a Common Lisp autowrapping facility for quickly creating clean
-and lean bindings to C libraries.")
- (license license:bsd-2))))
+(define-public ecl-history-tree
+ (sbcl-package->ecl-package sbcl-history-tree))
-(define-public cl-claw
- (sbcl-package->cl-source-package sbcl-claw))
+(define-public sbcl-html-encode
+ (package
+ (name "sbcl-html-encode")
+ (version "1.2")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+
"http://beta.quicklisp.org/archive/html-encode/2010-10-06/html-encode-";
+ version ".tgz"))
+ (sha256
+ (base32
+ "06mf8wn95yf5swhmzk4vp0xr4ylfl33dgfknkabbkd8n6jns8gcf"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp library for encoding text in various web-savvy
encodings")
+ (description
+ "A library for encoding text in various web-savvy encodings.")
+ (home-page "https://quickdocs.org/html-encode/";)
+ (license license:expat)))
-(define-public ecl-claw
- (sbcl-package->ecl-package sbcl-claw))
+(define-public cl-html-encode
+ (sbcl-package->cl-source-package sbcl-html-encode))
-(define-public sbcl-claw-utils
- (let ((revision "0")
- (commit "efe25016501973dc369f067a64c7d225802bc56f"))
+(define-public ecl-html-encode
+ (sbcl-package->ecl-package sbcl-html-encode))
+
+(define-public sbcl-html-entities
+ (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb"))
(package
- (name "sbcl-claw-utils")
- ;; version is not specified
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-html-entities")
+ (version (git-version "0.02" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/borodust/claw-utils";)
+ (url "https://github.com/BnMcGn/html-entities/";)
(commit commit)))
- (file-name (git-file-name "claw-utils" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5"))))
+ (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-cffi sbcl-claw))
- (home-page "https://github.com/borodust/claw-utils";)
- (synopsis "Utilities for easier autowrapping")
- (description
- "This Common Lisp library contains various handy utilities to help
-autowrapping with @code{claw}.")
+ (list sbcl-cl-ppcre))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/BnMcGn/html-entities/";)
+ (synopsis "Encode and decode entities in HTML with Common Lisp")
+ (description "Html-entities is a Common Lisp library that lets you
+encode and decode entities in HTML.")
(license license:expat))))
-(define-public cl-claw-utils
- (sbcl-package->cl-source-package sbcl-claw-utils))
+(define-public cl-html-entities
+ (sbcl-package->cl-source-package sbcl-html-entities))
-(define-public ecl-claw-utils
- (sbcl-package->ecl-package sbcl-claw-utils))
+(define-public ecl-html-entities
+ (sbcl-package->ecl-package sbcl-html-entities))
-(define-public sbcl-array-operations
- (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b")
- (revision "0"))
- (package
- (name "sbcl-array-operations")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/bendudson/array-operations";)
- (commit commit)))
- (file-name (git-file-name "array-operations" version))
- (sha256
- (base32 "0ip49hhq32w80qsc7jmspyda5r2rsszvw0mk2r3341cld78sz9ya"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria sbcl-clunit2))
- (inputs
- (list sbcl-let-plus))
- (synopsis "Simple array operations library for Common Lisp")
- (description
- "This library is a collection of functions and macros for manipulating
-Common Lisp arrays and performing numerical calculations with them.")
- (home-page "https://github.com/bendudson/array-operations";)
- (license license:expat))))
+(define-public sbcl-html-template
+ (package
+ (name "sbcl-html-template")
+ (version "0.9.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/html-template";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0wz3czvjsn4x971dsiia9f9nvvcmbkablcl75zsvxndkimc93wxb"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://edicl.github.io/html-template/";)
+ (synopsis "HTML templates from Common Lisp")
+ (description
+ "HTML-TEMPLATE is a Common Lisp library which can be used to fill
+templates with arbitrary (string) values at runtime. The result does not have
+to be HTML.
-(define-public cl-array-operations
- (sbcl-package->cl-source-package sbcl-array-operations))
+It is loosely modeled after the Perl module @code{HTML::Template} and
+partially compatible with a its syntax, though both libraries contain some
+extensions that the other does not support.
-(define-public ecl-array-operations
- (sbcl-package->ecl-package sbcl-array-operations))
+HTML-TEMPLATE translates templates into efficient closures which can be
+re-used as often as needed. It uses a cache mechanism so you can update
+templates while your program is running and have the changes take effect
+immediately.")
+ (license license:bsd-2)))
-(define-public sbcl-clml
- (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8")
- (revision "0"))
+(define-public cl-html-template
+ (sbcl-package->cl-source-package sbcl-html-template))
+
+(define-public ecl-html-template
+ (sbcl-package->ecl-package sbcl-html-template))
+
+(define-public sbcl-http-body
+ (let ((commit "3e4bedd6a9d9bc4e1dc0a45e5b55360ae30fd388")
+ (revision "2"))
(package
- (name "sbcl-clml")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mmaul/clml";)
- (commit commit)))
- (file-name (git-file-name "clml" version))
- (sha256
- (base32 "006pii59nmpc61n7p7h8ha5vjg6x0dya327i58z0rnvxs249h345"))
- ;; TODO: Remove this when the patch has been merged upstream.
- (patches (search-patches "sbcl-clml-fix-types.patch"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-array-operations
- sbcl-cl-fad
- sbcl-cl-ppcre
- sbcl-drakma
- sbcl-introspect-environment
- sbcl-iterate
- sbcl-lparallel
- sbcl-parse-number
- sbcl-split-sequence
- sbcl-trivial-garbage))
- (synopsis "Common Lisp machine learning library")
- (description
- "CLML (Common Lisp Machine Learning) is a high performance and large
-scale statistical machine learning package")
- (home-page "https://mmaul.github.io/clml/";)
- (license license:llgpl))))
+ (name "sbcl-http-body")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/http-body";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0kcg43l5674drzid9cj938q0ki5z25glx296rl239dm7yfmxlzz2"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("http-body-test" "http-body")))
+ (native-inputs
+ (list sbcl-assoc-utils sbcl-prove sbcl-trivial-utf-8))
+ (inputs
+ (list sbcl-babel
+ sbcl-cl-ppcre
+ sbcl-fast-http
+ sbcl-flexi-streams
+ sbcl-jonathan
+ sbcl-trivial-gray-streams
+ sbcl-cl-utilities
+ sbcl-quri))
+ (home-page "https://github.com/fukamachi/http-body";)
+ (synopsis "HTTP POST data parser")
+ (description
+ "HTTP-Body parses HTTP POST data and returns POST parameters. It
+supports application/x-www-form-urlencoded, application/json, and
+multipart/form-data.")
+ (license license:bsd-2))))
-(define-public cl-clml
- (sbcl-package->cl-source-package sbcl-clml))
+(define-public cl-http-body
+ (sbcl-package->cl-source-package sbcl-http-body))
-(define-public sbcl-utm-ups
- (let ((commit "f1e6fd469871051470dfaabdf199afb75f2fa302")
- (revision "0"))
+(define-public ecl-http-body
+ (sbcl-package->ecl-package sbcl-http-body))
+
+(define-public sbcl-hu.dwim.asdf
+ (let ((commit "67cdf84390e530af4303cc4bc815fdf2a5e48f59"))
(package
- (name "sbcl-utm-ups")
- (version (git-version "1.2" revision commit))
+ (name "sbcl-hu.dwim.asdf")
+ (version "20200724")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/utm-ups";)
+ (url "https://github.com/hu-dwim/hu.dwim.asdf";)
(commit commit)))
- (file-name (git-file-name "cl-utm-ups" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "19nnnqagfg1c1vzwlqpp8mq2d0hrk8r6r07a46nvdyzmwbnmbwyr"))))
+ (base32
+ "0p81jalilkaqw832a12s35q0z6rrarxjasm1jy6h4fvyj9pf0zkx"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (synopsis
- "Convert coordinates between latitude/longitude and UTM or UPS")
- (description
- "This a Common Lisp library to convert geographic coordinates between
-latitude/longitude and UTM (Universal Transverse Mercator) or UPS (Universal
-Polar Stereographic).")
- (home-page "https://codeberg.org/glv/utm-ups";)
- (license license:gpl3+))))
+ (home-page "https://hub.darcs.net/hu.dwim/hu.dwim.asdf";)
+ (synopsis "Extensions to ASDF")
+ (description "Various ASDF extensions such as attached test and
+documentation system, explicit development support, etc.")
+ (license license:public-domain))))
-(define-public cl-utm-ups
- (sbcl-package->cl-source-package sbcl-utm-ups))
+(define-public cl-hu.dwim.asdf
+ (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
-(define-public ecl-utm-ups
- (sbcl-package->ecl-package sbcl-utm-ups))
+(define-public ecl-hu.dwim.asdf
+ (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
-(define-public sbcl-mgrs
- (let ((commit "c06f268f9ccb00dfc94c8a07771ce1ca82df26a2")
- (revision "1"))
+(define-public sbcl-hu.dwim.common
+ (package
+ (name "sbcl-hu.dwim.common")
+ (version "2015-07-09")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://beta.quicklisp.org/archive/hu.dwim.common/";
+ version "/hu.dwim.common-"
+ (string-replace-substring version "-" "")
+ "-darcs.tgz"))
+ (sha256
+ (base32 "12l1rr6w9m99w0b5gc6hv58ainjfhbc588kz6vwshn4gqsxyzbhp"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-hu.dwim.asdf))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-closer-mop
+ sbcl-hu.dwim.common-lisp
+ sbcl-iterate
+ sbcl-metabang-bind))
+ (home-page "https://dwim.hu/";)
+ (synopsis "Common Lisp library shared by other hu.dwim systems")
+ (description "This package contains a support library for other
+hu.dwim systems.")
+ (license license:public-domain)))
+
+(define-public cl-hu.dwim.common
+ (sbcl-package->cl-source-package sbcl-hu.dwim.common))
+
+(define-public ecl-hu.dwim.common
+ (sbcl-package->ecl-package sbcl-hu.dwim.common))
+
+(define-public sbcl-hu.dwim.common-lisp
+ (let ((commit "90558195773383142a57a16687d5e7f4adea6418"))
(package
- (name "sbcl-mgrs")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-hu.dwim.common-lisp")
+ (version "2021-01-27")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/mgrs";)
+ (url "https://github.com/hu-dwim/hu.dwim.common-lisp/";)
(commit commit)))
- (file-name (git-file-name "cl-mgrs" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1n4kd734qjj7mrcg0q28hml3npam1rm067iwljwc87zshnxh5gmn"))))
+ (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-utm-ups))
- (synopsis
- "Convert coordinates between latitude/longitude and MGRS")
- (description
- "This a Common Lisp library to convert geographic coordinates between
-latitude/longitude and MGRS.")
- (home-page "https://codeberg.org/glv/mgrs";)
- (license license:gpl3+))))
+ (list sbcl-hu.dwim.asdf))
+ (home-page "http://dwim.hu/project/hu.dwim.common-lisp";)
+ (synopsis "Redefine some standard Common Lisp names")
+ (description "This library is a redefinition of the standard Common Lisp
+package that includes a number of renames and shadows.")
+ (license license:public-domain))))
-(define-public cl-mgrs
- (sbcl-package->cl-source-package sbcl-mgrs))
+(define-public cl-hu.dwim.common-lisp
+ (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
-(define-public ecl-mgrs
- (sbcl-package->ecl-package sbcl-mgrs))
+(define-public ecl-hu.dwim.common-lisp
+ (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp))
-(define-public sbcl-maidenhead
- (let ((commit "4b9c38e4845dda56ae7fb0355c5260c9ade0ac12")
- (revision "1"))
+(define-public sbcl-hu.dwim.defclass-star
+ (let ((commit "3086878a485074f9b2913c58267a9b764cd632fd"))
(package
- (name "sbcl-maidenhead")
- (version (git-version "1.1" revision commit))
+ (name "sbcl-hu.dwim.defclass-star")
+ ;; We used to set version from the date when it was a darcs repo, so we
+ ;; keep the year so that package gets updated on previous installs.
+ (version (git-version "2021" "2" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/maidenhead";)
+ (url "https://github.com/hu-dwim/hu.dwim.defclass-star";)
(commit commit)))
- (file-name (git-file-name "cl-maidenhead" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "10pcx2ngyj6lkfbg1b58lzcm02xl1a3smnad5lvvw30pbalwcq46"))))
+ (base32 "19ipds9r71qymfdp4izg0l7zmvinp06adr8rdalhaq7v7mzpg83z"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
- (synopsis
- "Convert coordinates between latitude/longitude and Maidenhead")
- (description
- "This a Common Lisp library to convert geographic coordinates between
-latitude/longitude and Maidenhead locator system.")
- (home-page "https://codeberg.org/glv/maidenhead";)
- (license license:gpl3+))))
+ (list ;; These 2 inputs are only needed tests which are disabled, see
below.
+ ;; ("hu.dwim.common" ,sbcl-hu.dwim.common)
+ ;; Need cl- package for the :hu.dwim.stefil+hu.dwim.def+swank
system.
+ ;; ("hu.dwim.stefil" ,cl-hu.dwim.stefil)
+ sbcl-hu.dwim.asdf))
+ (arguments
+ `(;; Tests require a circular dependency: hu.dwim.stefil -> hu.dwim.def
+ ;; -> hu.dwim.util -> hu.dwim.defclass-star.
+ #:tests? #f))
+ (home-page "https://github.com/hu-dwim/hu.dwim.defclass-star";)
+ (synopsis "Simplify definitions with defclass* and friends in Common
Lisp")
+ (description "@code{defclass-star} provides defclass* and defcondition*
to
+simplify class and condition declarations. Features include:
-(define-public cl-maidenhead
- (sbcl-package->cl-source-package sbcl-maidenhead))
+@itemize
+@item Automatically export all or select slots at compile time.
+@item Define the @code{:initarg} and @code{:accessor} automatically.
+@item Specify a name transformer for both the @code{:initarg} and
+@code{:accessor}, etc.
+@item Specify the @code{:initform} as second slot value.
+@end itemize
-(define-public ecl-maidenhead
- (sbcl-package->ecl-package sbcl-maidenhead))
+See
+@url{https://common-lisp.net/project/defclass-star/configuration.lisp.html}
+for an example.")
+ (license license:public-domain))))
-(define-public sbcl-olc
- (let ((commit "0269ed747477d967f7d9331964906b6a0f18a9c4")
+(define-public cl-hu.dwim.defclass-star
+ (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
+
+(define-public ecl-hu.dwim.defclass-star
+ (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star))
+
+(define-public sbcl-hu.dwim.graphviz
+ (let ((commit "31522ca8b9a04d535b7cec20ef24d8bf3b26d52b")
(revision "1"))
(package
- (name "sbcl-olc")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-hu.dwim.graphviz")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/olc";)
+ (url "https://github.com/hu-dwim/hu.dwim.graphviz";)
(commit commit)))
- (file-name (git-file-name "cl-olc" version))
+ (file-name (git-file-name "cl-hu.dwim.graphviz" version))
(sha256
- (base32 "02r6w9kfa6v4a12y2azmyjkxbn54r1y18c6a024vq4y6zp20fqnz"))))
+ (base32 "0cz5g7d6817ajypp876k9m65sxxlf42x4bg04ya73aqci5s1vjwy"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'patch-graphviz-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "source/package.lisp"
+ (("libgvc.so")
+ (search-input-file inputs "/lib/libgvc.so"))))))))
(native-inputs
- (list sbcl-fiveam))
- (synopsis
- "Convert coordinates between latitude/longitude and Open Location Code")
+ (list sbcl-hu.dwim.common sbcl-hu.dwim.stefil))
+ (inputs
+ (list graphviz sbcl-cffi sbcl-metabang-bind))
+ (home-page "https://github.com/hu-dwim/hu.dwim.graphviz";)
+ (synopsis "Graphviz layouting using CFFI bindings")
(description
- "This a Common Lisp library to convert geographic coordinates between
-latitude/longitude and Open Location Code.")
- (home-page "https://codeberg.org/glv/olc";)
- (license license:gpl3+))))
+ "This package provides CFFI bindings to the Graphviz library in Common
+Lisp.")
+ (license license:public-domain))))
-(define-public cl-olc
- (sbcl-package->cl-source-package sbcl-olc))
+(define-public cl-hu.dwim.graphviz
+ (sbcl-package->cl-source-package sbcl-hu.dwim.graphviz))
-(define-public ecl-olc
- (sbcl-package->ecl-package sbcl-olc))
+(define-public ecl-hu.dwim.graphviz
+ (sbcl-package->ecl-package sbcl-hu.dwim.graphviz))
-(define-public sbcl-regex
- (let ((commit "fbc9a9f313b9edc1788f33d4b23a29151635ae22"))
+(define-public sbcl-hunchenissr
+ (let ((commit "7df702f2e110999a2f31c7ebad81bfc39ac06670")
+ (revision "1"))
(package
- (name "sbcl-regex")
- (version (git-version "1" "1" commit))
+ (name "sbcl-hunchenissr")
+ (version (git-version "1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/michaelw/regex/";)
+ (url "https://github.com/interactive-ssr/hunchenissr";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "hunchenissr" version))
(sha256
- (base32 "0wq5wlafrxv13wg28hg5b10sc48b88swsvznpy2zg7x37m4nmm6a"))))
+ (base32 "0826qrvk64pjspdklns29dv3zhzfhd6k42fq030xajv8a7hkcxda"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/michaelw/regex/";)
- (synopsis "Regular expression engine for Common Lisp")
+ (inputs
+ (list sbcl-cl-base64
+ sbcl-cl-str
+ sbcl-hunchentoot
+ sbcl-issr-core
+ sbcl-jonathan
+ sbcl-plump
+ sbcl-portal))
+ (home-page "https://github.com/interactive-ssr/hunchenissr";)
+ (synopsis "Interactive Server Side Rendering backend for Hunchentoot")
(description
- "This Common Lisp package provides a regular expression engine.")
- (license license:bsd-2))))
+ "Hunchenissr works together with issr.js for the development of
+interactive (changing without page refreshes) websites making use of websocket
+and Common Lisp server HTML generation instead of mountains of convoluted
+Javascript.")
+ (license license:llgpl))))
-(define-public cl-regex
- (sbcl-package->cl-source-package sbcl-regex))
+(define-public cl-hunchenissr
+ (sbcl-package->cl-source-package sbcl-hunchenissr))
-(define-public ecl-regex
- (sbcl-package->ecl-package sbcl-regex))
+(define-public ecl-hunchenissr
+ (sbcl-package->ecl-package sbcl-hunchenissr))
-(define-public sbcl-clawk
- (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6"))
+(define-public sbcl-hunchenissr-routes
+ (let ((commit "2e831975dc2a6c030f1b518747cf429be8484b31")
+ (revision "1"))
(package
- (name "sbcl-clawk")
- (version (git-version "4" "1" commit))
+ (name "sbcl-hunchenissr-routes")
+ (version (git-version "0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/clawk";)
+ (url "https://github.com/interactive-ssr/hunchenissr-routes";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "hunchenissr-routes" version))
(sha256
- (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a"))))
+ (base32 "1xyqacihxwk4vnffqlg93czmalscglp6sh3bwy3qwb7hdxv6yxz6"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-regex))
- (home-page "https://github.com/sharplispers/clawk";)
- (synopsis "Common Lisp AWK")
+ (list sbcl-alexandria sbcl-cl-ppcre sbcl-cl-unification
+ sbcl-hunchenissr))
+ (home-page "https://github.com/interactive-ssr/hunchenissr-routes";)
+ (synopsis "Enable path variables when using Hunchenissr")
(description
- "CLAWK is an AWK implementation embedded into Common Lisp.")
- (license license:bsd-2))))
+ "This library enables path variables in networking routes when using
+Hunchenissr for Common Lisp. If a part of the path (between two slashes)
+starts with a question mark (?), that symbol (without question mark) will be
+bound to whatever value was in the same place in the URL (as a string).")
+ (license license:llgpl))))
-(define-public cl-clawk
- (sbcl-package->cl-source-package sbcl-clawk))
+(define-public cl-hunchenissr-routes
+ (sbcl-package->cl-source-package sbcl-hunchenissr-routes))
-(define-public ecl-clawk
- (sbcl-package->ecl-package sbcl-clawk))
+(define-public ecl-hunchenissr-routes
+ (sbcl-package->ecl-package sbcl-hunchenissr-routes))
-(define-public sbcl-clamp
- (let ((commit "02b8f3953e5753cc61a719807c82f3795cd28fe1"))
+(define-public sbcl-hunchentoot
+ ;; NOTE: (Sharlatan-20220520T213309+0100): The latest commit fixed tests,
+ ;; switch to the version tag when release is ready.
+ (let ((commit "76862391040c20255c7275e815c2175e46bfd080")
+ (revision "1"))
(package
- (name "sbcl-clamp")
- (version (git-version "0.3" "1" commit))
+ (name "sbcl-hunchentoot")
+ (version (git-version "1.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/arclanguage/Clamp";)
+ (url "https://github.com/edicl/hunchentoot";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-hunchentoot" version))
(sha256
- (base32 "0fdr9nqfmmpxm6hvjdxi1jkclya9xlnrw1yc3cn1m4ww3f50p31m"))))
+ (base32 "1h7ggmmzvgwr4p6j3ai0dqrw30q5309l13w4c03gqrapvwrb65l0"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("iterate" ,sbcl-iterate)
- ("cl-syntax" ,sbcl-cl-syntax)))
(native-inputs
- `(("cl-unit" ,sbcl-clunit)
- ("check-it" ,sbcl-check-it)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-build
- (lambda _
- (substitute* "clamp.asd"
- (("\\(:file \"read\" :depends-on \\(\"aliases\"\\)\\)")
- "(:file \"read\" :depends-on (\"aliases\" \"base\"))"))
- #t)))))
- (home-page "https://github.com/arclanguage/Clamp";)
- (synopsis "Common Lisp with Arc macros and procedures")
+ (list sbcl-cl-who sbcl-drakma))
+ (inputs
+ (list sbcl-chunga
+ sbcl-cl-base64
+ sbcl-cl-fad
+ sbcl-cl-ppcre
+ sbcl-flexi-streams
+ sbcl-cl+ssl
+ sbcl-md5
+ sbcl-rfc2388
+ sbcl-trivial-backtrace
+ sbcl-usocket))
+ (home-page "https://edicl.github.io/hunchentoot/";)
+ (synopsis "Web server written in Common Lisp")
(description
- "Clamp is an attempt to bring the powerful, but verbose, language of
-Common Lisp up to the terseness of Arc.
-
-There are two parts to Clamp. There is the core of Clamp, which implements
-the utilities of Arc that are easily converted from Arc to Common Lisp. The
-other part is the \"experimental\" part. It contains features of Arc that are
-not so easy to copy (ssyntax, argument destructuring, etc.).")
- (license license:artistic2.0))))
+ "Hunchentoot is a web server written in Common Lisp and at the same
+time a toolkit for building dynamic websites. As a stand-alone web server,
+Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
+connections (keep-alive), and SSL.")
+ (license license:bsd-2))))
-(define-public cl-clamp
- (sbcl-package->cl-source-package sbcl-clamp))
+(define-public cl-hunchentoot
+ (sbcl-package->cl-source-package sbcl-hunchentoot))
-(define-public ecl-clamp
- (sbcl-package->ecl-package sbcl-clamp))
+(define-public ecl-hunchentoot
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-hunchentoot))
+ (arguments
+ ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'.
+ '(#:tests? #f))))
-(define-public sbcl-trivial-shell
- (let ((commit "e02ec191b34b52deca5d1c4ee99d4fa13b8772e0"))
+(define-public sbcl-hunchentoot-errors
+ (let ((commit "69eb3bcea59ed1ccf3dd1960e6d48fb21f1dadab")
+ (revision "0"))
(package
- (name "sbcl-trivial-shell")
- (version (git-version "0.2.0" "1" commit))
+ (name "sbcl-hunchentoot-errors")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/trivial-shell";)
+ (url "https://github.com/mmontone/hunchentoot-errors";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-hunchentoot-errors" version))
(sha256
- (base32 "08mpkl5ij5sjfsyn8pq2kvsvpvyvr7ha1r8g1224fa667b8k2q85"))))
+ (base32 "0fab7s8qhhs713cw014qqvzm5z61wmxm2fcbkarhg41cz3li9k1j"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda _
- (substitute* "dev/definitions.lisp"
- (("/bin/sh")
- (which "sh"))))))))
- (native-inputs
- (list sbcl-lift))
- (home-page "https://common-lisp.net/project/trivial-shell/";)
- (synopsis "Common Lisp access to the shell")
+ (inputs
+ (list sbcl-cl-mimeparse
+ sbcl-hunchentoot
+ sbcl-parse-number
+ sbcl-string-case))
+ (home-page "https://github.com/mmontone/hunchentoot-errors/";)
+ (synopsis "Hunchentoot error pages and logs with request and session
information")
(description
- "A simple Common-Lisp interface to the underlying operating system.
-It's independent of the implementation and operating system.")
+ "This package provides a functionality augmenting Hunchentoot error
+pages and logs with request and session information.")
(license license:expat))))
-(define-public cl-trivial-shell
- (sbcl-package->cl-source-package sbcl-trivial-shell))
+(define-public cl-hunchentoot-errors
+ (sbcl-package->cl-source-package sbcl-hunchentoot-errors))
-(define-public ecl-trivial-shell
- (sbcl-package->ecl-package sbcl-trivial-shell))
+(define-public ecl-hunchentoot-errors
+ (sbcl-package->ecl-package sbcl-hunchentoot-errors))
-(define-public sbcl-clesh
- (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11"))
+(define-public sbcl-hypergeometrica
+ (let ((commit "db723ceb343d89a1c8d7f9174cf3a76fa91522b5")
+ (revision "0"))
(package
- (name "sbcl-clesh")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-hypergeometrica")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Neronus/Clesh";)
+ (url "https://github.com/stylewarning/hypergeometrica";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-hypergeometrica" version))
(sha256
- (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318"))))
+ (base32 "1dfd6w9djgfh7f4z79d8qsyggrwkjlqhs9rxpzpzv092nlwg3l35"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiasco))
(inputs
- (list sbcl-trivial-shell sbcl-named-readtables))
- (home-page "https://github.com/Neronus/Clesh";)
- (synopsis "Embed shell code in Common Lisp")
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-global-vars
+ sbcl-lparallel
+ sbcl-mmap
+ sbcl-napa-fft3
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/stylewarning/hypergeometrica";)
+ (synopsis "High-precision arithmetic")
(description
- "This is a very short and simple program, written in Common Lisp, that
-extends Common Lisp to embed shell code in a manner similar to Perl's
-backtick. It has been forked from SHELISP.")
- (license license:bsd-2))))
+ "Hypergeometrica is a Common Lisp library for performing high-precision
+arithmetic, with a focus on performance. At the heart of it all are routines
+for multiplication. Hypergeometrica aims to support:
-(define-public cl-clesh
- (sbcl-package->cl-source-package sbcl-clesh))
+@itemize
+@item In-core multiplication using various algorithms, from schoolbook to
+floating-point FFTs.
+@item In-core multiplication for large numbers using exact convolutions via
+number-theoretic transforms, which is enabled by 64-bit modular arithmetic.
+@item Out-of-core multiplication using derivatives of the original
+Cooley–Tukey algorithm.
+@end itemize
-(define-public ecl-clesh
- (sbcl-package->ecl-package sbcl-clesh))
+On top of multiplication, one can build checkpointed algorithms for computing
+various classical constants, like @math{\\pi}.")
+ (license license:bsd-3))))
-(define-public sbcl-trivial-channels
- (let ((commit "e2370118d8983ba69c0360a7695f8f2e2fd6a8a6")
+(define-public cl-hypergeometrica
+ (sbcl-package->cl-source-package sbcl-hypergeometrica))
+
+(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
+ (list 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-ieee-floats
+ (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
(revision "1"))
(package
- (name "sbcl-trivial-channels")
+ (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
+ (list sbcl-fiveam))
+ (synopsis "IEEE 754 binary representation for floats in Common Lisp")
+ (description "This is a Common Lisp library that converts
+floating point values to IEEE 754 binary representation.")
+ (license license:bsd-3))))
+
+(define-public cl-ieee-floats
+ (sbcl-package->cl-source-package sbcl-ieee-floats))
+
+(define-public ecl-ieee-floats
+ (sbcl-package->ecl-package sbcl-ieee-floats))
+
+(define-public sbcl-in-memory-streams
+ (let ((commit "bb4ce9c8c08479c9904f5d29f2b6187f264dc620")
+ (revision "1"))
+ (package
+ (name "sbcl-in-memory-streams")
(version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/trivial-channels";)
+ (url "https://codeberg.org/glv/cl-in-memory-streams";)
(commit commit)))
- (file-name (git-file-name "trivial-channels" version))
+ (file-name (git-file-name "cl-in-memory-streams" version))
(sha256
- (base32 "04wnxcgk40x8p0gxnz9arv1a5wasdqrdxa8c4p5v7r2mycfps6jj"))))
+ (base32 "1fls1jnkf86wimip6f95y496sc4rxpsh2y65lgqsqpi0yda5xl2f"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-bordeaux-threads sbcl-trivial-timeout))
- (home-page "https://github.com/rpav/trivial-channels";)
- (synopsis "Common Lisp simple thread-safe channels with timeout")
+ (list sbcl-trivial-gray-streams))
+ (synopsis "In-memory streams for any element type")
(description
- "It's very basic implementation of channels and queue for Common Lisp.")
- (license license:bsd-2))))
+ "This Common Lisp library provides an implementation of in-memory input
+streams, output streams and io streams for any type of elements.")
+ (home-page "https://codeberg.org/glv/cl-in-memory-streams";)
+ (license license:gpl3+))))
-(define-public ecl-trivial-channels
- (sbcl-package->ecl-package sbcl-trivial-channels))
+(define-public cl-in-memory-streams
+ (sbcl-package->cl-source-package sbcl-in-memory-streams))
-(define-public cl-trivial-channels
- (sbcl-package->cl-source-package sbcl-trivial-channels))
+(define-public ecl-in-memory-streams
+ (sbcl-package->ecl-package sbcl-in-memory-streams))
-(define-public sbcl-trivial-download
- (let ((commit "d2472061d86b1cf3d32f388daacd4e32a13af699"))
+(define-public sbcl-incless
+ (let ((commit "395accf484ffdff70f20b941f322e8329c585ca7")
+ (revision "0"))
(package
- (name "sbcl-trivial-download")
- (version (git-version "0.3" "1" commit))
+ (name "sbcl-incless")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/trivial-download/";)
+ (url "https://github.com/s-expressionists/Incless";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-incless" commit))
(sha256
- (base32 "06f46zr3gp3wlm2kgxna24qd2gpr1v89x9fynh1x5vrw6c6hqjcv"))))
+ (base32 "14bkb5zx8xq6wv6dsqi041dwq9scvw3kdjlnkfs2ndazj0rb2a1k"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-drakma))
- (home-page "https://github.com/eudoxia0/trivial-download/";)
- (synopsis "Download files from Common Lisp")
+ (inputs (list sbcl-alexandria))
+ ;; See https://github.com/s-expressionists/Incless/issues/6
+ (arguments '(#:asd-systems '("incless")))
+ (home-page "https://github.com/s-expressionists/incless";)
+ (synopsis "Implements print-object methods for many standard classes")
(description
- "@code{trivial-download} allows you to download files from the Internet
-from Common Lisp. It provides a progress bar.")
+ "@code{cl-incless} implements print-object methods for many standard
+classes.")
(license license:bsd-2))))
-(define-public cl-trivial-download
- (sbcl-package->cl-source-package sbcl-trivial-download))
+(define-public cl-incless
+ (sbcl-package->cl-source-package sbcl-incless))
-(define-public ecl-trivial-download
- (sbcl-package->ecl-package sbcl-trivial-download))
+(define-public ecl-incless
+ (sbcl-package->ecl-package sbcl-incless))
-(define-public sbcl-transmission
- (let ((commit "4bbf1d2761bfa5dfa79b7bc12c3238089b994d95"))
+(define-public sbcl-inferior-shell
+ (let ((commit "15c2d04a7398db965ea1c3ba2d49efa7c851f2c2")
+ (revision "1"))
(package
- (name "sbcl-transmission")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-inferior-shell")
+ (version (git-version "2.0.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/libre-man/cl-transmission/";)
+ (url "https://github.com/fare/inferior-shell";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "inferior-shell" version))
(sha256
- (base32 "0sg3f2jqs2z3mvscjhc43hkd34vlcc4c8hq8rhh5w1gjg19z57hb"))))
+ (base32 "02qx37zzk5j4xmwh77k2qa2wvnzvaj6qml5dh2q7b6b1ljvgcj4m"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-transmission")))
- (inputs
- (list sbcl-cl-ppcre sbcl-jonathan sbcl-named-readtables sbcl-rutils
- sbcl-drakma))
(native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/libre-man/cl-transmission/";)
- (synopsis "Common Lisp interface with Transmission using its RPC")
+ (list sbcl-hu.dwim.stefil))
+ (inputs
+ (list sbcl-alexandria sbcl-fare-mop sbcl-fare-quasiquote
+ sbcl-fare-utils sbcl-trivia))
+ (home-page "https://github.com/fare/inferior-shell";)
+ (synopsis "Spawn local or remote processes and shell pipes")
(description
- "@code{cl-transmission} is a library to interface with the Transmission
-torrent client using its RPC (remote procedure call).")
+ "This package provides a Common Lisp system helping in scripting, it
+uses @code{uiop:run-program} as a backend.")
(license license:expat))))
-(define-public cl-transmission
- (sbcl-package->cl-source-package sbcl-transmission))
+(define-public cl-inferior-shell
+ (sbcl-package->cl-source-package sbcl-inferior-shell))
-(define-public ecl-transmission
- (sbcl-package->ecl-package sbcl-transmission))
+(define-public ecl-inferior-shell
+ (sbcl-package->ecl-package sbcl-inferior-shell))
-(define-public sbcl-gtwiwtg
- (package
- (name "sbcl-gtwiwtg")
- (version "0.1.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cbeo/gtwiwtg/";)
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0lkraw0dwh4is4x5sp5rjrw6f93m0gr9849abrbi12s25ws7jbw4"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-osicat sbcl-prove))
- (home-page "https://github.com/cbeo/gtwiwtg/";)
- (synopsis "Naive generators for Common Lisp")
- (description
- "The GTWIWTG library (Generators The Way I Want Them Generated --
-technically not generators, but iterators) is meant to be small, explorable,
-and understandable.")
- (license license:gpl3)))
-
-(define-public cl-gtwiwtg
- (sbcl-package->cl-source-package sbcl-gtwiwtg))
-
-(define-public ecl-gtwiwtg
- (sbcl-package->ecl-package sbcl-gtwiwtg))
-
-(define-public sbcl-cl-progress-bar
- (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae"))
+(define-public sbcl-infix-math
+ (let ((commit "f5155ae9709e518061ace79887d78f8e79c61cac")
+ (revision "0"))
(package
- (name "sbcl-cl-progress-bar")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-infix-math")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sirherrbatka/cl-progress-bar/";)
+ (url "https://github.com/ruricolist/infix-math";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-infix-math" version))
(sha256
- (base32 "1ldb4qhmx431n3lsq71ynwb9ybazbfqd55icjbhi06mj52ngndir"))))
+ (base32 "1h6p254xl793wfq3qla5y95k6zimy477f8brblx6ran3rg3bydbg"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-bordeaux-threads sbcl-documentation-utils-extensions))
- (home-page "https://github.com/sirherrbatka/cl-progress-bar/";)
- (synopsis "Progress bars in Common Lisp")
+ (list sbcl-alexandria sbcl-parse-number sbcl-serapeum sbcl-wu-decimal))
+ (home-page "https://github.com/ruricolist/infix-math";)
+ (synopsis "Extensible infix syntax for math in Common Lisp")
(description
- "This library provides almost the same code as used inside Quicklisp
-for drawning progress bars")
+ "Infix-Math is a library that provides a special-purpose syntax for
+transcribing mathematical formulas into Lisp.")
(license license:expat))))
-(define-public cl-progress-bar
- (sbcl-package->cl-source-package sbcl-cl-progress-bar))
-
-(define-public ecl-cl-progress-bar
- (sbcl-package->ecl-package sbcl-cl-progress-bar))
-
-(define-public sbcl-repl-utilities
- (let ((commit "7e300df663177ea4581f4e7e9c601377881dd986"))
- (package
- (name "sbcl-repl-utilities")
- (version (git-version "0.0.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/m-n/repl-utilities/";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1hh56pq5nw3l4b83dzlyss69f06r038byj2cnjwvci4hfjhdfcc3"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/m-n/repl-utilities";)
- (synopsis "Ease common tasks at the Common Lisp REPL")
- (description
- "@code{repl-utilities} is a set of utilities which ease life at the
-REPL. It includes three sorts of features: introspective procedures,
-miscellaneous utility functions, and, pulling them together, methods to
-conveniently keep these symbols and optionally additional symbols available in
-whichever package you switch to.")
- (license license:bsd-2))))
-
-(define-public cl-repl-utilities
- (sbcl-package->cl-source-package sbcl-repl-utilities))
+(define-public cl-infix-math
+ (sbcl-package->cl-source-package sbcl-infix-math))
-(define-public ecl-repl-utilities
- (sbcl-package->ecl-package sbcl-repl-utilities))
+(define-public ecl-infix-math
+ (sbcl-package->ecl-package sbcl-infix-math))
-(define-public sbcl-supertrace
- (let ((commit "66d22c3ff131ecd1c8048dfced1d62ed6024ecb0"))
- (package
- (name "sbcl-supertrace")
- (version (git-version "0.1.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/supertrace";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0n369n6b7y1m49biccnnr7svymjdsk8sksrkqrn3mj21vgv7s7bg"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-cffi sbcl-rove sbcl-cl-ppcre sbcl-bordeaux-threads))
- (inputs
- (list sbcl-cffi))
- (home-page "https://github.com/fukamachi/supertrace";)
- (synopsis "Improved Common Lisp tracing for debugging and profiling")
- (description
- "Supertrace provides a superior Common Lisp @code{trace} functionality
-for debugging and profiling real world applications.")
- (license license:bsd-2))))
+(define-public sbcl-inheriting-readers
+ (package
+ (name "sbcl-inheriting-readers")
+ (version "1.0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/inheriting-readers";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-inheriting-readers" version))
+ (sha256
+ (base32 "0km3mq6vx1q9qv6j3r4sqqcsdbnb5jar66bl0mzzpaacfvzbx68p"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-class-options
+ sbcl-closer-mop
+ sbcl-compatible-metaclasses))
+ (home-page "https://www.hexstreamsoft.com/libraries/inheriting-readers/";)
+ (synopsis "Simple yet powerful value inheritance scheme")
+ (description
+ "This package provides a simple yet powerful value inheritance scheme.")
+ (license license:unlicense)))
-(define-public cl-supertrace
- (sbcl-package->cl-source-package sbcl-supertrace))
+(define-public cl-inheriting-readers
+ (sbcl-package->cl-source-package sbcl-inheriting-readers))
-(define-public ecl-supertrace
- (sbcl-package->ecl-package sbcl-supertrace))
+(define-public ecl-inheriting-readers
+ (sbcl-package->ecl-package sbcl-inheriting-readers))
-(define-public sbcl-flamegraph
- (let ((commit "1ed7a718eae88bd35e1649a1c716d46c59dc0a24")
+(define-public sbcl-interface
+ (let ((commit "6d8bd74214053debcbc0b174d65ea73c271c1563")
(revision "0"))
(package
- (name "sbcl-flamegraph")
+ (name "sbcl-interface")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- ;; This is a fork with fixes for latest SBCL.
- (url "https://github.com/ruricolist/cl-flamegraph";)
+ (url "https://github.com/stylewarning/interface";)
(commit commit)))
- (file-name (git-file-name "cl-flamegraph" version))
+ (file-name (git-file-name "cl-interface" version))
(sha256
- (base32 "1aj7hhvav9j9c66ssy11ry3p6xqb912yafi91g6sin6pdx84c2lw"))))
+ (base32 "0h1bckhyig2znl6nrd3agjzz7knrm2kyh2vfyk7j60kzki9rpzxy"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/40ants/cl-flamegraph";)
- (synopsis "Generate flamegraphs of Common Lisp code")
+ (inputs (list sbcl-alexandria sbcl-global-vars))
+ (synopsis "System for defining interfaces")
(description
- "@code{cl-flamegraph} is a wrapper around SBCL's statistical profiler.
-It saves stack traces of profiled code in a form suitable for processing by
-the @command{flamegraph.pl} script, which is available in the Guix package
-@code{flamegraph}.")
+ "This library contains an implementation of interfaces and
+implementations. They're sometimes called protocols in other
+languages. Broadly speaking, an @emph{interface} is some collection of
+function @emph{prototypes} that a valid implementation must implement.")
+ (home-page "https://github.com/stylewarning/interface";)
(license license:bsd-3))))
-(define-public cl-flamegraph
- (sbcl-package->cl-source-package sbcl-flamegraph))
+(define-public cl-interface
+ (sbcl-package->cl-source-package sbcl-interface))
-(define-public sbcl-trivial-benchmark
- (let ((commit "1fbc8d15f09ed8aa426bc73956b8b7c9b2668802")
+(define-public ecl-interface
+ (sbcl-package->ecl-package sbcl-interface))
+
+(define-public sbcl-introspect-environment
+ (let ((commit "8fb20a1a33d29637a22943243d1482a20c32d6ae")
(revision "2"))
(package
- (name "sbcl-trivial-benchmark")
- (version (git-version "2.0.0" revision commit))
+ (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 "https://github.com/Shinmera/trivial-benchmark/";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-trivial-benchmark" version))
+ (file-name (git-file-name "cl-introspect-environment" version))
(sha256
- (base32 "1p48wgpady0n8frdcgp7sbg93b0fbvpx1qk5valmanhwr9j3xh88"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (home-page "https://shinmera.github.io/trivial-benchmark/";)
- (synopsis "Easy to use benchmarking system for Common Lisp")
- (description
- "Trivial-Benchmark runs a block of code many times and outputs some
-statistical data for it. On SBCL this includes the data from @code{time}, for
-all other implementations just the @code{real-time} and @code{run-time} data.
-However, you can extend the system by adding your own @code{metrics} to it, or
-even by adding additional statistical @code{compute}ations.")
- (license license:zlib))))
+ (base32 "1p48jnr1im47529w0ciyar4hfwbivqi57zgllkmfrav09ffigk9s"))))
+ (native-inputs
+ (list 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.
-(define-public cl-trivial-benchmark
- (sbcl-package->cl-source-package sbcl-trivial-benchmark))
+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.
-(define-public ecl-trivial-benchmark
- (sbcl-package->ecl-package sbcl-trivial-benchmark))
+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.
-(define-public sbcl-the-cost-of-nothing
- (let ((commit "f364029fbbf37ae5786f2f9ddf6185dd204a7185")
+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 cl-introspect-environment
+ (sbcl-package->cl-source-package sbcl-introspect-environment))
+
+(define-public ecl-introspect-environment
+ (sbcl-package->ecl-package sbcl-introspect-environment))
+
+(define-public sbcl-iolib
+ (let ((commit "010b7a6bdd2e918ebf2ec85edd3853179f01cb30")
(revision "0"))
(package
- (name "sbcl-the-cost-of-nothing")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-iolib")
+ (version (git-version "0.8.4" revision commit))
+ (home-page "https://github.com/sionescu/iolib";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/the-cost-of-nothing";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-the-cost-of-nothing" version))
+ (file-name (git-file-name "cl-iolib" version))
(sha256
- (base32 "1ccrglyr1wnnfp218w1qj7yfl4yzlxkki3hqaifi5axgbi5dmmh8"))))
+ (base32 "1qqy2yhprkmdn2vmi69akf818q3n99gv8cacv6456af0wjm5p1ga"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; The test operation benchmarks the Common Lisp implementation; it
- ;; doesn't test the package.
- (list #:tests? #f))
+ (native-inputs
+ (list pkg-config sbcl-fiveam))
(inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-local-time
- sbcl-trivial-garbage))
- (home-page "https://github.com/marcoheisig/the-cost-of-nothing";)
- (synopsis "Measure the run time of Common Lisp code")
- (description
- "THE-COST-OF-NOTHING is a library for measuring the run time of Common
-Lisp code. It provides macros and functions for accurate benchmarking and
-lightweight monitoring. Furthermore, it provides predefined benchmarks to
-determine the cost of certain actions on a given platform and implementation.")
+ (list libfixposix
+ sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-idna
+ sbcl-split-sequence
+ sbcl-swap-bytes))
+ (arguments
+ '(#:asd-systems '("iolib"
+ "iolib/os")
+ #: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.asd"
+ (("\\(:file \"sockets\" :depends-on \\(\"pkgdcl\"
\"defsuites\"\\)\\)")
+ "")))))))
+ (synopsis "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 cl-the-cost-of-nothing
- (sbcl-package->cl-source-package sbcl-the-cost-of-nothing))
+(define-public cl-iolib
+ (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
+ (package
+ (inherit parent)
+ (propagated-inputs
+ ;; Need header to compile.
+ (modify-inputs (package-propagated-inputs parent)
+ (prepend libfixposix))))))
-(define-public ecl-the-cost-of-nothing
- (sbcl-package->ecl-package sbcl-the-cost-of-nothing))
+(define-public ecl-iolib
+ (sbcl-package->ecl-package sbcl-iolib))
-(define-public sbcl-atomichron
- (let ((commit "5b3578bbad8c37ab559e56924d98c373efe11de5")
- (revision "0"))
- (package
- (name "sbcl-atomichron")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/no-defun-allowed/atomichron";)
- (commit commit)))
- (file-name (git-file-name "cl-atomichron" version))
- (sha256
- (base32 "1fmmhb3pbv7j4d1cc02zv24bpd0kd2agfjjcj46w3gmv1bb0hva1"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-atomics sbcl-bordeaux-threads))
- (home-page "https://github.com/no-defun-allowed/atomichron";)
- (synopsis "Atomic metering library for Common Lisp")
- (description
- "@code{atomichron} is a Common Lisp library which implements a time
-meter which tracks how many times a form is evaluated, and how long evaluation
-takes. It uses atomic instructions so that meters will present correct
-results in the presence of multiple threads, while trying to minimize
-synchronization latency.")
- (license license:bsd-2))))
+(define-public sbcl-ironclad
+ (package
+ (name "sbcl-ironclad")
+ (version "0.60")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/ironclad/";)
+ (commit (string-append "v" version))))
+ (sha256
+ (base32 "122ldxiddkscb3li5wjrppr7vyn77znyjfgs8pbflrskzyxlabdd"))
+ (file-name (git-file-name "cl-ironclad" version))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ ;; Tests only.
+ (list sbcl-rt))
+ (inputs
+ (list sbcl-bordeaux-threads sbcl-flexi-streams))
+ (synopsis "Cryptographic toolkit written in Common Lisp")
+ (description
+ "Ironclad is a cryptography library written entirely in Common Lisp.
+It includes support for several popular ciphers, digests, MACs and public key
+cryptography algorithms. For several implementations that support Gray
+streams, support is included for convenient stream wrappers.")
+ (home-page "https://github.com/sharplispers/ironclad";)
+ (license license:bsd-3)))
-(define-public cl-atomichron
- (sbcl-package->cl-source-package sbcl-atomichron))
+(define-public cl-ironclad
+ (sbcl-package->cl-source-package sbcl-ironclad))
-(define-public ecl-atomichron
- (sbcl-package->ecl-package sbcl-atomichron))
+(define-public ecl-ironclad
+ (sbcl-package->ecl-package sbcl-ironclad))
-(define-public sbcl-glyphs
- (let ((commit "1ff5714e8c1dca327bc604dfe3e3d1f4b7755373"))
+(define-public sbcl-issr-core
+ (let ((commit "64e3b07a63a7ca3ad70ba42474f98ac4513580aa")
+ (revision "1"))
(package
- (name "sbcl-glyphs")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-issr-core")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ahungry/glyphs/";)
+ (url "https://github.com/interactive-ssr/core";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "issr-core" version))
(sha256
- (base32 "17kai1anbkk5dj5sbrsin2fc019cmcbglb900db60v38myj0y0wf"))))
+ (base32 "1bajb09crzadkirdpd6jrpcc55irjd4sxzavygr25l85pafyhniw"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-ppcre sbcl-parenscript sbcl-named-readtables))
- (home-page "https://github.com/ahungry/glyphs/";)
- (synopsis "Reduce Common Lisp verbosity")
+ (list sbcl-cl-str sbcl-global-vars sbcl-plump sbcl-tailrec))
+ (home-page
+ "https://github.com/interactive-ssr/client/blob/master/main.org";)
+ (synopsis "The core functionality for ISSR server modules")
(description
- "This library is a little experiment in reducing verbosity in Common
-Lisp, inspired by BODOL (@url{https://github.com/bodil/BODOL}).")
- (license license:gpl3))))
-
-(define-public cl-glyphs
- (sbcl-package->cl-source-package sbcl-glyphs))
-
-(define-public ecl-glyphs
- (sbcl-package->ecl-package sbcl-glyphs))
-
-(define-public sbcl-zs3
- (package
- (name "sbcl-zs3")
- (version "1.3.3")
- (source
- (origin
- (method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/xach/zs3";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name "zs3" version))
- (sha256
- (base32 "186v95wgsj2hkxdw2jl9x1w4fddjclp7arp0rrd9vf5ly8h8sbf3"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-drakma
- sbcl-alexandria
- sbcl-cxml
- sbcl-ironclad
- sbcl-puri
- sbcl-cl-base64))
- (synopsis "Work with Amazon S3 and Amazon CloudFront from Common Lisp")
- (description "This is ZS3, a library for working with Amazon's Simple
Storage
-Service (S3) and CloudFront service from Common Lisp.")
- (home-page "https://github.com/xach/zs3";)
- (license license:bsd-2)))
+ "ISSR core provides functions and variables for ISSR server modules so
+that different servers can behave similarly. The most important features are
+Document Object Model differencing to generate instructions to update a DOM,
+and DOM cleaning, to ensure that all remote DOMs are the same.")
+ (license license:llgpl))))
-(define-public cl-zs3
- (sbcl-package->cl-source-package sbcl-zs3))
+(define-public cl-issr-core
+ (sbcl-package->cl-source-package sbcl-issr-core))
-(define-public ecl-zs3
- (sbcl-package->ecl-package sbcl-zs3))
+(define-public ecl-issr-core
+ (sbcl-package->ecl-package sbcl-issr-core))
-(define-public sbcl-simple-neural-network
+(define-public sbcl-iterate
(package
- (name "sbcl-simple-neural-network")
- (version "3.1")
+ (name "sbcl-iterate")
+ (version "1.5.3")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/simple-neural-network";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "simple-neural-network" version))
+ (url "https://gitlab.common-lisp.net/iterate/iterate.git";)
+ (commit version)))
+ (file-name (git-file-name "cl-iterate" version))
(sha256
- (base32 "1jj1c90fr5clwka0jv32hv6xp1bkdlpa6x5jh19an13rhx8ll4zr"))))
+ (base32 "0l6l8fpgcpwpmi00jwmamxbspbqa8fil6dv11bf9gaxxbw41f8c2"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- `(("chipz" ,sbcl-chipz)
- ("fiveam" ,sbcl-fiveam)))
- (inputs
- `(("cl-store" ,sbcl-cl-store)
- ("lparallel" ,sbcl-lparallel)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'check 'remove-test-data
- (lambda* (#:key outputs #:allow-other-keys)
- (let ((out (assoc-ref outputs "out")))
- (for-each delete-file (find-files out "\\.gz$"))))))))
- (synopsis "Simple neural network in Common Lisp")
- (description
- "@code{simple-neural-network} is a Common Lisp library for creating,
-training and using basic neural networks. The networks created by this
-library are feedforward neural networks trained using backpropagation.")
- (home-page "https://codeberg.org/glv/simple-neural-network";)
- (license license:gpl3+)))
+ (list sbcl-rt))
+ (home-page "https://common-lisp.net/project/iterate/";)
+ (synopsis "Iteration construct for Common Lisp")
+ (description "@code{iterate} is an iteration construct for Common Lisp.
+It is similar to the @code{CL:LOOP} macro, with these distinguishing marks:
-(define-public cl-simple-neural-network
- (sbcl-package->cl-source-package sbcl-simple-neural-network))
+@itemize
+@item it is extensible,
+@item it helps editors like Emacs indent iterate forms by having a more
+ lisp-like syntax, and
+@item it isn't part of the ANSI standard for Common Lisp.
+@end itemize\n")
+ (license license:expat)))
-(define-public ecl-simple-neural-network
- (sbcl-package->ecl-package sbcl-simple-neural-network))
+(define-public cl-iterate
+ (sbcl-package->cl-source-package sbcl-iterate))
-(define-public sbcl-zstd
- (let ((commit "134f058eee11512cf772a8d5b64364acf56a10b8")
+(define-public ecl-iterate
+ (sbcl-package->ecl-package sbcl-iterate))
+
+(define-public sbcl-ixf
+ (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183")
(revision "1"))
(package
- (name "sbcl-zstd")
- (version (git-version "2.0" revision commit))
+ (name "sbcl-ixf")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/cl-zstd";)
+ (url "https://github.com/dimitri/cl-ixf";)
(commit commit)))
- (file-name (git-file-name "cl-zstd" version))
+ (file-name (git-file-name "cl-ixf" version))
(sha256
- (base32 "1iqpi5v6fdm6xxc9l8zhk6kcgl8hgxiwk1ki2yx2j3j4kfvqv8j9"))))
+ (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-cffi
- sbcl-cl-octet-streams
- (list zstd "lib")))
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/libzstd.lisp"
- (("libzstd\\.so")
- (search-input-file inputs "/lib/libzstd.so"))))))))
- (synopsis "Common Lisp library for Zstandard (de)compression")
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cl-ppcre
+ sbcl-ieee-floats
+ sbcl-local-time
+ sbcl-md5
+ sbcl-split-sequence))
+ (home-page "https://github.com/dimitri/cl-ixf";)
+ (synopsis "Parse IBM IXF file format")
(description
- "This Common Lisp library provides functions for Zstandard
-compression/decompression using bindings to the libzstd C library.")
- (home-page "https://codeberg.org/glv/cl-zstd";)
- (license license:gpl3+))))
+ "This is a Common Lisp library to handle the IBM PC version of the IXF
+(Integration Exchange Format) file format.")
+ (license license:public-domain))))
-(define-public cl-zstd
- (sbcl-package->cl-source-package sbcl-zstd))
+(define-public cl-ixf
+ (sbcl-package->cl-source-package sbcl-ixf))
-(define-public ecl-zstd
- (sbcl-package->ecl-package sbcl-zstd))
+(define-public ecl-ixf
+ (sbcl-package->ecl-package sbcl-ixf))
-(define-public sbcl-agnostic-lizard
- (let ((commit "fe1a1d7d80c8b56163754e0e5b3653fd750ad298")
- (revision "2"))
+(define-public sbcl-jonathan
+ (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300")
+ (revision "1"))
(package
- (name "sbcl-agnostic-lizard")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-jonathan")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Rudolph-Miller/jonathan";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove sbcl-legion))
+ (inputs
+ (list sbcl-cl-syntax sbcl-fast-io sbcl-proc-parse sbcl-cl-ppcre))
+ (home-page "https://rudolph-miller.github.io/jonathan/overview.html";)
+ (synopsis "JSON encoder and decoder")
+ (description
+ "High performance JSON encoder and decoder. Currently support: SBCL,
+CCL.")
+ ;; Author specifies the MIT license
+ (license license:expat))))
+
+(define-public cl-jonathan
+ (sbcl-package->cl-source-package sbcl-jonathan))
+
+(define-public ecl-jonathan
+ (sbcl-package->ecl-package sbcl-jonathan))
+
+(define-public sbcl-jpeg-turbo
+ (let ((commit "f79c646cc266c107bdace53572a31664754c6e0c")
+ (revision "1"))
+ (package
+ (name "sbcl-jpeg-turbo")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/mraskin/agnostic-lizard";)
+ (url "https://github.com/shamazmazum/jpeg-turbo/";)
(commit commit)))
- (file-name (git-file-name "cl-agnostic-lizard" version))
+ (file-name (git-file-name "cl-jpeg-turbo" version))
(sha256
- (base32 "0amzshh6v3mp24j0h2cinv4zvdlg4kih04md5biakwhnmcw4j4pr"))))
+ (base32 "1andd1ibbk3224idnpsnrn96flr5d1wm9ja3di57fs04wn577sag"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Almost correct portable code walker for Common Lisp")
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-lib-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/jpeg-turbo.lisp"
+ (("\"libturbojpeg\\.so\\.0\"")
+ (string-append "\""
+ (search-input-file inputs
+
"/lib/libturbojpeg.so")
+ "\""))))))))
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list libjpeg-turbo sbcl-cffi))
+ (synopsis "Common Lisp wrapper for libjpeg-turbo")
(description
- "Agnostic Lizard is a portable implementation of a code walker and in
-particular of the macroexpand-all function (and macro) that makes a best
-effort to be correct while not expecting much beyond what the Common Lisp
-standard requires.
+ "This is a Common Lisp wrapper for libjpeg-turbo library which provides
+TurboJPEG API for compressing and decompressing JPEG images.")
+ (home-page "https://github.com/shamazmazum/jpeg-turbo/";)
+ (license license:bsd-2))))
-It aims to be implementation-agnostic and to climb the syntax trees.")
- (home-page "https://gitlab.common-lisp.net/mraskin/agnostic-lizard";)
- (license license:gpl3+))))
+(define-public cl-jpeg-turbo
+ (sbcl-package->cl-source-package sbcl-jpeg-turbo))
-(define-public cl-agnostic-lizard
- (sbcl-package->cl-source-package sbcl-agnostic-lizard))
+(define-public ecl-jpeg-turbo
+ (sbcl-package->ecl-package sbcl-jpeg-turbo))
-(define-public ecl-agnostic-lizard
- (sbcl-package->ecl-package sbcl-agnostic-lizard))
+(define-public sbcl-jpl-queues
+ (package
+ (name "sbcl-jpl-queues")
+ (version "0.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "http://www.thoughtcrime.us/software/jpl-queues/jpl-queues-";
+ version
+ ".tar.gz"))
+ (sha256
+ (base32
+ "1wvvv7j117h9a42qaj1g4fh4mji28xqs7s60rn6d11gk9jl76h96"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("jpl-util" ,sbcl-jpl-util)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ ;; Tests seem to be broken.
+ `(#:tests? #f))
+ (synopsis "Common Lisp library implementing a few different kinds of
queues")
+ (description
+ "A Common Lisp library implementing a few different kinds of queues:
-(define-public sbcl-dynamic-classes
- (let ((commit "ebd7405603f67b16e8f2bc08ce8e2bcfcf439501")
- (revision "0"))
+@itemize
+@item Bounded and unbounded FIFO queues.
+@item Lossy bounded FIFO queues that drop elements when full.
+@item Unbounded random-order queues that use less memory than unbounded FIFO
queues.
+@end itemize
+
+Additionally, a synchronization wrapper is provided to make any queue
+conforming to the @command{jpl-queues} API thread-safe for lightweight
+multithreading applications. (See Calispel for a more sophisticated CL
+multithreaded message-passing library with timeouts and alternation among
+several blockable channels.)")
+ (home-page "https://www.thoughtcrime.us/software/jpl-queues/";)
+ (license license:isc)))
+
+(define-public cl-jpl-queues
+ (sbcl-package->cl-source-package sbcl-jpl-queues))
+
+(define-public ecl-jpl-queues
+ (sbcl-package->ecl-package sbcl-jpl-queues))
+
+(define-public sbcl-jpl-util
+ (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
(package
- (name "sbcl-dynamic-classes")
- (version (git-version "1.0.2" revision commit))
+ (name "sbcl-jpl-util")
+ (version "20151005")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/dynamic-classes";)
+ ;; Quicklisp uses this fork.
+ (url "https://github.com/hawkir/cl-jpl-util";)
(commit commit)))
- (file-name (git-file-name "dynamic-classes" version))
+ (file-name
+ (git-file-name "jpl-util" version))
(sha256
- (base32 "1k9lkchwyi2xhygp2v8ifq3kg1l3wcnihhzgr06jrivjxgdqpc1a"))))
+ (base32
+ "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("metatilities-base" ,sbcl-metatilities-base)))
- (arguments
- ;; NOTE: (Sharlatan-20210106222900+0000) Circular dependencies and
failing
- ;; test suites. lift-standard.config contains referances to deprecated
- ;; functionality.
- ;; See https://github.com/hraban/dynamic-classes/issues/2
- `(#:tests? #f))
- (home-page "https://common-lisp.net/project/dynamic-classes/";)
- (synopsis "Dynamic class definition for Common Lisp")
- (description "Dynamic-Classes helps to ease the prototyping process by
-bringing dynamism to class definition.")
- (license license:expat))))
+ (synopsis "Collection of Common Lisp utility functions and macros")
+ (description
+ "@command{cl-jpl-util} is a collection of Common Lisp utility functions
+and macros, primarily for software projects written in CL by the author.")
+ (home-page "https://www.thoughtcrime.us/software/cl-jpl-util/";)
+ (license license:isc))))
-(define-public ecl-dynamic-classes
- (sbcl-package->ecl-package sbcl-dynamic-classes))
+(define-public cl-jpl-util
+ (sbcl-package->cl-source-package sbcl-jpl-util))
-(define-public cl-dynamic-classes
- (sbcl-package->cl-source-package sbcl-dynamic-classes))
+(define-public ecl-jpl-util
+ (sbcl-package->ecl-package sbcl-jpl-util))
-(define-public sbcl-cl-markdown
- ;; The latest changes with fixes are not released yet, see
- ;; https://github.com/hraban/cl-markdown/issues/9
- (let ((commit "3788802199228b49d0e06c3feb80c1c22af05cfc")
- (revision "0"))
+(define-public sbcl-json-streams
+ (let ((commit "5da012e8133affbf75024e7500feb37394690752")
+ (revision "1"))
(package
- (name "sbcl-cl-markdown")
- (version (git-version "0.10.6" revision commit))
+ (name "sbcl-json-streams")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/cl-markdown";)
+ (url "https://github.com/rotatef/json-streams";)
(commit commit)))
- (file-name (git-file-name "cl-markdown" version))
+ (file-name (git-file-name "json-streams" version))
(sha256
- (base32 "1algqwmafipyf194cx9wfhg0pdx1ppx6s444p1pm8yaycbsyla1v"))))
+ (base32 "0cia3721im04q73dfkd688d8splgpz03qa4h8s3r39kar4w3xll2"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-lift sbcl-trivial-shell))
- (inputs
- (list sbcl-anaphora
- sbcl-cl-containers
- sbcl-cl-ppcre
- sbcl-dynamic-classes
- sbcl-metabang-bind
- sbcl-metatilities-base))
- (home-page "https://common-lisp.net/project/cl-markdown/";)
- (synopsis "Common Lisp rewrite of Markdown")
+ (list sbcl-cl-quickcheck sbcl-flexi-streams))
+ (home-page "https://github.com/rotatef/json-streams";)
+ (synopsis "Common Lisp library for reading and writing JSON")
(description
- "This is an implementation of a Markdown parser in Common Lisp.")
- (license license:expat))))
+ "This package provides a stream based JSON parser/writer, well suited as
+building block for higher level libraries.")
+ (license license:gpl3+))))
-(define-public ecl-cl-markdown
- (let ((pkg (sbcl-package->ecl-package sbcl-cl-markdown)))
- (package
- (inherit pkg)
- (arguments
- ;; XXX: Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is
- ;; undefined" on ECL.
- ;; See https://github.com/hraban/cl-markdown/issues/11
- '(#:tests? #f)))))
+(define-public cl-json-streams
+ (sbcl-package->cl-source-package sbcl-json-streams))
-(define-public cl-markdown
- (sbcl-package->cl-source-package sbcl-cl-markdown))
+(define-public ecl-json-streams
+ (sbcl-package->ecl-package sbcl-json-streams))
-(define-public sbcl-cl-markless
- (let ((commit "a0e145c03103bd3bf7e275d5ac0e19e8381eb844")
- (revision "1"))
+(define-public sbcl-jsown
+ (let ((commit "744c4407bef58dfa876d9da0b5c0205d869e7977"))
(package
- (name "sbcl-cl-markless")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-jsown")
+ (version (git-version "1.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-markless";)
+ (url "https://github.com/madnificent/jsown";)
(commit commit)))
- (file-name (git-file-name "cl-markless" version))
+ (file-name (git-file-name name commit))
(sha256
- (base32 "154ax1yk0b1035yij29c5pgfn7ifghrxy821mk68wyljg8afgvh5"))))
+ (base32 "0gadvmf1d9bq35s61z76psrsnzwwk12svi66jigf491hv48wigw7"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-3bmd
- sbcl-babel
- sbcl-command-line-arguments
- sbcl-documentation-utils
- sbcl-plump
- sbcl-trivial-gray-streams
- sbcl-trivial-indent
- sbcl-trivial-mimes
- sbcl-zip))
- (arguments
- '(#:asd-systems '("cl-markless"
- "cl-markless-plump"
- "cl-markless-epub"
- "cl-markless-markdown"
- "cl-markless-standalone")))
- (home-page "https://shirakumo.github.io/cl-markless/";)
- (synopsis "Parser implementation for Markless")
- (description "This is an implementation of the \"Markless
-standard\" (@url{https://github.com/shirakumo/markless}) at version 1.0. It
-handles the parsing of plaintext from a stream into an abstract syntax tree
-composed out of strings and component objects. From there the AST can be
-easily compiled into a target markup language like HTML.")
- (license license:zlib))))
+ (home-page "https://github.com/madnificent/jsown";)
+ (synopsis "Fast JSON reader / writer library for Common Lisp")
+ (description
+ "@code{jsown} is a high performance Common Lisp JSON parser. Its aim
+is to allow for the fast parsing of JSON objects in Common Lisp. Recently,
+functions and macros have been added to ease the burden of writing and editing
+@code{jsown} objects.
-(define-public ecl-cl-markless
- (sbcl-package->ecl-package sbcl-cl-markless))
+@code{jsown} allows you to parse JSON objects quickly to a modifiable Lisp
+list and write them back. If you only need partial retrieval of objects,
+@code{jsown} allows you to select the keys which you would like to see parsed.
+@code{jsown} also has a JSON writer and some helper methods to alter the JSON
+objects themselves.")
+ (license license:expat))))
-(define-public cl-markless
- (sbcl-package->cl-source-package sbcl-cl-markless))
+(define-public cl-jsown
+ (sbcl-package->cl-source-package sbcl-jsown))
-(define-public sbcl-magicffi
- (let ((commit "d88f2f280c31f639e4e05be75215d8a8dce6aef2"))
+(define-public ecl-jsown
+ (sbcl-package->ecl-package sbcl-jsown))
+
+(define-public sbcl-just-getopt-parser
+ (package
+ (name "sbcl-just-getopt-parser")
+ (version "2021.11")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tlikonen/cl-just-getopt-parser";)
+ (commit version)))
+ (sha256
+ (base32 "0ngh8b51ngh3bqacl40j6wwiinhwxswsy02d9k7qlzv9sbjxay4s"))
+ (file-name (git-file-name "cl-just-getopt-parser" version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Getopt-like command-line parser for Common Lisp")
+ (description
+ "This package provides the @code{getopt} function to parse command-line
+options. The options are organized in valid options, other arguments and
+unknown arguments. Optional Lisp conditions for error situations are also
+defined.")
+ (home-page "https://github.com/tlikonen/cl-just-getopt-parser";)
+ (license license:cc0)))
+
+(define-public cl-just-getopt-parser
+ (sbcl-package->cl-source-package sbcl-just-getopt-parser))
+
+(define-public ecl-just-getopt-parser
+ (sbcl-package->ecl-package sbcl-just-getopt-parser))
+
+(define-public sbcl-jzon
+ (package
+ (name "sbcl-jzon")
+ (version "1.1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Zulu-Inuoe/jzon";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-jzon" version))
+ (sha256
+ (base32 "0rbardn1dfizpyyy1c127zzk1fnq4pslz75xa7ldpfjsi5jc5fmr"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("com.inuoe.jzon")
+ #:asd-test-systems '("com.inuoe.jzon-tests")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-test-asd
+ (lambda _
+ (substitute* "test/com.inuoe.jzon-tests.asd"
+ ((":depends-on")
+ (string-append
+ ":perform (test-op (op c) (symbol-call :fiveam :run!"
+ " (find-symbol \"JZON\" :com.inuoe.jzon-tests)))"
+ "\n"
+ " :depends-on"))))))))
+ (native-inputs
+ (list sbcl-alexandria
+ sbcl-fiveam))
+ (inputs
+ (list sbcl-closer-mop
+ sbcl-flexi-streams
+ sbcl-float-features
+ sbcl-trivial-gray-streams))
+ (home-page "https://github.com/Zulu-Inuoe/jzon/";)
+ (synopsis "Correct and safe JSON parser")
+ (description
+ "@code{jzon} is a correct and safe JSON RFC 8259 parser for Common Lisp.")
+ (license license:expat)))
+
+(define-public cl-jzon
+ (sbcl-package->cl-source-package sbcl-jzon))
+
+(define-public ecl-jzon
+ (sbcl-package->ecl-package sbcl-jzon))
+
+(define-public sbcl-kdlcl
+ (let ((commit "dd4a48a3473c3c8fb34d4a37f87d6a1776c5875c")
+ (revision "0"))
(package
- (name "sbcl-magicffi")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-kdlcl")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dochang/magicffi/";)
+ (url "https://github.com/chee/kdlcl";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-kdlcl" version))
(sha256
- (base32 "0p6ysa92fk34bhxpw7bycbfgw150fv11z9x8jr9xb4lh8cm2hvp6"))))
+ (base32 "0bqqxkd6s420ld2hmhvbbvpzss0m2kimmxaqhz7j1ksmq86bvvmj"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria))
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("ppcre" ,sbcl-cl-ppcre)
- ("libmagic" ,file)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((magic (assoc-ref inputs "libmagic")))
- (substitute* "grovel.lisp"
- (("/usr/include/magic.h")
- (string-append magic "/include/magic.h")))
- (substitute* "api.lisp"
- ((":default \"libmagic\"" all)
- (string-append ":default \"" magic
"/lib/libmagic\"")))))))))
- (home-page "https://common-lisp.net/project/magicffi/";)
- (synopsis "Common Lisp interface to libmagic based on CFFI")
- (description
- "MAGICFFI is a Common Lisp CFFI interface to libmagic(3), the file type
-determination library using @emph{magic} numbers.")
- (license license:bsd-2))))
+ (arguments `(#:asd-systems '("kdl")))
+ (inputs (list sbcl-esrap sbcl-parse-number))
+ (home-page "https://github.com/chee/kdlcl/";)
+ (synopsis "KDL reader/printer for Common Lisp")
+ (description "This package provides a KDL reader/writer for
+ Common Lisp.")
+ (license license:expat-0))))
-(define-public ecl-magicffi
- (sbcl-package->ecl-package sbcl-magicffi))
+(define-public cl-kdlcl
+ (sbcl-package->cl-source-package sbcl-kdlcl))
-(define-public cl-magicffi
- (sbcl-package->cl-source-package sbcl-magicffi))
+(define-public ecl-kdlcl
+ (sbcl-package->ecl-package sbcl-kdlcl))
-(define-public sbcl-shlex
- (let ((commit "3dee1cb7c0140fa7660ca7a3b2ac5e75d1218e5c")
- (revision "2"))
+(define-public sbcl-kebab
+ (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b")
+ (revision "1"))
(package
- (name "sbcl-shlex")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-kebab")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/pocket7878/kebab";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/cl-shlex";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-shlex" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "16ag48sswgimr1fzr582vhym4s03idpd4lkydw5s58lv80ibpim8"))))
+ (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-serapeum sbcl-cl-ppcre sbcl-cl-unicode))
- (home-page "https://github.com/ruricolist/cl-shlex";)
- (synopsis "Common Lisp lexical analyzer for shell-like syntaxes")
- (description
- "This library contains a lexer for syntaxes that use shell-like rules
-for quoting and commenting. It is a port of the @code{shlex} module from
Python’s
-standard library.")
- (license license:expat))))
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("alexandria" ,sbcl-alexandria)
+ ("cl-interpol" ,sbcl-cl-interpol)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (native-inputs
+ (list sbcl-prove))
+ (arguments
+ ;; Tests passes but the phase fails with
+ ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #<SYSTEM
"kebab">.
+ `(#:tests? #f))
+ (synopsis "Common Lisp case converter")
+ (description "This Common Lisp library converts strings, symbols and
+keywords between any of the following typographical cases: PascalCase,
+camelCase, snake_case, kebab-case (lisp-case).")
+ (license license:llgpl))))
-(define-public ecl-shlex
- (sbcl-package->ecl-package sbcl-shlex))
+(define-public cl-kebab
+ (sbcl-package->cl-source-package sbcl-kebab))
-(define-public cl-shlex
- (sbcl-package->cl-source-package sbcl-shlex))
+(define-public ecl-kebab
+ (sbcl-package->ecl-package sbcl-kebab))
-(define-public sbcl-cmd
- (let ((commit "0164d574ba236e2001ee1d9dba3f4774c7512a8c")
- (revision "8"))
+(define-public sbcl-kmrcl
+ (let ((version "1.111")
+ (commit "4a27407aad9deb607ffb8847630cde3d041ea25a")
+ (revision "1"))
(package
- (name "sbcl-cmd")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-kmrcl")
+ (version (git-version version revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/cmd/";)
+ (url "http://git.kpe.io/kmrcl.git/";)
(commit commit)))
- (file-name (git-file-name "cl-cmd" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "03wbckzmz6pqdlz7pyar6nfg4vs4bl0b2np7n3kk3qhjbrdakc4m"))))
+ (base32 "06gx04mah5nc8w78s0j8628divbf1s5w7af8w7pvzb2d5mgvrbd2"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The useless bundled debian folder drags `make' into the closure.
+ `(begin
+ (delete-file-recursively "debian")
+ #t))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((bin (string-append (assoc-ref inputs "coreutils")
- "/bin"))
- (ps-bin (string-append (assoc-ref inputs "procps")
- "/bin")))
- (substitute* "cmd.lisp"
- (("\\(def \\+env\\+ \"env\"\\)")
- (format #f "(def +env+ \"~a/env\")" bin))
- (("\\(def \\+kill\\+ \"kill\"\\)")
- (format #f "(def +kill+ \"~a/kill\")" bin))
- (("\\(def \\+ps\\+ \"ps\"\\)")
- (format #f "(def +ps+ \"~a/ps\")" ps-bin))
- (("\\(def \\+pwd\\+ \"pwd\"\\)")
- (format #f "(def +pwd+ \"~a/pwd\")" bin))
- (("\\(def \\+sh\\+ \"/bin/sh\"\\)")
- (format #f "(def +sh+ \"~a\")" (which "sh")))
- (("\\(def \\+tr\\+ \"tr\"\\)")
- (format #f "(def +tr+ \"~a/tr\")" bin)))))))))
(inputs
- (list coreutils
- procps
- sbcl-alexandria
- sbcl-serapeum
- sbcl-shlex
- sbcl-trivia))
- (home-page "https://github.com/ruricolist/cmd";)
- (synopsis "Conveniently run external programs from Common Lisp")
+ (list sbcl-rt))
+ (home-page "http://files.kpe.io/kmrcl/";)
+ (synopsis "General utilities for Common Lisp programs")
(description
- "A utility for running external programs, built on UIOP.
-Cmd is designed to be natural to use, protect against shell interpolation and
-be usable from multi-threaded programs.")
- (license license:expat))))
+ "KMRCL is a collection of utilities used by a number of Kevin
+Rosenberg's Common Lisp packages.")
+ (license license:llgpl))))
-(define-public ecl-cmd
- (sbcl-package->ecl-package sbcl-cmd))
+(define-public cl-kmrcl
+ (sbcl-package->cl-source-package sbcl-kmrcl))
-(define-public cl-cmd
- (sbcl-package->cl-source-package sbcl-cmd))
+(define-public ecl-kmrcl
+ (sbcl-package->ecl-package sbcl-kmrcl))
-(define-public sbcl-ppath
- (let ((commit "eb1a8173b4d1d691ea9a7699412123462f58c3ce"))
+(define-public sbcl-kons-9
+ (let ((commit "fe0b3228ca28c316457d35f9e7c67edc83b2a4cc")
+ (revision "0"))
(package
- (name "sbcl-ppath")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-kons-9")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fourier/ppath/";)
+ (url "https://github.com/kaveh808/kons-9";)
(commit commit)))
- (file-name (git-file-name name commit))
+ (file-name (git-file-name "cl-kons-9" version))
(sha256
- (base32 "1c46q9lmzqv14z80d3fwdawgn3pn4922x31fyqvsvbcjm4hd16fb"))))
+ (base32 "1kdwva4qj1s5vmbv6gbmpnk56ahaf8n2kvij5xjlfyk7nriy4bbi"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("kons-9")
+ #:asd-test-systems '("kons-9/testsuite")))
+ (native-inputs
+ (list sbcl-alexandria sbcl-confidence))
(inputs
- (list sbcl-alexandria
+ (list sbcl-closer-mop
sbcl-cffi
- sbcl-osicat
- sbcl-cl-ppcre
- sbcl-split-sequence
- sbcl-trivial-features))
- (native-inputs
- (list sbcl-cl-fad sbcl-prove))
- (home-page "https://github.com/fourier/ppath";)
- (synopsis "Common Lisp's implementation of the Python's os.path module")
+ sbcl-cl-glfw3
+ sbcl-cl-opengl
+ sbcl-cl-vectors
+ sbcl-clobber
+ sbcl-origin
+ sbcl-trivial-backtrace
+ sbcl-trivial-main-thread
+ sbcl-zpb-ttf))
+ (home-page "https://github.com/kaveh808/kons-9";)
+ (synopsis "Common Lisp 3D graphics system")
(description
- "This library is a path strings manipulation library inspired by
-Python's @code{os.path}. All functionality from @code{os.path} is supported on
-major operation systems.
-
-The philosophy behind is to use simple strings and \"dumb\" string
-manipulation functions to handle paths and filenames. Where possible the
-corresponding OS system functions are called.")
- (license license:bsd-2))))
+ "This package provides KONS-9 which can be considered as a traditional
user
+interface driven 3D application for general artists, or as a REPL-based
+development environment for technical artists and software developers. These
two
+approaches can be seamlessly combined into a flexible and powerful workflow,
+where non-technical users can immediately benefit from software tools and
+extensions developed by technical users.")
+ (license (list license:expat
+ ;; lib/JMC-font-libs/font-master
+ ;; lib/JMC-font-libs/font-zpb-ttf-master
+ license:lgpl2.1)))))
-(define-public ecl-ppath
- (sbcl-package->ecl-package sbcl-ppath))
+(define-public cl-kons-9
+ (sbcl-package->cl-source-package sbcl-kons-9))
-(define-public cl-ppath
- (sbcl-package->cl-source-package sbcl-ppath))
+;; TODO: (Sharlatan-20221110T230620+0000): ECL is not supported yet.
+;; https://github.com/kaveh808/kons-9/issues/176
+;; (define-public ecl-kons-9
+;; (sbcl-package->ecl-package sbcl-kons-9))
-(define-public sbcl-trivial-escapes
- (let ((commit "1eca78da2078495d09893be58c28b3aa7b8cc4d1"))
+(define-public sbcl-lack
+ (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+ (revision "1"))
(package
- (name "sbcl-trivial-escapes")
- (version (git-version "1.2.0" "1" commit))
+ (name "sbcl-lack")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/williamyaoh/trivial-escapes";)
+ (url "https://github.com/fukamachi/lack";)
(commit commit)))
- (file-name (git-file-name name commit))
+ (file-name (git-file-name "lack" version))
(sha256
- (base32 "0v6h8lk17iqv1qkxgqjyzn8gi6v0hvq2vmfbb01md3zjvjqxn6lr"))))
+ (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-named-readtables))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/williamyaoh/trivial-escapes";)
- (synopsis "C-style escape directives for Common Lisp")
+ (list sbcl-prove))
+ (inputs
+ `(("circular-streams" ,sbcl-circular-streams)
+ ("http-body" ,sbcl-http-body)
+ ("ironclad" ,sbcl-ironclad)
+ ("local-time" ,sbcl-local-time)
+ ("quri" ,sbcl-quri)
+ ("trivial-mimes" ,sbcl-trivial-mimes)))
+ (arguments
+ '(#:asd-systems '("lack"
+ "lack-request"
+ "lack-response"
+ "lack-component"
+ "lack-util"
+ "lack-middleware-backtrace"
+ "lack-middleware-static")
+ ;; XXX: Component :CLACK not found
+ #:tests? #f))
+ (home-page "https://github.com/fukamachi/lack";)
+ (synopsis "Lack, the core of Clack")
(description
- "This Common Lisp library interprets escape characters the same way that
-most other programming language do.
-It provides four readtables. The default one lets you write strings like this:
-@code{#\"This string has\na newline in it!\"}.")
- (license license:public-domain))))
+ "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 ecl-trivial-escapes
- (sbcl-package->ecl-package sbcl-trivial-escapes))
+(define-public cl-lack
+ (sbcl-package->cl-source-package sbcl-lack))
-(define-public cl-trivial-escapes
- (sbcl-package->cl-source-package sbcl-trivial-escapes))
+(define-public ecl-lack
+ (sbcl-package->ecl-package sbcl-lack))
-(define-public sbcl-trivial-extensible-sequences
- (let ((commit "d40b2da23716601578b1f645727047f80baeb49a")
- (revision "0"))
+(define-public sbcl-lambda-fiddle
+ (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch
+ (revision "1"))
(package
- (name "sbcl-trivial-extensible-sequences")
+ (name "sbcl-lambda-fiddle")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/trivial-extensible-sequences";)
+ (url "https://github.com/Shinmera/lambda-fiddle";)
(commit commit)))
- (file-name (git-file-name "cl-trivial-extensible-sequences" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0352psdd8j0phjycr6ldckwspyal4jcf0f2fizi6fwdp7nvadng7"))))
+ (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://shinmera.github.io/trivial-extensible-sequences/";)
- (synopsis "Portability library for the extensible sequences protocol")
- (description
- "This package provides a portability layer for the extensible sequences
-standard extension to Common Lisp. Extensible sequences allow you to create
-your own sequence types that integrate with the rest of the functions and
-operations that interact with sequences.")
+ (home-page "https://github.com/Shinmera/lambda-fiddle";)
+ (synopsis "Collection of utilities to process lambda-lists")
+ (description "This collection of utilities is useful in contexts where
+you want a macro that uses lambda-lists in some fashion but need more precise
+processing.")
(license license:zlib))))
-;; NOTE: (Sharlatan-20230312T215058+0000): ECL is not supported
-;; (define-public ecl-trivial-extensible-sequences
-;; (sbcl-package->ecl-package sbcl-trivial-extensible-sequences))
+(define-public cl-lambda-fiddle
+ (sbcl-package->cl-source-package sbcl-lambda-fiddle))
-(define-public cl-trivial-extensible-sequences
- (sbcl-package->cl-source-package sbcl-trivial-extensible-sequences))
+(define-public ecl-lambda-fiddle
+ (sbcl-package->ecl-package sbcl-lambda-fiddle))
-(define-public sbcl-cl-indentify
- (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53"))
+(define-public sbcl-language-codes
+ (let ((commit "e7aa0e37cb97a3d37d6bc7316b479d01bff8f42e"))
(package
- (name "sbcl-cl-indentify")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-language-codes")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/yitzchak/cl-indentify";)
+ (url "https://github.com/Shinmera/language-codes";)
(commit commit)))
(file-name (git-file-name name commit))
(sha256
- (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p"))))
+ (base32 "0py176ibmsc01n5r0q1bs1ykqf5jwdbh8kx0j1a814l9y51241v0"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-command-line-arguments
- sbcl-trivial-gray-streams))
- (native-inputs
- (list sbcl-trivial-escapes sbcl-rove))
- (home-page "https://github.com/yitzchak/cl-indentify";)
- (synopsis "Code beautifier for Common Lisp")
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/language-codes/";)
+ (synopsis "Map ISO language codes to language names in Common Lisp")
(description
- "A library and command line utility to automatically indent Common Lisp
-source files.")
- (license license:expat))))
+ "This is a small library providing the ISO-639 language code to
+language name mapping.")
+ (license license:zlib))))
-(define-public ecl-cl-indentify
- (sbcl-package->ecl-package sbcl-cl-indentify))
+(define-public cl-language-codes
+ (sbcl-package->cl-source-package sbcl-language-codes))
-(define-public cl-indentify
- (sbcl-package->cl-source-package sbcl-cl-indentify))
+(define-public ecl-language-codes
+ (sbcl-package->ecl-package sbcl-language-codes))
-(define-public sbcl-concrete-syntax-tree
- (let ((commit "37291727196a3bc88a7be67c1427c52078d4b82c")
+(define-public sbcl-langutils
+ (let ((commit "38beec7a82eeb35b0bfb0824a41d13ed94fc648b")
(revision "0"))
(package
- (name "sbcl-concrete-syntax-tree")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-langutils")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/s-expressionists/Concrete-Syntax-Tree";)
+ (url "https://github.com/eslick/cl-langutils";)
(commit commit)))
- (file-name (git-file-name "cl-concrete-syntax-tree" commit))
+ (file-name (git-file-name "cl-langutils" version))
(sha256
- (base32 "15q9jyqsh2z921li9my8c840cj2ci7k217x5frfiyk0kymkx4rgv"))))
+ (base32 "15y9x5wkg3fqndc04w2sc650fnwimxp4gjgpv9xvvdm9x4v433x6"))))
(build-system asdf-build-system/sbcl)
+ (arguments '(#:tests? #f)) ; There are no tests.
(inputs
- (list sbcl-acclimation))
- (arguments
- '(#:asd-systems '("concrete-syntax-tree"
- "concrete-syntax-tree-destructuring"
- "concrete-syntax-tree-source-info")))
- (home-page "https://github.com/s-expressionists/Concrete-Syntax-Tree";)
- (synopsis "Parse Common Lisp code into a concrete syntax tree")
+ (list sbcl-stdutils
+ sbcl-s-xml-rpc))
+ (home-page "https://langutils.common-lisp.dev/";)
+ (synopsis "Common Lisp natural language processing toolkit")
(description
- "This library is intended to solve the problem of source tracking for
-Common Lisp code.
-
-By \"source tracking\", it is meant that code elements that have a known
-origin in the form of a position in a file or in an editor buffer are
-associated with some kind of information about this origin.
-
-Since the exact nature of such origin information depends on the Common Lisp
-implementation and the purpose of wanting to track that origin, the library
-does not impose a particular structure of this information. Instead, it
-provides utilities for manipulating source code in the form of what is called
-concrete syntax trees (CSTs for short) that preserve this information about
-the origin.")
- (license license:bsd-2))))
+ "This package provides a hierarchy of major functions and auxiliary
+functions related to the structured analysis and processing of open
+text.")
+ (license license:bsd-3))))
-(define-public ecl-concrete-syntax-tree
- (sbcl-package->ecl-package sbcl-concrete-syntax-tree))
+(define-public cl-langutils
+ (sbcl-package->cl-source-package sbcl-langutils))
-(define-public cl-concrete-syntax-tree
- (sbcl-package->cl-source-package sbcl-concrete-syntax-tree))
+(define-public ecl-langutils
+ (sbcl-package->ecl-package sbcl-langutils))
-(define-public sbcl-eclector
- (let ((commit "d499b09142c7e39b4ef52e821fa767d5a8d606a0")
- (revision "0"))
+(define-public sbcl-lass
+ (let ((commit "1f2418dbf2d8d6f5892171057616b2ca9d6e5008")
+ (revision "1"))
(package
- (name "sbcl-eclector")
- (version (git-version "0.9.0" revision commit))
+ (name "sbcl-lass")
+ (version (git-version "0.6.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/s-expressionists/Eclector";)
- (commit commit)))
- (file-name (git-file-name "cl-eclector" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/LASS";)
+ (commit commit)))
+ (file-name (git-file-name "cl-lass" version))
(sha256
- (base32 "1sg8wmdpm8pcjwk394way5vs2ya3r995lddmi51q9zfn9hmzb7gn"))))
+ (base32 "1wax2kykc9ff0sk2linp9v8fcsm5ay6idpq365vivady9fh504r5"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-acclimation
- sbcl-alexandria
- sbcl-closer-mop
- sbcl-concrete-syntax-tree))
- (arguments
- '(#:asd-systems '("eclector"
- "eclector-concrete-syntax-tree")))
- (home-page "https://s-expressionists.github.io/Eclector/";)
- (synopsis "Highly customizable, portable Common Lisp reader")
+ (list sbcl-cl-base64 sbcl-trivial-indent sbcl-trivial-mimes))
+ (synopsis "LASS (Lisp Augmented Style Sheets) compiles Lisp to CSS")
(description
- "Eclector is a portable Common Lisp reader that is highly customizable,
-can recover from errors and can return concrete syntax trees.
+ "With lispy syntax, shortcuts, and improvements, LASS aims to help you
+out in writing CSS quick and easy. LASS was largely inspired by SASS. LASS
+supports two modes, one being directly in your lisp code, the other in pure
+LASS files.")
+ (home-page "https://shinmera.github.io/LASS/";)
+ (license license:zlib))))
-In contrast to many other reader implementations, eclector can recover from
-most errors in the input supplied to it and continue reading. This capability
-is realized as a restart.
+(define-public cl-lass
+ (sbcl-package->cl-source-package sbcl-lass))
-It can also produce instances of the concrete syntax tree classes provided by
-the concrete syntax tree library.")
- (license license:bsd-2))))
+(define-public ecl-lass
+ (sbcl-package->ecl-package sbcl-lass))
-(define-public ecl-eclector
- (sbcl-package->ecl-package sbcl-eclector))
+(define-public sbcl-legion
+ (let ((commit "599cca19f0e34246814621f7fe90322221c2e263")
+ (revision "1"))
+ (package
+ (name "sbcl-legion")
+ (version (git-version "0.1.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/legion/";)
+ (commit commit)))
+ (file-name (git-file-name "cl-legion" version))
+ (sha256
+ (base32 "0583pw0mf8bd4dj42w2xrlzcwfkl8q28n1bh8dpxxfg93crx4si6"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove sbcl-local-time))
+ (inputs
+ (list
+ sbcl-bordeaux-threads
+ sbcl-cl-speedy-queue
+ sbcl-vom))
+ (home-page "https://github.com/fukamachi/legion";)
+ (synopsis "Simple multithreading worker mechanism for Common Lisp")
+ (description
+ "This library provides a simple multithreading worker mechanism.")
+ (license license:bsd-3))))
-(define-public cl-eclector
- (sbcl-package->cl-source-package sbcl-eclector))
+(define-public cl-legion
+ (sbcl-package->cl-source-package sbcl-legion))
-(define-public sbcl-trucler
- (let ((commit "d40ff965520cbccf4980b7e7e3122912a11f24ad")
- (revision "1"))
+(define-public ecl-legion
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-legion))
+ (arguments
+ ;; Tests get stuck forever
+ (list #:tests? #f))))
+
+(define-public sbcl-legit
+ (let ((commit "9c677b9b798803d37ab6f5e0e0705441872f7230")
+ (revision "3"))
(package
- (name "sbcl-trucler")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-legit")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/s-expressionists/Trucler";)
+ (url "https://github.com/Shinmera/legit";)
(commit commit)))
- (file-name (git-file-name "cl-trucler" commit))
+ (file-name (git-file-name "cl-legit" version))
(sha256
- (base32 "0a0zi7q88j31n0b17yfxb66xjvvridgqr4vr6z3pgnm9wha990a6"))))
+ (base32 "0jy021ywrbnkgbgb63ip6j7kr40m4wz2pz1v5ybn6xkkn6dyprsz"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-acclimation))
(arguments
- '(#:asd-systems '("trucler"
- "trucler-base"
- "trucler-native"
- "trucler-reference")))
- (home-page "https://github.com/s-expressionists/Trucler";)
- (synopsis "Environment protocol for Common Lisp compilers")
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-git-executable
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "process.lisp"
+ (("\"git")
+ (string-append "\"" (search-input-file inputs
+ "/bin/git")))))))))
+ (inputs
+ (list git
+ sbcl-cl-ppcre
+ sbcl-documentation-utils
+ sbcl-lambda-fiddle
+ sbcl-simple-inferiors))
+ (home-page "https://shinmera.github.io/legit/";)
+ (synopsis "Interface to the git binary")
(description
- "Trucler defines a CLOS-based protocol to be used by Common Lisp
-compilers for environment query and update. In addition, library authors can
-use the @code{trucler-native} interface to inspect native environments.
-Trucler supports introspection for variables, functions, tags, blocks and
-optimization policies.")
- (license license:bsd-2))))
+ "This is an interface to the @code{git} binary to make controlling it
+from within Common Lisp much easier. It might not ever reach full coverage of
+all features given git's immense size, but features will be added as they are
+needed. The low-level command API is fully mapped however.")
+ (license license:zlib))))
-(define-public cl-trucler
- (sbcl-package->cl-source-package sbcl-trucler))
+(define-public cl-legit
+ (sbcl-package->cl-source-package sbcl-legit))
-(define-public ecl-trucler
- (sbcl-package->ecl-package sbcl-trucler))
+(define-public ecl-legit
+ (sbcl-package->ecl-package sbcl-legit))
-(define-public sbcl-incless
- (let ((commit "395accf484ffdff70f20b941f322e8329c585ca7")
- (revision "0"))
+(define-public sbcl-let-over-lambda
+ (let ((commit "481b2e3ab4646186451dfdd2062113203287d520")
+ (revision "1"))
(package
- (name "sbcl-incless")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-let-over-lambda")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/s-expressionists/Incless";)
+ (url "https://github.com/thephoeron/let-over-lambda";)
(commit commit)))
- (file-name (git-file-name "cl-incless" commit))
+ (file-name (git-file-name "cl-let-over-lambda" version))
(sha256
- (base32 "14bkb5zx8xq6wv6dsqi041dwq9scvw3kdjlnkfs2ndazj0rb2a1k"))))
+ (base32 "114p781lwi9lrbzg27dnkymz9m4cvm1k430j7qsykwd0b58d8qbk"))))
(build-system asdf-build-system/sbcl)
- (inputs (list sbcl-alexandria))
- ;; See https://github.com/s-expressionists/Incless/issues/6
- (arguments '(#:asd-systems '("incless")))
- (home-page "https://github.com/s-expressionists/incless";)
- (synopsis "Implements print-object methods for many standard classes")
+ (arguments
+ ;; All test cases pass, but tests successfully fail at the end:
+ ;;
+ ;; Summary:
+ ;; All 1 file passed.
+ ;; Unhandled ASDF/FIND-COMPONENT:MISSING-DEPENDENCY in thread
+ ;; #<SB-THREAD:THREAD "main thread" RUNNING {1001860103}>:
+ ;; Component LET-OVER-LAMBDA-ASD::LET-OVER-LAMBDA-TEST not found,
+ ;; required by #<SYSTEM "let-over-lambda">
+ `(#:tests? #f))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (native-inputs
+ (list sbcl-prove))
+ (home-page "https://github.com/thephoeron/let-over-lambda";)
+ (synopsis "Macros from Let Over Lambda")
(description
- "@code{cl-incless} implements print-object methods for many standard
-classes.")
- (license license:bsd-2))))
+ "This package provides Doug Hoyte's \"Production\" version of macros
+from the Let Over Lambda book, including community updates.")
+ (license license:bsd-3))))
-(define-public ecl-incless
- (sbcl-package->ecl-package sbcl-incless))
+(define-public cl-let-over-lambda
+ (sbcl-package->cl-source-package sbcl-let-over-lambda))
-(define-public cl-incless
- (sbcl-package->cl-source-package sbcl-incless))
+(define-public ecl-let-over-lambda
+ (sbcl-package->ecl-package sbcl-let-over-lambda))
-(define-public sbcl-jsown
- (let ((commit "744c4407bef58dfa876d9da0b5c0205d869e7977"))
+(define-public sbcl-let-plus
+ (let ((commit "455e657e077235829b197f7ccafd596fcda69e30")
+ (revision "2"))
(package
- (name "sbcl-jsown")
- (version (git-version "1.0.1" "1" commit))
+ (name "sbcl-let-plus")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/madnificent/jsown";)
+ (url "https://github.com/sharplispers/let-plus";)
(commit commit)))
- (file-name (git-file-name name commit))
(sha256
- (base32 "0gadvmf1d9bq35s61z76psrsnzwwk12svi66jigf491hv48wigw7"))))
+ (base32 "00c0nq6l4zb692rzsc9aliqzj3avrssfyz4bhxzl7f1jsz3m29jb"))
+ (file-name (git-file-name "cl-let-plus" version))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/madnificent/jsown";)
- (synopsis "Fast JSON reader / writer library for Common Lisp")
+ (inputs
+ (list sbcl-alexandria sbcl-anaphora))
+ (native-inputs
+ (list sbcl-lift))
+ (synopsis "Destructuring extension of let*")
(description
- "@code{jsown} is a high performance Common Lisp JSON parser. Its aim
-is to allow for the fast parsing of JSON objects in Common Lisp. Recently,
-functions and macros have been added to ease the burden of writing and editing
-@code{jsown} objects.
+ "This library implements the let+ macro, which is a dectructuring
+extension of let*. It features:
-@code{jsown} allows you to parse JSON objects quickly to a modifiable Lisp
-list and write them back. If you only need partial retrieval of objects,
-@code{jsown} allows you to select the keys which you would like to see parsed.
-@code{jsown} also has a JSON writer and some helper methods to alter the JSON
-objects themselves.")
- (license license:expat))))
+@itemize
+@item Clean, consistent syntax and small implementation (less than 300 LOC,
+not counting tests)
+@item Placeholder macros allow editor hints and syntax highlighting
+@item @command{&ign} for ignored values (in forms where that makes sense)
+@item Very easy to extend
+@end itemize\n")
+ (home-page "https://github.com/sharplispers/let-plus";)
+ (license license:boost1.0))))
-(define-public ecl-jsown
- (sbcl-package->ecl-package sbcl-jsown))
+(define-public cl-let-plus
+ (sbcl-package->cl-source-package sbcl-let-plus))
-(define-public cl-jsown
- (sbcl-package->cl-source-package sbcl-jsown))
+(define-public ecl-let-plus
+ (sbcl-package->ecl-package sbcl-let-plus))
-(define-public sbcl-clostrum
- (let ((commit "c85d38bde9d093f1f132574e9b98b8d64683cd51")
- (revision "0"))
+(define-public sbcl-lev
+ (let ((commit "7d03c68dad44f1cc4ac2aeeab2d24eb525ad941a")
+ (revision "1"))
(package
- (name "sbcl-clostrum")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-lev")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/s-expressionists/Clostrum";)
+ (url "https://github.com/fukamachi/lev";)
(commit commit)))
- (file-name (git-file-name "cl-clostrum" commit))
+ (file-name (git-file-name "lev" version))
(sha256
- (base32 "10alsdnpzbgic75xghwjp414sqwg4npvp69zn0r4l8ms0ki9zr1x"))))
+ (base32 "14lfnrvfyg2nnvlwck896p6vgarzc6g4kijmvhi2d8wra7gxzifh"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (home-page "https://github.com/s-expressionists/Clostrum";)
- (synopsis "First Class Global Environments")
- (description
- "This package provides first-class global environments for
-Common Lisp.")
+ (arguments
+ ;; NOTE: (Sharlatan-20210520T163300+0100): No tests in upstream
+ `(#:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-libev-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/lev.lisp"
+ (("libev.so" _)
+ (search-input-file inputs "/lib/libev.so"))))))))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("libev" ,libev)))
+ (home-page "https://github.com/fukamachi/lev";)
+ (synopsis "Common Lisp bindings for libev")
+ (description "This package provides Common Lisp bindings for libev.")
(license license:bsd-2))))
-(define-public ecl-clostrum
- (sbcl-package->ecl-package sbcl-clostrum))
+(define-public cl-lev
+ (sbcl-package->cl-source-package sbcl-lev))
-(define-public cl-clostrum
- (sbcl-package->cl-source-package sbcl-clostrum))
+(define-public ecl-lev
+ (sbcl-package->ecl-package sbcl-lev))
-(define-public sbcl-system-locale
- (let ((commit "4b334bc2fa45651bcaa28ae7d9331095d6bf0a17"))
+(define-public sbcl-linedit
+ (let ((commit "0561c97dfca2f5854fcc66558a567a9875ddcb8f")
+ (revision "1"))
(package
- (name "sbcl-system-locale")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-linedit")
+ (version (git-version "0.17.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/system-locale/";)
+ (url "https://github.com/sharplispers/linedit";)
(commit commit)))
- (file-name (git-file-name name commit))
+ (file-name (git-file-name "cl-linedit" version))
(sha256
- (base32 "00p5c053kmgq4ks6l9mxsqz6g3bjcybvkvj0bh3r90qgpkaawm1p"))))
+ (base32 "0hhh7xn6q12rviayfihg1ym6x6csa0pdjgb88ykqbrz2rs3pgpz5"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/system-locale/";)
- (synopsis "Get the system's locale and language settings in Common Lisp")
+ (list sbcl-alexandria sbcl-cffi sbcl-osicat sbcl-terminfo))
+ (home-page "https://github.com/sharplispers/linedit";)
+ (synopsis "Readline-style line-editor for Common Lisp")
(description
- "This library retrieves locale information configured on the
-system. This is helpful if you want to write applications and libraries that
-display messages in the user's native language.")
- (license license:zlib))))
+ "Linedit is a readline-style library written in Common Lisp that
+provides customizable line-editing for Common Lisp programs.")
+ (license license:expat))))
-(define-public ecl-system-locale
- (sbcl-package->ecl-package sbcl-system-locale))
+(define-public cl-linedit
+ (sbcl-package->cl-source-package sbcl-linedit))
-(define-public cl-system-locale
- (sbcl-package->cl-source-package sbcl-system-locale))
+(define-public ecl-linedit
+ (sbcl-package->ecl-package sbcl-linedit))
-(define-public sbcl-cluster
- (let ((commit "b040e97578f3027d7d8c7652c74917726574c43e")
- (revision "0"))
+(define-public sbcl-lisp-namespace
+ (let ((commit "699fccb6727027343bb5fca69162a3113996edfc")
+ (revision "2"))
(package
- (name "sbcl-cluster")
- (version (git-version "0.0.0" revision commit))
+ (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 "https://github.com/robert-strandh/Cluster";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-cluster" commit))
+ (file-name (git-file-name "cl-lisp-namespace" version))
(sha256
- (base32 "0ixbr3wm7d3m8mgzasd95rxvs9kip6ngr5s1zk7j3604mcfssqyi"))))
- (build-system asdf-build-system/sbcl)
+ (base32 "1p5db9mab4whapy1pl38ajw5fkrrdw266n05mnhf4xx2fb9sbx6p"))))
(inputs
- (list sbcl-acclimation
- sbcl-split-sequence))
- (home-page "https://github.com/robert-strandh/Cluster";)
- (synopsis "Assembler with input in the form of standard instances")
- (description
- "Cluster is an assembler (initially for x86 and x86-64) with a
difference.
-To avoid the issue of defining a syntax, the input to Cluster is a list
-of standard objects (i.e., instances of the class STANDARD-OBJECT),
-as opposed to a character file or S-expressions.")
- (license license:bsd-2))))
+ (list sbcl-alexandria))
+ (native-inputs
+ (list sbcl-fiveam))
+ (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 ecl-cluster
- (sbcl-package->ecl-package sbcl-cluster))
+(define-public cl-lisp-namespace
+ (sbcl-package->cl-source-package sbcl-lisp-namespace))
-(define-public cl-cluster
- (sbcl-package->cl-source-package sbcl-cluster))
+(define-public ecl-lisp-namespace
+ (sbcl-package->ecl-package sbcl-lisp-namespace))
-(define-public sbcl-language-codes
- (let ((commit "e7aa0e37cb97a3d37d6bc7316b479d01bff8f42e"))
+(define-public sbcl-lisp-pay
+ (let ((commit "c4de776f0a284709931ff3674160ced3b41bd000")
+ (revision "0"))
(package
- (name "sbcl-language-codes")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-lisp-pay")
+ (version (git-version "0.0.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/language-codes";)
+ (url "https://github.com/K1D77A/lisp-pay";)
(commit commit)))
- (file-name (git-file-name name commit))
+ (file-name (git-file-name "cl-lisp-pay" version))
(sha256
- (base32 "0py176ibmsc01n5r0q1bs1ykqf5jwdbh8kx0j1a814l9y51241v0"))))
+ (base32 "09r6qy4fipriqa0d6g9qm6dq992lr58vh24g5j0adm19i5fnjavh"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/language-codes/";)
- (synopsis "Map ISO language codes to language names in Common Lisp")
- (description
- "This is a small library providing the ISO-639 language code to
-language name mapping.")
- (license license:zlib))))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-cl-base64
+ sbcl-cl-str
+ sbcl-cl-tls
+ sbcl-closer-mop
+ sbcl-dexador
+ sbcl-hu.dwim.defclass-star
+ sbcl-hunchentoot
+ sbcl-ironclad
+ sbcl-jonathan
+ sbcl-lack
+ sbcl-ningle
+ sbcl-shasht))
+ (home-page "https://github.com/K1D77A/lisp-pay/";)
+ (synopsis "Wrappers over multiple Payment Processor APIs")
+ (description "This library provides payment API wrappers over
+BTCPay, Paypal, and Stripe.")
+ (license license:expat))))
-(define-public ecl-language-codes
- (sbcl-package->ecl-package sbcl-language-codes))
+(define-public cl-lisp-pay
+ (sbcl-package->cl-source-package sbcl-lisp-pay))
-(define-public cl-language-codes
- (sbcl-package->cl-source-package sbcl-language-codes))
+(define-public ecl-lisp-pay
+ (sbcl-package->ecl-package sbcl-lisp-pay))
-(define-public sbcl-multilang-documentation
- (let ((commit "59e798a07e949e8957a20927f52aca425d84e4a0"))
+(define-public sbcl-lisp-stat
+ (let ((commit "357a0d2b5f68a5ff925776235c2b7455e12b78ba")
+ (revision "0"))
(package
- (name "sbcl-multilang-documentation")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-lisp-stat")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/multilang-documentation";)
+ (url "https://github.com/Lisp-Stat/lisp-stat";)
(commit commit)))
- (file-name (git-file-name name commit))
+ (file-name (git-file-name "cl-lisp-stat" version))
(sha256
- (base32 "13y5jskx8n2b7kimpfarr8v777w3b7zj5swg1b99nj3hk0843ixw"))))
+ (base32 "0qwlxrbwj884mr67sf6aj0zwrndv33aiiid4bqrkji41kjhqfcz5"))))
(build-system asdf-build-system/sbcl)
+ ;; https://github.com/Lisp-Stat/lisp-stat/issues/22
+ (arguments (list #:tests? #f))
+ (native-inputs (list sbcl-parachute))
(inputs
- (list sbcl-documentation-utils sbcl-language-codes
- sbcl-system-locale))
- (home-page "https://shinmera.github.io/multilang-documentation/";)
- (synopsis "Add multiple languages support to Common Lisp documentation")
- (description
- "This library provides a drop-in replacement function for
-cl:documentation that supports multiple docstrings per-language, allowing you
-to write documentation that can be internationalised.")
- (license license:zlib))))
+ (list sbcl-alexandria
+ sbcl-alexandria-plus
+ sbcl-array-operations
+ sbcl-conduit-packages
+ sbcl-data-frame
+ sbcl-dexador
+ sbcl-dfio
+ sbcl-distributions
+ sbcl-numerical-utilities
+ sbcl-select
+ sbcl-statistics))
+ (home-page "https://lisp-stat.github.io/lisp-stat/";)
+ (synopsis "Statistical Computing in Common Lisp")
+ (description "This package provides a statistical computing
+environment for Common Lisp.")
+ (license license:ms-pl))))
-(define-public ecl-multilang-documentation
- (sbcl-package->ecl-package sbcl-multilang-documentation))
+(define-public cl-lisp-stat
+ (sbcl-package->cl-source-package sbcl-lisp-stat))
-(define-public cl-multilang-documentation
- (sbcl-package->cl-source-package sbcl-multilang-documentation))
+;; This depends on ecl-data-frame and ecl-dfio, which don't work yet.
+;; (define-public ecl-lisp-stat
+;; (sbcl-package->ecl-package sbcl-lisp-stat))
-(define-public sbcl-trivial-do
- (let ((commit "03a1729f1e71bad3ebcf6cf098a0cce52dfa1163"))
+(define-public sbcl-lispbuilder-sdl
+ (let ((commit "589b3c6d552bbec4b520f61388117d6c7b3de5ab"))
(package
- (name "sbcl-trivial-do")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-lispbuilder-sdl")
+ (version (git-version "0.9.8.2" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/yitzchak/trivial-do";)
+ (url "https://github.com/lispbuilder/lispbuilder";)
(commit commit)))
- (file-name (git-file-name name commit))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1ffva79nkicc7wc8c2ic5nayis3b2rk5sxzj74yjkymkjgbpcrgd"))))
+ (base32 "0zga59fjlhq3mhwbf80qwqwpkjkxqnn2mhxajlb8563vhn3dbafp"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/yitzchak/trivial-do";)
- (synopsis "Additional dolist style macros for Common Lisp")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("sdl" ,sdl)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'cd-sdl
+ (lambda _
+ (chdir "lispbuilder-sdl")
+ #t))
+ (add-after 'cd-sdl 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "cffi/library.lisp"
+ (("libSDL[^\"]*" all)
+ (string-append (assoc-ref inputs "sdl") "/lib/" all)))
+ #t)))))
+ (home-page
"https://github.com/lispbuilder/lispbuilder/wiki/LispbuilderSDL";)
+ (synopsis "Common Lisp wrapper for SDL")
(description
- "Additional dolist style macros for Common Lisp, such as
-@code{doalist}, @code{dohash}, @code{dolist*}, @code{doplist}, @code{doseq}
-and @code{doseq*}.")
- (license license:zlib))))
+ "This library is an SDL wrapper as part of an umbrella project that
+provides cross-platform packages for building large, interactive applications
+in Common Lisp.")
+ (license license:expat))))
-(define-public ecl-trivial-do
- (sbcl-package->ecl-package sbcl-trivial-do))
+(define-public cl-lispbuilder-sdl
+ (sbcl-package->cl-source-package sbcl-lispbuilder-sdl))
-(define-public cl-trivial-do
- (sbcl-package->cl-source-package sbcl-trivial-do))
+(define-public ecl-lispbuilder-sdl
+ (sbcl-package->ecl-package sbcl-lispbuilder-sdl))
-(define-public sbcl-common-lisp-jupyter
- (let ((commit "ba9f0e746b9200d6fd6db647d7274448119ed01b")
- (revision "3"))
+(define-public sbcl-list-named-class
+ (let ((commit "2955791a7469131bcab42d800883f27993ee1d62")
+ (revision "0"))
(package
- (name "sbcl-common-lisp-jupyter")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-list-named-class")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/yitzchak/common-lisp-jupyter";)
+ (url "https://github.com/phoe/list-named-class";)
(commit commit)))
- (file-name (git-file-name "common-lisp-jupyter" commit))
+ (file-name (git-file-name "cl-list-named-class" version))
(sha256
- (base32 "0si69xfzi769dprwfy7gp1x3bl7lxz6d4n98sa26w9r41wvay5ja"))))
+ (base32 "1bdi9q9wvfj66jji3n9hpjrj9271ial2awsb0xw80bmy6wqbg8kq"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-1am))
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-cl-base64
- sbcl-cl-indentify
- sbcl-closer-mop
- sbcl-dissect
- sbcl-eclector
- sbcl-ironclad
- sbcl-iterate
- sbcl-multilang-documentation
- sbcl-puri
- sbcl-pzmq
- sbcl-shasht
- sbcl-static-vectors
- sbcl-trivial-do
- sbcl-trivial-garbage
- sbcl-trivial-gray-streams
- sbcl-trivial-mimes))
- (home-page "https://yitzchak.github.io/common-lisp-jupyter/";)
- (synopsis "Common Lisp kernel for Jupyter")
+ (list sbcl-alexandria sbcl-closer-mop))
+ (home-page "https://github.com/phoe/list-named-class/";)
+ (synopsis "Name classes after lists of symbols")
(description
- "This is a Common Lisp kernel for Jupyter along with a library for
-building Jupyter kernels, based on Maxima-Jupyter which was based on
-@code{cl-jupyter}.")
+ "This package makes it possible to name classes by lists of symbols
+instead of symbols.")
(license license:expat))))
-(define-public ecl-common-lisp-jupyter
- (sbcl-package->ecl-package sbcl-common-lisp-jupyter))
+(define-public cl-list-named-class
+ (sbcl-package->cl-source-package sbcl-list-named-class))
-(define-public cl-common-lisp-jupyter
- (sbcl-package->cl-source-package sbcl-common-lisp-jupyter))
+(define-public ecl-list-named-class
+ (sbcl-package->ecl-package sbcl-list-named-class))
-(define-public sbcl-radiance
- (let ((commit "8d826c7fe1935338565580931db43f46181e0e85")
- (revision "3"))
+(define-public sbcl-listopia
+ (package
+ (name "sbcl-listopia")
+ (version "0.12.0")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Dimercel/listopia";)
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "07xa2s2s60h9f40az3zdacybl5pk1x8bhvga9phsra0czbv44lx2"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove))
+ (home-page "https://github.com/Dimercel/listopia";)
+ (synopsis "List manipulation library for Common Lisp")
+ (description "This package is a list manipulation library for Common Lisp
+inspired by Haskell package @code{Data.List}.")
+ (license license:llgpl)))
+
+(define-public cl-listopia
+ (sbcl-package->cl-source-package sbcl-listopia))
+
+(define-public ecl-listopia
+ (sbcl-package->ecl-package sbcl-listopia))
+
+(define-public sbcl-livesupport
+ (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a")
+ (revision "1"))
(package
- (name "sbcl-radiance")
- (version (git-version "2.1.2" revision commit))
+ (name "sbcl-livesupport")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/radiance";)
+ (url "https://github.com/cbaggers/livesupport";)
(commit commit)))
- (file-name (git-file-name "radiance" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1j823dgp87www0sjbcbv9j025bfxlkwhjd7kz6635mrqwmmlki4l"))))
+ (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; TODO: The tests require some configuration.
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'disable-quicklisp
- (lambda _
- ;; Disable the automatic installation of systems by Quicklisp.
- ;; (Maybe there would be a way to package Quicklisp and make it
- ;; install things in the user's directory instead of
- ;; /gnu/store/...).
- (substitute* "interfaces.lisp"
- (("\\(unless \\(asdf:find-system configured-implementation
NIL\\)"
- all)
- (string-append "#+quicklisp " all))))))))
- (native-inputs
- (list sbcl-alexandria
- sbcl-dexador
- sbcl-parachute
- sbcl-verbose))
- (inputs
- (list sbcl-babel
- sbcl-bordeaux-threads
- sbcl-cl-ppcre
- sbcl-closer-mop
- sbcl-documentation-utils
- sbcl-deploy
- sbcl-form-fiddle
- sbcl-lambda-fiddle
- sbcl-local-time
- sbcl-modularize-hooks
- sbcl-modularize-interfaces
- sbcl-puri
- sbcl-trivial-indent
- sbcl-trivial-mimes
- sbcl-ubiquitous))
- (home-page "https://shirakumo.github.io/radiance/";)
- (synopsis "Common Lisp web application environment")
- (description
- "Radiance is a web application environment, which is sort of like a web
-framework, but more general, more flexible. It should let you write personal
-websites and generally deployable applications easily and in such a way that
-they can be used on practically any setup without having to undergo special
-adaptations.")
- (license license:zlib))))
+ (home-page "https://github.com/cbaggers/livesupport";)
+ (synopsis "Some helpers that make livecoding a little easier")
+ (description "This package provides a macro commonly used in livecoding
to
+enable continuing when errors are raised. Simply wrap around a chunk of code
+and it provides a restart called @code{continue} which ignores the error and
+carrys on from the end of the body.")
+ (license license:bsd-2))))
-(define-public ecl-radiance
- (sbcl-package->ecl-package sbcl-radiance))
+(define-public cl-livesupport
+ (sbcl-package->cl-source-package sbcl-livesupport))
-(define-public cl-radiance
- (sbcl-package->cl-source-package sbcl-radiance))
+(define-public ecl-livesupport
+ (sbcl-package->ecl-package sbcl-livesupport))
-(define-public sbcl-radiance-contribs
- (let ((commit "710b3e1f9971e48368d52eea0b407f2e8f510981")
+(define-public sbcl-lla
+ (let ((commit "ded805d1e9b1493e17b601116ba9bd8a3de3024f")
(revision "1"))
(package
- (name "sbcl-radiance-contribs")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-lla")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/radiance-contribs";)
+ (url "https://github.com/tpapp/lla";)
(commit commit)))
- (file-name (git-file-name "radiance-contribs" version))
+ (file-name (git-file-name "cl-lla" version))
(sha256
- (base32 "08ivnd7a6vfciqna680qpx6zj6vw9xcbrzq29iz3x7x9sp1pqgq3"))))
+ (base32 "0n9vc7dnyjbbsv1n7rd8sylwda5fsdf8f890g4nachanyx0xps9k"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; TODO: Include more contribs.
- `(#:asd-systems '("r-clip"
- "i-log4cl"
- "i-sqlite"
- "r-data-model"
- "r-simple-rate"
- "r-welcome")))
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/configuration.lisp"
+ (("\"libblas.so.3gf\"")
+ (string-append "\"" (assoc-ref inputs "lapack")
+ "/lib/libopenblas.so\""))
+ (("\"liblapack.so.3gf\"")
+ (string-append "\"" (assoc-ref inputs "lapack")
+ "/lib/libopenblas.so\""))))))))
(inputs
- (list sbcl-radiance
- sbcl-cffi
- sbcl-clip
- sbcl-cl-sqlite
- sbcl-log4cl))
- (home-page "https://shirakumo.github.io/radiance/";)
- (synopsis "Standard implementations and drivers for the radiance
interfaces")
+ `(("anaphora" ,sbcl-anaphora)
+ ("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-num-utils" ,sbcl-cl-num-utils)
+ ("cl-slice" ,sbcl-cl-slice)
+ ("lapack" ,openblas)
+ ("let-plus" ,sbcl-let-plus)))
+ (native-inputs
+ (list sbcl-clunit))
+ (home-page "https://github.com/tpapp/lla";)
+ (synopsis "Linear algebra library for Common Lisp")
(description
- "This is a collection of useful helper modules and standard
-implementations for Radiance interfaces.")
- (license license:zlib))))
+ "LLA is a high-level Common Lisp library built on BLAS and LAPACK, but
+providing a much more abstract interface with the purpose of freeing the user
+from low-level concerns and reducing the number of bugs in numerical code.")
+ (license license:boost1.0))))
-(define-public ecl-radiance-contribs
- (sbcl-package->ecl-package sbcl-radiance-contribs))
+(define-public cl-lla
+ (sbcl-package->cl-source-package sbcl-lla))
-(define-public cl-radiance-contribs
- (sbcl-package->cl-source-package sbcl-radiance-contribs))
+(define-public ecl-lla
+ (sbcl-package->ecl-package sbcl-lla))
-(define-public sbcl-daemon
- (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597")
- (revision "1"))
+(define-public sbcl-lmdb
+ (let ((commit "f439b707939a52769dc9747838ff4a616fab14a3")
+ (revision "0"))
(package
- (name "sbcl-daemon")
- (version (git-version "0.0.4" revision commit))
+ (name "sbcl-lmdb")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/snmsts/daemon";)
+ (url "https://github.com/antimer/lmdb";)
(commit commit)))
- (file-name (git-file-name "daemon" version))
+ (file-name (git-file-name "cl-lmdb" version))
(sha256
- (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4"))))
+ (base32 "0akvimmvd4kcx6gh1j1dzvcclhc0jc4hc9vkh3ldgzb8wyf4vl8q"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/lmdb.lisp"
+ (("\"liblmdb.so\"")
+ (string-append
+ "\"" (search-input-file inputs "/lib/liblmdb.so")
"\""))))))))
(inputs
- (list sbcl-trivial-features))
- (home-page "https://github.com/snmsts/daemon";)
- (synopsis "Daemonize Common Lisp processes")
+ (list lmdb
+ sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cl-reexport
+ sbcl-mgl-pax
+ sbcl-osicat
+ sbcl-trivial-features
+ sbcl-trivial-garbage
+ sbcl-trivial-utf-8))
+ (native-inputs
+ (list sbcl-try))
+ (home-page "https://github.com/antimer/lmdb";)
+ (synopsis "LMDB bindings for Common Lisp")
(description
- "DAEMON provides the functionality of daemonizing Common Lisp processes
-on UNIX like platforms.")
+ "LMDB, the Lightning Memory-mapped Database, is an ACID key-value
+database with multiversion concurrency control. This package is a Common Lisp
+wrapper around the C LMDB library. It covers most of C LMDB's functionality,
+has a simplified API, much needed safety checks, and comprehensive
+documentation.")
(license license:expat))))
-(define-public ecl-daemon
- (sbcl-package->ecl-package sbcl-daemon))
+(define-public cl-lmdb
+ (sbcl-package->cl-source-package sbcl-lmdb))
-(define-public cl-daemon
- (sbcl-package->cl-source-package sbcl-daemon))
+(define-public sbcl-local-time
+ (let ((commit "40169fe26d9639f3d9560ec0255789bf00b30036")
+ (revision "4"))
+ (package
+ (name "sbcl-local-time")
+ (version (git-version "1.0.6" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dlowe-net/local-time";)
+ (commit commit)))
+ (file-name (git-file-name "cl-local-time" version))
+ (sha256
+ (base32 "1dbp33zmkqzzshmf5k76pxqgli285wvy0p0dhcz816fdikpwn2jg"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; Delete the extension provided by sbcl-cl-postgres+local-time
+ (add-after 'unpack 'delete-local-time
+ (lambda _
+ (delete-file "cl-postgres+local-time.asd")
+ (delete-file "src/integration/cl-postgres.lisp"))))))
+ (native-inputs
+ (list sbcl-hu.dwim.stefil))
+ (home-page "https://common-lisp.net/project/local-time/";)
+ (synopsis "Time manipulation library for Common Lisp")
+ (description
+ "The LOCAL-TIME library is a Common Lisp library for the manipulation of
+dates and times. It is based almost entirely upon Erik Naggum's paper \"The
+Long Painful History of Time\".")
+ (license license:expat))))
-(define-public sbcl-file-attributes
- (let ((commit "bbde396438f37d676de9775239115410bec4da2d"))
+(define-public cl-local-time
+ (sbcl-package->cl-source-package sbcl-local-time))
+
+(define-public ecl-local-time
+ (sbcl-package->ecl-package sbcl-local-time))
+
+(define-public sbcl-cl-postgres+local-time
+ (package
+ (inherit sbcl-local-time)
+ (name "sbcl-cl-postgres+local-time")
+ (inputs (list sbcl-local-time sbcl-postmodern))
+ (arguments
+ `(#:asd-systems '("cl-postgres+local-time")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'delete-local-time
+ (lambda _
+ (delete-file "local-time.asd")
+ (delete-file "src/package.lisp")
+ (delete-file "src/local-time.lisp")
+ (delete-file-recursively "doc")
+ (delete-file-recursively "test")
+ (delete-file-recursively "zoneinfo"))))))
+ (synopsis "Integration between cl-postgres and local-time")
+ (description
+ "This package provides the LOCAL-TIME extensions for the cl-postgres
+ASDF system of postmodern.")
+ (license license:expat)))
+
+(define-public cl-postgres+local-time
+ (sbcl-package->cl-source-package sbcl-cl-postgres+local-time))
+
+(define-public ecl-cl-postgres+local-time
+ (sbcl-package->ecl-package sbcl-cl-postgres+local-time))
+
+(define-public sbcl-log4cl
+ (let ((commit "fe3da517147d023029782ced7cd989ba24f1e62d")
+ (revision "2"))
(package
- (name "sbcl-file-attributes")
- (version (git-version "1.0.0" "2" commit))
+ (name "sbcl-log4cl")
+ (version (git-version "1.1.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/file-attributes/";)
+ (url "https://github.com/sharplispers/log4cl";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-log4cl" version))
(sha256
- (base32 "0n8q818ry2shggjfhp8gjby8v5mla9pg97c5g19pcglpnwim7a74"))))
+ (base32 "0n119sy35k9yl4n18az1sw9a7saa5jh3v44863b305by1p5xdy7k"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-stefil))
(inputs
- (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-features))
- (home-page "https://shinmera.github.io/file-attributes/";)
- (synopsis "Access to common file attributes in Common Lisp")
+ (list sbcl-bordeaux-threads))
+ (home-page "https://github.com/7max/log4cl";)
+ (synopsis "Common Lisp logging framework, modeled after Log4J")
(description
- "This is a small OS portability library to retrieve and set file
-attributes not supported by the Common Lisp standard functions.")
- (license license:zlib))))
+ "This is a Common Lisp logging framework that can log at various levels
+and mix text with expressions.")
+ (license license:asl2.0))))
-(define-public ecl-file-attributes
- (sbcl-package->ecl-package sbcl-file-attributes))
+(define-public cl-log4cl
+ (sbcl-package->cl-source-package sbcl-log4cl))
-(define-public cl-file-attributes
- (sbcl-package->cl-source-package sbcl-file-attributes))
+(define-public ecl-log4cl
+ (sbcl-package->ecl-package sbcl-log4cl))
-(define-public sbcl-filesystem-utils
- (let ((commit "a07e8b61b89d4b46408fb9294d9b8130e8c8a02e")
- (revision "2"))
+(define-public sbcl-lorem-ipsum
+ (let ((commit "04a1839a03b53c954e799b9cf570ac915b032ce8")
+ (revision "0"))
(package
- (name "sbcl-filesystem-utils")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-lorem-ipsum")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phoe/lorem-ipsum";)
+ (commit commit)))
+ (sha256
+ (base32 "1530qq0bk3xr25m77q96pbi1idnxdkax8cwmvq4ch03rfjy34j7n"))
+ (file-name (git-file-name "cl-lorem-ipsum" commit))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/phoe/lorem-ipsum";)
+ (synopsis "Lorem ipsum generator in portable Common Lisp")
+ (description
+ "This package provides functions for generating lorem ipsum text.")
+ (license license:expat))))
+
+(define-public cl-lorem-ipsum
+ (sbcl-package->cl-source-package sbcl-lorem-ipsum))
+
+(define-public ecl-lorem-ipsum
+ (sbcl-package->ecl-package sbcl-lorem-ipsum))
+
+(define-public sbcl-lparallel
+ (let ((commit "80fc2952a074776abd343d6b5d3ab157f0e1df7a")
+ (revision "1"))
+ (package
+ (name "sbcl-lparallel")
+ (version (git-version "2.8.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/filesystem-utils/";)
+ (url "https://github.com/sharplispers/lparallel/";)
(commit commit)))
- (file-name (git-file-name "cl-filesystem-utils" version))
+ (file-name (git-file-name "cl-lparallel" version))
(sha256
- (base32 "1zv2i2gndnbs7hz3bgkkq1qfx604wbndpc7qqlqvg23fssn9w59f"))))
+ (base32 "0nv2dx8cl25g68icqhw95yr5mygm86lcjzmzijql51na1p60g6y9"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-documentation-utils
- sbcl-pathname-utils
- sbcl-trivial-features))
- (home-page "https://shinmera.github.io/filesystem-utils/";)
- (synopsis "Collection of utilities for filesystem interaction")
- (description
- "This is an extension library to @code{pathname-utils}, to allow
-dealing with common problems with filesystems, such as listing files, probing
-file types, determining default directories, etc.")
- (license license:zlib))))
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-trivial-garbage))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-dependency
+ ;; lparallel loads a SBCL specific system in its asd file. This is
+ ;; not carried over into the fasl which is generated. In order for
+ ;; it to be carried over, it needs to be listed as a dependency.
+ (lambda _
+ (substitute* "lparallel.asd"
+ ((":depends-on \\(:alexandria" all)
+ (string-append all " #+sbcl :sb-cltl2"))))))))
+ (home-page "https://lparallel.org/";)
+ (synopsis "Parallelism for Common Lisp")
+ (description
+ "@command{lparallel} is a library for parallel programming in Common
+Lisp, featuring:
-(define-public ecl-filesystem-utils
- (sbcl-package->ecl-package sbcl-filesystem-utils))
+@itemize
+@item a simple model of task submission with receiving queue,
+@item constructs for expressing fine-grained parallelism,
+@item asynchronous condition handling across thread boundaries,
+@item parallel versions of map, reduce, sort, remove, and many others,
+@item promises, futures, and delayed evaluation constructs,
+@item computation trees for parallelizing interconnected tasks,
+@item bounded and unbounded FIFO queues,
+@item high and low priority tasks,
+@item task killing by category,
+@item integrated timeouts.
+@end itemize\n")
+ (license license:expat))))
-(define-public cl-filesystem-utils
- (sbcl-package->cl-source-package sbcl-filesystem-utils))
+(define-public cl-lparallel
+ (sbcl-package->cl-source-package sbcl-lparallel))
-(define-public sbcl-depot
- (let ((commit "73822d9f480cbad00971b45ee80117297a67fb53")
- (revision "1"))
+(define-public ecl-lparallel
+ (sbcl-package->ecl-package sbcl-lparallel))
+
+(define-public sbcl-lquery
+ (let ((revision "1")
+ (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d"))
(package
- (name "sbcl-depot")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-lquery")
+ (version (git-version "3.2.1" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/depot/";)
- (commit commit)))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/lquery";)
+ (commit commit)))
(sha256
- (base32 "1v42pirdwbxy8l8i9a2jmbpri8a62vh0r4vm25xwaak0y4gr71va"))
- (file-name (git-file-name "depot" version))))
- (build-system asdf-build-system/sbcl)
+ (base32 "0520mcpxc2d6fdm8z61arpgd2z38kan7cf06qs373n5r64rakz6w"))
+ (file-name (git-file-name name version))))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-atomics
- sbcl-babel
- sbcl-documentation-utils
- sbcl-trivial-features
- sbcl-trivial-gray-streams
- sbcl-zippy))
- ;; TODO: Some 6 tests fail, why? See
https://github.com/Shinmera/depot/issues/2.
- (arguments
- '(#:asd-systems '("depot"
- "depot-in-memory"
- "depot-virtual"
- "depot-zip")))
- (synopsis "Protocol for transparent collections of files")
- (description "This is a system presenting a protocol for \"file
-systems\": things that present a collection of \"files,\" which are things
-that have several attributes, and a central data payload. Most notably this
-includes the OS filesystem, but can also be used to address other
-filesystem-like things like archives, object stores, etc. in the same
-manner.")
- (home-page "https://shinmera.github.io/depot/";)
+ (list sbcl-array-utils sbcl-form-fiddle sbcl-plump 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 ecl-depot
- (sbcl-package->ecl-package sbcl-depot))
+(define-public cl-lquery
+ (sbcl-package->cl-source-package sbcl-lquery))
-(define-public cl-depot
- (sbcl-package->cl-source-package sbcl-depot))
+(define-public ecl-lquery
+ (sbcl-package->ecl-package sbcl-lquery))
-(define-public sbcl-cl-difflib
- (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e")
+(define-public sbcl-ltk
+ (let ((commit "ff14a781d211c19c35e65a7ecaece67dda0b3ebb")
(revision "0"))
(package
- (name "sbcl-cl-difflib")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-ltk")
+ (version (git-version "0.992" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/wiseman/cl-difflib";)
+ (url "https://github.com/herth/ltk";)
(commit commit)))
- (file-name
- (git-file-name name version))
+ (file-name (git-file-name "cl-ltk" version))
(sha256
- (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48"))))
+ (base32 "0f1xgsj2j7bq21cq2pa9rw3ybxd9vyknisl6z307lxx7lvhm3xac"))))
(build-system asdf-build-system/sbcl)
- ;; Due to the age of this library tests use some deprecated
- ;; functionality and keep failing.
+ (inputs
+ (list imagemagick tk))
(arguments
- '(#:tests? #f))
- (home-page "https://github.com/wiseman/cl-difflib";)
- (synopsis "Compute differences between pairs of sequences")
+ `(#:asd-systems '("ltk"
+ "ltk-mw"
+ "ltk-remote")
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "ltk/ltk.lisp"
+ (("#-freebsd \"wish\"")
+ (string-append "#-freebsd \""
+ (assoc-ref inputs "tk")
+ "/bin/wish\""))
+ (("do-execute \"convert\"")
+ (string-append "do-execute \""
+ (assoc-ref inputs "imagemagick")
+ "/bin/convert\"")))
+ #t))
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "ltk/ltk-remote.lisp"
+ (("\\(:export")
+ "(:shadow #:raise) (:export"))
+ #t)))))
+ (synopsis "Common Lisp bindings for the Tk GUI toolkit")
(description
- "A Common Lisp library for computing differences between
-sequences based on the Python difflib module.")
- (license license:expat))))
+ "LTK is a Common Lisp binding for the Tk graphics toolkit. It is
+written in pure Common Lisp and does not require any Tk knowledge for its
+usage.")
+ (home-page "http://www.peter-herth.de/ltk/";)
+ (license license:llgpl))))
-(define-public ecl-cl-difflib
- (sbcl-package->ecl-package sbcl-cl-difflib))
+(define-public cl-ltk
+ (sbcl-package->cl-source-package sbcl-ltk))
-(define-public cl-difflib
- (sbcl-package->cl-source-package sbcl-cl-difflib))
+(define-public ecl-ltk
+ (sbcl-package->ecl-package sbcl-ltk))
-(define-public sbcl-cl-html-diff
- (let ((commit "5a0b39d1c524278d6f60851d7786bb2585614310")
+(define-public sbcl-lunamech-matrix-api
+ (let ((commit "aa54a820149584c237b03d500ad83397fe25dc92")
(revision "0"))
(package
- (name "sbcl-cl-html-diff")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-lunamech-matrix-api")
+ (version (git-version "0.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/wiseman/cl-html-diff";)
+ (url "https://github.com/K1D77A/lunamech-matrix-api";)
(commit commit)))
- (file-name
- (git-file-name name version))
+ (file-name (git-file-name "cl-lunamech-matrix-api" version))
(sha256
- (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb"))))
+ (base32 "0a664qq4m5gk4iv5ck63gmsl3218jhjsalawklj56wn2pw0cf8a0"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-difflib))
- (home-page "https://github.com/wiseman/cl-html-diff";)
- (synopsis "Generate a human-readable diff of two HTML documents")
- (description
- "A Common Lisp library for generating a human-readable diff of two
-HTML documents.")
+ (list sbcl-cl-json
+ sbcl-cl-str
+ sbcl-closer-mop
+ sbcl-dexador
+ sbcl-do-urlencode
+ sbcl-drakma
+ sbcl-jonathan
+ sbcl-plump
+ sbcl-quri
+ sbcl-reader
+ sbcl-shasht))
+ (home-page "https://github.com/K1D77A/lunamech-matrix-api/";)
+ (synopsis "Implementation of the Matrix API")
+ (description "This package provides an implementation of the Matrix
+API for Common Lisp.")
(license license:expat))))
-(define-public ecl-cl-html-diff
- (sbcl-package->ecl-package sbcl-cl-html-diff))
+(define-public cl-lunamech-matrix-api
+ (sbcl-package->cl-source-package sbcl-lunamech-matrix-api))
-(define-public cl-html-diff
- (sbcl-package->cl-source-package sbcl-cl-html-diff))
+(define-public ecl-lunamech-matrix-api
+ (sbcl-package->ecl-package sbcl-lunamech-matrix-api))
-(define-public sbcl-tooter
- (let ((commit "2dcc2facddcacd79d0cce545a8c4b73c35826fc1")
- (revision "4"))
+(define-public sbcl-lw-compat
+ ;; No release since 2013.
+ (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d"))
(package
- (name "sbcl-tooter")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-lw-compat")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/tooter";)
+ (url "https://github.com/pcostanza/lw-compat/";)
(commit commit)))
- (file-name (git-file-name "cl-tooter" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1zisrmslj4rnibm02vxh7hbas2cfsjh6iizs2nfdg3a3pn7bhf6h"))))
+ (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cl-ppcre
- sbcl-documentation-utils
- sbcl-drakma
- sbcl-yason))
- (synopsis "Common Lisp client library for Mastodon instances")
- (description
- "This is a Common Lisp library implementing the full v1 REST API
-protocol for Mastodon.")
- (home-page "https://shinmera.github.io/tooter/";)
- (license license:zlib))))
+ (home-page "https://github.com/pcostanza/lw-compat/";)
+ (synopsis "LispWorks utilities ported to other Common Lisp
implementations")
+ (description "This package contains a few utility functions from the
+LispWorks library that are used in software such as ContextL.")
+ (license license:expat))))
-(define-public ecl-tooter
- (sbcl-package->ecl-package sbcl-tooter))
+(define-public cl-lw-compat
+ (sbcl-package->cl-source-package sbcl-lw-compat))
-(define-public cl-tooter
- (sbcl-package->cl-source-package sbcl-tooter))
+(define-public ecl-lw-compat
+ (sbcl-package->ecl-package sbcl-lw-compat))
-(define-public sbcl-croatoan
- (let ((commit "282145ff9e9005fddc4241bc6827b3ab09c5bd25")
- (revision "1"))
+(define-public sbcl-lzlib
+ (let ((commit "22767ca12d1c1bd59a7ae1f9c5ef7d2e937206bb")
+ (revision "2"))
(package
- (name "sbcl-croatoan")
+ (name "sbcl-lzlib")
(version (git-version "2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/McParen/croatoan";)
+ (url "https://codeberg.org/glv/cl-lzlib";)
(commit commit)))
- (file-name (git-file-name "cl-croatoan" version))
+ (file-name (git-file-name "cl-lzlib" version))
(sha256
- (base32 "021h2f2yj4j9gynr3k7qi36x94jm5b95p3vaddbaih96wyzgbmq5"))))
+ (base32 "1dxzlkay7aqcs65h2f7j7rl4sdjija60dshlahzyllfw174p9d3m"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "ncurses/ncurses.lisp"
- (("libncursesw.so")
- (search-input-file inputs "/lib/libncursesw.so"))))))))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list ncurses
+ (list lzlib
sbcl-cffi
- sbcl-trivial-gray-streams
- sbcl-bordeaux-threads))
- (synopsis "Common Lisp bindings for the ncurses terminal library")
- (description "Croatoan provides high-level Common Lisp CLOS bindings for
-the ncurses terminal library.")
- (home-page "https://github.com/McParen/croatoan";)
- (license license:expat))))
+ sbcl-cl-octet-streams
+ sbcl-lparallel))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/lzlib.lisp"
+ (("liblz\\.so")
+ (search-input-file inputs "/lib/liblz.so"))))))))
+ (synopsis "Common Lisp library for lzip (de)compression")
+ (description
+ "This Common Lisp library provides functions for lzip (LZMA)
+compression/decompression using bindings to the lzlib C library.")
+ (home-page "https://codeberg.org/glv/cl-lzlib";)
+ (license license:gpl3+))))
-(define-public ecl-croatoan
- (sbcl-package->ecl-package sbcl-croatoan))
+(define-public cl-lzlib
+ (sbcl-package->cl-source-package sbcl-lzlib))
-(define-public cl-croatoan
- (sbcl-package->cl-source-package sbcl-croatoan))
+(define-public ecl-lzlib
+ (sbcl-package->ecl-package sbcl-lzlib))
-(define-public sbcl-cl-spark
- (let ((commit "4e34bcebdcf8e45265986eb43ad4ad03bb41a581")
- (revision "1"))
+(define-public sbcl-machine-state
+ (let ((commit "3d258eea63942e7d2fd7212f1ad8bbcf505634a2")
+ (revision "2"))
(package
- (name "sbcl-cl-spark")
- (version (git-version "0.1.13" revision commit))
+ (name "sbcl-machine-state")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tkych/cl-spark";)
+ (url "https://github.com/Shinmera/machine-state";)
(commit commit)))
- (file-name (git-file-name "cl-spark" version))
+ (file-name (git-file-name "cl-machine-state" version))
(sha256
- (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk"))))
+ (base32 "1fjf2v8agx75qnna1n8fn54lvb01w1rk1vddi3p45a2xw1kwhzml"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "Common Lisp library to make histograms")
- (description "This is a Common Lisp library to make histograms using
-UTF-8 block characters.")
- (home-page "https://github.com/tkych/cl-spark";)
- (license license:expat))))
+ (inputs
+ (list sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-cl-opengl
+ sbcl-documentation-utils))
+ (arguments
+ '(#:tests? #f ; No tests.
+ #:asd-systems '("machine-state" "machine-state/opengl")))
+ (home-page "https://shinmera.github.io/machine-state/";)
+ (synopsis "Retrieve machine state information about CPU time, memory
usage and more")
+ (description
+ "This library implements various functions to access status information
+about the machine, process, etc.")
+ (license license:zlib))))
-(define-public ecl-cl-spark
- (sbcl-package->ecl-package sbcl-cl-spark))
+(define-public cl-machine-state
+ (sbcl-package->cl-source-package sbcl-machine-state))
-(define-public cl-spark
- (sbcl-package->cl-source-package sbcl-cl-spark))
+(define-public ecl-machine-state
+ (sbcl-package->ecl-package sbcl-machine-state))
-(define-public sbcl-access
- (let ((commit "a4f87fc1007f5c9a0a2abfddc1c23a77e87096f8")
+(define-public sbcl-magic-ed
+ (let ((commit "30bb27832d4e3e362578e7320934638f9889a8c4")
(revision "1"))
(package
- (name "sbcl-access")
- (version (git-version "1.6.0" revision commit))
+ (name "sbcl-magic-ed")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/access";)
+ (url "https://github.com/sanel/magic-ed";)
(commit commit)))
- (file-name (git-file-name "cl-access" version))
+ (file-name (git-file-name "cl-magic-ed" version))
(sha256
- (base32 "0zdjqhb9rvnlq6nzmsp7372gi91k1rq9bz510m6hcki7g3r01iv5"))))
+ (base32 "1j6il4lif0dy6hqiz6n91yl8dvii9pk1i9vz0faq5mnr42mr7i5f"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit2))
- (inputs
- (list sbcl-alexandria
- sbcl-cl-ppcre
- sbcl-closer-mop
- sbcl-iterate))
- (synopsis
- "Common lisp library to unify access to dictionary-like structures")
+ (home-page "https://github.com/sanel/magic-ed";)
+ (synopsis "Editing facility for Common Lisp REPL")
(description
- "This is a Common lisp library to unify access to the most common
-dictionary-like data structures.")
- (home-page "https://github.com/AccelerationNet/access";)
- (license license:bsd-3))))
+ "Magic (ed) is a tiny editing facility for Common Lisp, where you can
+directly load, edit, manipulate and evaluate file or file content from REPL.
+This package also can be a starting point for people who are not accustomed to
+Emacs or SLIME and would like to continue using their default terminal/console
+editor with Common Lisp.")
+ (license license:expat))))
-(define-public ecl-access
- (sbcl-package->ecl-package sbcl-access))
+(define-public cl-magic-ed
+ (sbcl-package->cl-source-package sbcl-magic-ed))
-(define-public cl-access
- (sbcl-package->cl-source-package sbcl-access))
+(define-public ecl-magic-ed
+ (sbcl-package->ecl-package sbcl-magic-ed))
-(define-public sbcl-sxql-composer
- (let ((commit "2b2230cb01ae1b68e28921d99e4814046867fb75")
- (revision "1"))
+(define-public sbcl-magicffi
+ (let ((commit "d88f2f280c31f639e4e05be75215d8a8dce6aef2"))
(package
- (name "sbcl-sxql-composer")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-magicffi")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/sxql-composer";)
+ (url "https://github.com/dochang/magicffi/";)
(commit commit)))
- (file-name (git-file-name "sxql-composer" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1agkrj3ymskzc3c7pxbrj123d1kygjqcls145m0ap3i07q96hh1r"))))
+ (base32 "0p6ysa92fk34bhxpw7bycbfgw150fv11z9x8jr9xb4lh8cm2hvp6"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-alexandria))
(inputs
- (list sbcl-sxql))
- (synopsis "Build and compose SXQL queries dynamically")
+ `(("cffi" ,sbcl-cffi)
+ ("ppcre" ,sbcl-cl-ppcre)
+ ("libmagic" ,file)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (let ((magic (assoc-ref inputs "libmagic")))
+ (substitute* "grovel.lisp"
+ (("/usr/include/magic.h")
+ (string-append magic "/include/magic.h")))
+ (substitute* "api.lisp"
+ ((":default \"libmagic\"" all)
+ (string-append ":default \"" magic
"/lib/libmagic\"")))))))))
+ (home-page "https://common-lisp.net/project/magicffi/";)
+ (synopsis "Common Lisp interface to libmagic based on CFFI")
(description
- "This is a Common Lisp library to build and compose SXQL queries
-dynamically.")
- (home-page "https://github.com/mmontone/sxql-composer";)
- (license license:expat))))
+ "MAGICFFI is a Common Lisp CFFI interface to libmagic(3), the file type
+determination library using @emph{magic} numbers.")
+ (license license:bsd-2))))
-(define-public ecl-sxql-composer
- (sbcl-package->ecl-package sbcl-sxql-composer))
+(define-public ecl-magicffi
+ (sbcl-package->ecl-package sbcl-magicffi))
-(define-public cl-sxql-composer
- (sbcl-package->cl-source-package sbcl-sxql-composer))
+(define-public cl-magicffi
+ (sbcl-package->cl-source-package sbcl-magicffi))
-(define-public sbcl-cl-i18n
- (let ((commit "acb162a12dac50fc46d83da8934fce85d19e31c4")
- (revision "3"))
+(define-public sbcl-magicl
+ (package
+ (name "sbcl-magicl")
+ (version "0.9.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/quil-lang/magicl";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-magicl" version))
+ (sha256
+ (base32 "0x9p55qin399jhr5md88nij8fv78b64xjhww7ys364pkjnx8ak9v"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list gfortran sbcl-fiasco))
+ (inputs
+ (list lapack
+ sbcl-alexandria
+ sbcl-abstract-classes
+ sbcl-cffi
+ sbcl-interface
+ sbcl-policy-cond
+ sbcl-static-vectors
+ sbcl-trivial-garbage))
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/extensions/blas/load-libs.lisp"
+ (("libblas.so")
+ (search-input-file inputs "/lib/libblas.so")))
+ (substitute* "src/extensions/lapack/load-libs.lisp"
+ (("liblapack.so")
+ (search-input-file inputs "/lib/liblapack.so"))))))))
+ (synopsis "Matrix Algebra proGrams In Common Lisp")
+ (description
+ "This package provides matrix algebra functions for Common Lisp.")
+ (home-page "https://github.com/quil-lang/magicl";)
+ (license license:bsd-3)))
+
+(define-public cl-magicl
+ (sbcl-package->cl-source-package sbcl-magicl))
+
+(define-public sbcl-maiden
+ (let ((commit "164e8df1b513fcbf097315b51242d337c183a5ef")
+ (revision "1"))
(package
- (name "sbcl-cl-i18n")
- (version (git-version "0.5.5" revision commit))
+ (name "sbcl-maiden")
+ (version (git-version "3.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/cage/cl-i18n";)
+ (url "https://github.com/Shirakumo/maiden/";)
(commit commit)))
- (file-name (git-file-name "cl-i18n" version))
(sha256
- (base32 "1y29cirmlyc406a45sdx39spvnjzbs772c977075ccicz46qaxz7"))))
+ (base32 "1m16qi019cmfpfs6538hc4qsplpb8nl9ly1qlckgfxgjag0z3wdr"))
+ (file-name (git-file-name "maiden" version))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("maiden"
+ "maiden-commands"
+ "maiden-networking"
+ "maiden-client-entities"
+ "maiden-irc"
+ "maiden-silly")))
(inputs
- (list sbcl-alexandria sbcl-babel sbcl-cl-ppcre-unicode))
- (synopsis "Internationalisation framework for Common Lisp")
- (description
- "This is a Gettext-style internationalisation framework for Common
-Lisp.")
- (home-page "https://codeberg.org/cage/cl-i18n";)
- (license license:llgpl))))
-
-(define-public ecl-cl-i18n
- (sbcl-package->ecl-package sbcl-cl-i18n))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cl-base64
+ sbcl-cl+ssl
+ sbcl-closer-mop
+ sbcl-deeds
+ sbcl-documentation-utils
+ sbcl-drakma
+ sbcl-form-fiddle
+ sbcl-jsown
+ sbcl-lambda-fiddle
+ sbcl-lquery
+ sbcl-pathname-utils
+ sbcl-trivial-garbage
+ sbcl-trivial-indent
+ sbcl-ubiquitous
+ sbcl-usocket
+ sbcl-uuid
+ sbcl-verbose))
+ (synopsis "Modern and extensible chat bot framework")
+ (description "Maiden is a collection of systems to help you build
+applications and libraries that interact with chat servers. It can help you
+build a chat bot, or a general chat client. It also offers a variety of parts
+that should make it much easier to write a client for a new chat protocol.")
+ (home-page "http://shirakumo.github.io/maiden/";)
+ (license license:zlib))))
-(define-public cl-i18n
- (sbcl-package->cl-source-package sbcl-cl-i18n))
+(define-public maiden
+ (sbcl-package->cl-source-package sbcl-maiden))
-(define-public sbcl-crypto-shortcuts
- (let ((commit "7efd22d80e867cd8c9f8f363d4fe7b51ee2dadc0")
+(define-public sbcl-maidenhead
+ (let ((commit "4b9c38e4845dda56ae7fb0355c5260c9ade0ac12")
(revision "1"))
(package
- (name "sbcl-crypto-shortcuts")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-maidenhead")
+ (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/crypto-shortcuts";)
+ (url "https://codeberg.org/glv/maidenhead";)
(commit commit)))
- (file-name (git-file-name "crypto-shortcuts" version))
+ (file-name (git-file-name "cl-maidenhead" version))
(sha256
- (base32 "0c0m0ar04jn7qf2v8c4sivamlzki03r13rnxy8b3n27rh9r6hgin"))))
+ (base32 "10pcx2ngyj6lkfbg1b58lzcm02xl1a3smnad5lvvw30pbalwcq46"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-base64 sbcl-flexi-streams sbcl-ironclad))
- (synopsis "Collection of common cryptography functions")
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis
+ "Convert coordinates between latitude/longitude and Maidenhead")
(description
- "This is a collection of common cryptography functions for Common
-Lisp.")
- (home-page "https://shinmera.github.io/crypto-shortcuts/";)
- (license license:zlib))))
+ "This a Common Lisp library to convert geographic coordinates between
+latitude/longitude and Maidenhead locator system.")
+ (home-page "https://codeberg.org/glv/maidenhead";)
+ (license license:gpl3+))))
-(define-public ecl-crypto-shortcuts
- (sbcl-package->ecl-package sbcl-crypto-shortcuts))
+(define-public cl-maidenhead
+ (sbcl-package->cl-source-package sbcl-maidenhead))
-(define-public cl-crypto-shortcuts
- (sbcl-package->cl-source-package sbcl-crypto-shortcuts))
+(define-public ecl-maidenhead
+ (sbcl-package->ecl-package sbcl-maidenhead))
-(define-public sbcl-cl-html5-parser
- (let ((commit "74a92eb3a183a0afd089ea33350e816e6b9aeefa")
- (revision "1"))
+(define-public sbcl-make-hash
+ ;; no tagged branch
+ (let ((revision "1")
+ (commit "ae0909cd8e697520a1085fac6f54ac2b448ebd21"))
(package
- (name "sbcl-cl-html5-parser")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-make-hash")
+ (version (git-version "1.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rotatef/cl-html5-parser";)
+ (url "https://github.com/genovese/make-hash";)
(commit commit)))
- (file-name (git-file-name "cl-html5-parser" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "04if61wigylsmn996rbfl8ylsd0d9hzdmg7p2wiglncibjzcl5k9"))))
+ (base32 "1qa4mcmb3pv44py0j129dd8hjx09c2akpnds53b69151mgwv5qz8"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/genovese/make-hash";)
+ (synopsis "Common Lisp package for flexible hash table creation")
+ (description
+ "This is a Common Lisp package for hash table creation with flexible,
+extensible initializers.")
+ (license license:bsd-3))))
+
+(define-public cl-make-hash
+ (sbcl-package->cl-source-package sbcl-make-hash))
+
+(define-public ecl-make-hash
+ (sbcl-package->ecl-package sbcl-make-hash))
+
+(define-public sbcl-map-bind
+ (let ((commit "532d55d93540c632e22b2cd264b5daa5f9d3d900")
+ (revision "0"))
+ (package
+ (name "sbcl-map-bind")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/map-bind";)
+ (commit commit)))
+ (file-name (git-file-name "cl-map-bind" version))
+ (sha256
+ (base32 "0hfy65xyqc4zqfncn11pp3hjjkdz7m91cynnv91s3lgcl3kffva0"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-json-streams sbcl-split-sequence sbcl-stefil))
- (inputs
- (list sbcl-cl-ppcre sbcl-flexi-streams sbcl-string-case))
- (synopsis "HTML5 parser for Common Lisp")
- (description "This a Common Lisp library to parse HTML5 documents.")
- (home-page "https://github.com/rotatef/cl-html5-parser";)
- (license license:lgpl3+))))
+ (list sbcl-parachute))
+ (home-page "https://www.hexstreamsoft.com/libraries/map-bind/";)
+ (synopsis "Macro favouring positional references over naming")
+ (description
+ "@code{MAP-BIND} is a macro that allows visual grouping of variables
with
+their corresponding values in calls to mapping operators when using an
+inline @code{LAMBDA}.")
+ (license license:unlicense))))
-(define-public ecl-cl-html5-parser
- (sbcl-package->ecl-package sbcl-cl-html5-parser))
+(define-public cl-map-bind
+ (sbcl-package->cl-source-package sbcl-map-bind))
-(define-public cl-html5-parser
- (sbcl-package->cl-source-package sbcl-cl-html5-parser))
+(define-public ecl-cl-map-bind
+ (sbcl-package->ecl-package sbcl-map-bind))
-(define-public sbcl-percent-encoding
- (let ((commit "c1224e22bc8048fbd3ebbc9329715a0c1b673170")
+(define-public sbcl-map-set
+ (let ((commit "7b4b545b68b8")
(revision "1"))
(package
- (name "sbcl-percent-encoding")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-map-set")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://bitbucket.org/tarballs_are_good/map-set/get/";
+ commit ".tar.gz"))
+ (sha256
+ (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://bitbucket.org/tarballs_are_good/map-set";)
+ (synopsis "Set-like data structure")
+ (description
+ "Implementation of a set-like data structure with constant time
+addition, removal, and random selection.")
+ (license license:bsd-3))))
+
+(define-public cl-map-set
+ (sbcl-package->cl-source-package sbcl-map-set))
+
+(define-public ecl-map-set
+ (sbcl-package->ecl-package sbcl-map-set))
+
+;;; The following package is renamed from "markup" to "markup-reader" in order
+;;; not to conflict with the "cl-markup" package.
+(define-public sbcl-markup-reader
+ (let ((commit "d2d4d7b073554f47c24223a9304452966608702e")
+ (revision "1"))
+ (package
+ (name "sbcl-markup-reader")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/llibra/percent-encoding";)
+ (url "https://github.com/moderninterpreters/markup";)
(commit commit)))
- (file-name (git-file-name "percent-encoding" version))
+ (file-name (git-file-name "markup-reader" version))
(sha256
- (base32 "0q1lh3sa6mkjr5gcdkgimkpc29rgf9cjhv90f61h8ridj28grq0h"))))
+ (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("markup")))
(native-inputs
(list sbcl-fiveam))
(inputs
- (list sbcl-anaphora sbcl-babel))
- (synopsis "RFC 3986 percent-encoding library")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-str" ,sbcl-cl-str)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
+ (home-page "https://github.com/moderninterpreters/markup";)
+ (synopsis "Reader-macro to read HTML tags inside of Common Lisp code")
(description
- "This is a Common Lisp library providing RFC 3986 percent-encoding.")
- (home-page "https://github.com/llibra/percent-encoding";)
- (license license:expat))))
+ "Markup allows the use of HTML syntax with in Common Lisp code.
+This has the advantage of being able to copy HTML snippets and have them
+instantly be functional, less double quotes than a s-expression approach,
+and designers will be able to understand the embedded HTML.")
+ (license license:asl2.0))))
-(define-public ecl-percent-encoding
- (sbcl-package->ecl-package sbcl-percent-encoding))
+(define-public cl-markup-reader
+ (sbcl-package->cl-source-package sbcl-markup-reader))
-(define-public cl-percent-encoding
- (sbcl-package->cl-source-package sbcl-percent-encoding))
+(define-public ecl-markup-reader
+ (sbcl-package->ecl-package sbcl-markup-reader))
-(define-public sbcl-machine-state
- (let ((commit "3d258eea63942e7d2fd7212f1ad8bbcf505634a2")
- (revision "2"))
+(define-public sbcl-marray
+ (let ((commit "0352f316b6830f0b119088ba9be836e4726bd7d8")
+ (revision "0"))
(package
- (name "sbcl-machine-state")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-marray")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/machine-state";)
+ (url "https://github.com/death/marray";)
(commit commit)))
- (file-name (git-file-name "cl-machine-state" version))
+ (file-name (git-file-name "cl-marray" version))
(sha256
- (base32 "1fjf2v8agx75qnna1n8fn54lvb01w1rk1vddi3p45a2xw1kwhzml"))))
+ (base32 "0l4kvzpiw14vqhlsaflp3c7y51vznjjgbdi0q3axqk1wxvzy1zlx"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-cl-opengl
- sbcl-documentation-utils))
(arguments
- '(#:tests? #f ; No tests.
- #:asd-systems '("machine-state" "machine-state/opengl")))
- (home-page "https://shinmera.github.io/machine-state/";)
- (synopsis "Retrieve machine state information about CPU time, memory
usage and more")
- (description
- "This library implements various functions to access status information
-about the machine, process, etc.")
- (license license:zlib))))
-
-(define-public ecl-machine-state
- (sbcl-package->ecl-package sbcl-machine-state))
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-dependencies
+ (lambda _
+ (substitute* "marray.asd"
+ ((":components")
+ ":depends-on (#+sbcl \"sb-posix\")\n :components")))))))
+ (home-page "https://github.com/death/marray";)
+ (synopsis "Memory-mapped files as Common Lisp arrays")
+ (description
+ "MARRAY is a library which provides access to memory-mapped files
+through Common Lisp arrays.")
+ (license license:expat))))
-(define-public cl-machine-state
- (sbcl-package->cl-source-package sbcl-machine-state))
+(define-public cl-marray
+ (sbcl-package->cl-source-package sbcl-marray))
-(define-public sbcl-cl-mount-info
- (let ((commit "2024f5037a7f63db3e3587dc9972cd7b9318f06b")
+;; ECL support not implemented yet.
+;; (define-public ecl-marray
+;; (sbcl-package->ecl-package sbcl-marray))
+
+(define-public sbcl-marshal
+ (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
(revision "1"))
(package
- (name "sbcl-cl-mount-info")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-marshal")
+ (version (git-version "1.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://notabug.org/cage/cl-mount-info.git";)
+ (url "https://github.com/wlbr/cl-marshal";)
(commit commit)))
- (file-name (git-file-name "cl-mount-info" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0vza9gj9q42nzb5v8aj22lmn4aqx9vrddsb5a343nbwfz89hbh9x"))))
+ (base32 "08qs6fhk38xpkkjkpcj92mxx0lgy4ygrbbzrmnivdx281syr0gwh"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-cffi sbcl-cl-ppcre))
- (home-page "https://notabug.org/cage/cl-mount-info.git";)
- (synopsis "Library to get information about mounted filesystems")
+ (home-page "https://github.com/wlbr/cl-marshal";)
+ (synopsis "Simple (de)serialization of Lisp datastructures")
(description
- "CL-MOUNT-INFO is a Common Lisp wrapper around @code{getmntent(3)} and
-related C functions to get information about the mounted file system.")
- (license license:lgpl3))))
-
-(define-public ecl-cl-mount-info
- (sbcl-package->ecl-package sbcl-cl-mount-info))
-
-(define-public cl-mount-info
- (sbcl-package->cl-source-package sbcl-cl-mount-info))
-
-(define-public sbcl-cl-diskspace
- (let ((commit "2dce2d0387d58221c452bd76c7b9b7a7de81ef55")
- (revision "1"))
- (package
- (name "sbcl-cl-diskspace")
- (version (git-version "0.3.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/muyinliu/cl-diskspace";)
- (commit commit)))
- (file-name (git-file-name "cl-diskspace" version))
- (sha256
- (base32 "0l19hxqw6b8i5i1jdbr45k1xib9axcwdagsp3y8wkb35g6wwc0s7"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/unix/cl-diskspace-list-all-disks-with-df.lisp"
- (("grep")
- (search-input-file inputs "/bin/grep")))
- (substitute* "src/unix/cl-diskspace-list-all-disks-with-df.lisp"
- (("/bin/df")
- (which "df")))
- #t)))))
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("cffi" ,sbcl-cffi)
- ("grep" ,grep)))
- (home-page "https://github.com/muyinliu/cl-diskspace";)
- (synopsis "Disk space information library for Common Lisp")
- (description
- "CL-DISKSPACE is a Common Lisp library to list disks with the command
-line tool @code{df} and get disk space information using @code{statvfs}.")
- (license license:isc))))
-
-(define-public ecl-cl-diskspace
- (sbcl-package->ecl-package sbcl-cl-diskspace))
-
-(define-public cl-diskspace
- (sbcl-package->cl-source-package sbcl-cl-diskspace))
-
-(define-public sbcl-cl-cpus
- (package
- (name "sbcl-cl-cpus")
- (version "0.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/muyinliu/cl-cpus";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-cpus" version))
- (sha256
- (base32 "0sdaff9hpsx7bpkkkqavmxmrrlc2d61gmqjjgn8xchncng4a0rf8"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cffi))
- (home-page "https://github.com/muyinliu/cl-cpus";)
- (synopsis "Common Lisp feature to get number of CPUs")
- (description
- "This package provides a Common Lisp system which has only one function to
-return the CPU count of the current system.")
- (license license:isc)))
-
-(define-public ecl-cl-cpus
- (sbcl-package->ecl-package sbcl-cl-cpus))
-
-(define-public cl-cpus
- (sbcl-package->cl-source-package sbcl-cl-cpus))
-
-(define-public sbcl-system-load
- (let ((commit "3ff1a40be55866cc5316ac7a530d872b12510294")
- (revision "0"))
- (package
- (name "sbcl-system-load")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/system-load";)
- (commit commit)))
- (file-name (git-file-name "cl-system-load" version))
- (sha256
- (base32 "08d8kr8j5l2m8p69f47iklxhna394vx9mrys0sgplf5f2bqb7xcv"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/Shinmera/system-load";)
- (synopsis "Access system's CPU and memory usage from Common Lisp")
- (description
- "System-Load is a Common Lisp library for accessing the system's CPU and
-memory usage.")
- (license license:zlib))))
+ "Simple and fast marshalling of Lisp datastructures. Convert any object
+into a string representation, put it on a stream an revive it from there.
+Only minimal changes required to make your CLOS objects serializable.")
+ (license license:expat))))
-(define-public cl-system-load
- (sbcl-package->cl-source-package sbcl-system-load))
+(define-public cl-marshal
+ (sbcl-package->cl-source-package sbcl-marshal))
-(define-public ecl-system-load
- (sbcl-package->ecl-package sbcl-system-load))
+(define-public ecl-marshal
+ (sbcl-package->ecl-package sbcl-marshal))
-(define-public sbcl-fof
- (let ((commit "522879e7da110ecf2e841998b197b34062c54b29")
- (revision "1"))
+(define-public sbcl-mathkit
+ (let ((commit "fd884f94b36ef5e9bc19459ad0b3cda6303d2a2a"))
(package
- (name "sbcl-fof")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-mathkit")
+ (version (git-version "0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/ambrevar/fof";)
+ (url "https://github.com/lispgames/mathkit/";)
(commit commit)))
- (file-name (git-file-name "cl-fof" version))
+ (file-name (git-file-name "cl-mathkit" version))
(sha256
- (base32 "0ipy51q2fw03xk9rqcyzbq2b9c32npc1gl3c53rdjywpak7zwwg6"))))
+ (base32 "174y6ndmf52h8sml87qjfl48llmynvdizzk2h0mr85zbaysx73i3"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("fof" "fof/mf")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "ffprobe.lisp"
- (("\\(defvar \\*ffprobe-command\\* \"ffprobe\"\\)")
- (format #f "(defvar *ffprobe-command* \"~a/bin/ffprobe\")"
- (assoc-ref inputs "ffmpeg")))))))))
(inputs
(list sbcl-alexandria
- sbcl-cl-json
- sbcl-cl-str
- sbcl-hu.dwim.defclass-star
- sbcl-local-time
- sbcl-magicffi
- sbcl-named-readtables
- sbcl-osicat
- sbcl-serapeum
- sbcl-trivia
- sbcl-trivial-package-local-nicknames
- ;; Non-CL deps:
- ffmpeg))
- (home-page "https://gitlab.com/ambrevar/fof";)
- (synopsis "File object finder library for Common Lisp")
+ sbcl-sb-cga))
+ (home-page "https://github.com/lispgames/mathkit/";)
+ (synopsis "Pure math functions useful for games, 3D, and GL in general")
(description
- "This library enable rapid file search, inspection and manipulation
-straight from the REPL.
-It aims at replacing Unix tools such as @code{find} or @code{du}.
-It also offers a replacement to the @code{pathname} Common Lisp API.
-Slot writers which commit changes to disk, e.g. permissions, modification
-time, etc.")
- (license license:gpl3+))))
+ "This is a purely math-related utility kit, providing functions which
+can be useful for games, 3D, and GL in general.")
+ (license license:expat))))
-(define-public ecl-fof
- (sbcl-package->ecl-package sbcl-fof))
+(define-public cl-mathkit
+ (sbcl-package->cl-source-package sbcl-mathkit))
-(define-public cl-fof
- (sbcl-package->cl-source-package sbcl-fof))
+(define-public ecl-mathkit
+ (sbcl-package->ecl-package sbcl-mathkit))
-(define-public sbcl-computable-reals
- (let ((commit "fdc73d75e79d0a4ce6d01c822c950ae2eb137d39"))
+(define-public sbcl-maxpc
+ (let ((commit "e5e58d053039517d30fd59ab2d128256b87790d5")
+ (revision "1"))
(package
- (name "sbcl-computable-reals")
- (version (git-version "1.1.0" "1" commit))
+ (name "sbcl-maxpc")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/stylewarning/computable-reals";)
+ (url "https://github.com/eugeneia/maxpc";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0f12axi53x14l12dgf4a1lfq3p1fx7fh7sjfc0db3lk88ph9qfwl"))))
+ (base32 "15wrjbr2js6j67c1dd4p2qxj49q9iqv1lhb7cwdcwpn79crr39gf"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/stylewarning/computable-reals";)
- (synopsis "Arbitrary-precision, re-computing real-numbers in Common
Lisp")
+ (home-page "https://mr.gy/software/maxpc/api.html";)
+ (synopsis
+ "Library for writing parsers and lexers based on combinatory parsing")
(description
- "This library provides arbitrary precision (floating point) real
-numbers in Common Lisp.")
- (license license:bsd-3))))
+ "@emph{Max’s Parser Combinators} is a simple and pragmatic library for
+writing parsers and lexers based on combinatory parsing. MaxPC is capable of
+parsing deterministic, context-free languages, provides powerful tools for
+parse tree transformation and error handling, and can operate on
+@dfn{sequences} and @dfn{streams}. It supports unlimited backtracking, but
+does not implement @url{http://pdos.csail.mit.edu/~baford/packrat/thesis/,
+Packrat Parsing}. Instead, MaxPC achieves good performance through its
+optimized primitives, and explicit separation of matching and capturing input.
+In practice, MaxPC parsers perform better on typical computer languages—when
+compared to Packrat parsers—at the expense of not producing linear-time
+parsers.")
+ (license license:agpl3))))
-(define-public ecl-computable-reals
- (sbcl-package->ecl-package sbcl-computable-reals))
+(define-public cl-maxpc
+ (sbcl-package->cl-source-package sbcl-maxpc))
-(define-public cl-computable-reals
- (sbcl-package->cl-source-package sbcl-computable-reals))
-
-(define-public sbcl-policy-cond
- (let ((commit "eedb625520175bfdf44d385ff3b21039b7f75706")
- (revision "0"))
- (package
- (name "sbcl-policy-cond")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/stylewarning/policy-cond";)
- (commit commit)))
- (file-name (git-file-name "cl-policy-cond" version))
- (sha256
- (base32 "0xj2a6lcg7i7g4038sc4f641din6m8vdiha8c5afz9fik80bshxk"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/stylewarning/policy-cond";)
- (synopsis "Insert code based on compiler policy")
- (description "POLICY-COND provides tools to insert and execute code
-based on a compiler's OPTIMIZE policy. It also contains a contract-like notion
-of expectations, which allow dynamic checking or inclusion of various things
-that should happen depending on compiler policy.")
- (license license:bsd-3))))
-
-(define-public cl-policy-cond
- (sbcl-package->cl-source-package sbcl-policy-cond))
-
-(define-public ecl-policy-cond
- (sbcl-package->ecl-package sbcl-policy-cond))
+(define-public ecl-maxpc
+ (sbcl-package->ecl-package sbcl-maxpc))
-(define-public sbcl-html-template
+(define-public sbcl-mcclim
(package
- (name "sbcl-html-template")
- (version "0.9.2")
+ (name "sbcl-mcclim")
+ (version "0.9.8")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/html-template";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (url "https://codeberg.org/McCLIM/McCLIM";)
+ (commit (string-append version "-yule"))))
+ (file-name (git-file-name "cl-mcclim" version))
(sha256
- (base32 "0wz3czvjsn4x971dsiia9f9nvvcmbkablcl75zsvxndkimc93wxb"))))
+ (base32 "0gbi61jnnsz6fvhv18mf57jkq46bvcd0355vqdcnrni7xyi10sk8"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://edicl.github.io/html-template/";)
- (synopsis "HTML templates from Common Lisp")
+ (native-inputs
+ (list sbcl-fiveam pkg-config))
+ (inputs
+ (list fontconfig
+ freetype
+ harfbuzz
+ sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cffi
+ sbcl-cl-base64
+ sbcl-cl-dejavu
+ sbcl-cl-freetype2
+ sbcl-cl-pdf
+ sbcl-cl-unicode
+ sbcl-cl-vectors
+ sbcl-cl-who
+ sbcl-closer-mop
+ sbcl-cluffer
+ sbcl-clx
+ sbcl-flexi-streams
+ sbcl-flexichain
+ sbcl-log4cl
+ sbcl-lorem-ipsum
+ sbcl-opticl
+ sbcl-slime-swank
+ sbcl-spatial-trees
+ sbcl-trivial-features
+ sbcl-trivial-garbage
+ sbcl-trivial-gray-streams
+ sbcl-zpb-ttf))
+ (arguments
+ '(#:asd-systems '("mcclim"
+ "clim-examples"
+ ;; clim-debugger is required by cleavir.
+ "clim-debugger")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "Extensions/fontconfig/src/functions.lisp"
+ (("libfontconfig\\.so")
+ (search-input-file inputs "/lib/libfontconfig.so")))
+ (substitute* "Extensions/harfbuzz/src/functions.lisp"
+ (("libharfbuzz\\.so")
+ (search-input-file inputs "/lib/libharfbuzz.so"))))))))
+ (home-page "https://mcclim.common-lisp.dev/";)
+ (synopsis "Common Lisp GUI toolkit")
(description
- "HTML-TEMPLATE is a Common Lisp library which can be used to fill
-templates with arbitrary (string) values at runtime. The result does not have
-to be HTML.
-
-It is loosely modeled after the Perl module @code{HTML::Template} and
-partially compatible with a its syntax, though both libraries contain some
-extensions that the other does not support.
-
-HTML-TEMPLATE translates templates into efficient closures which can be
-re-used as often as needed. It uses a cache mechanism so you can update
-templates while your program is running and have the changes take effect
-immediately.")
- (license license:bsd-2)))
+ "McCLIM is an implementation of the @emph{Common Lisp Interface Manager
+specification}, a toolkit for writing GUIs in Common Lisp.")
+ (license license:lgpl2.1+)))
-(define-public ecl-html-template
- (sbcl-package->ecl-package sbcl-html-template))
+(define-public cl-mcclim
+ (sbcl-package->cl-source-package sbcl-mcclim))
-(define-public cl-html-template
- (sbcl-package->cl-source-package sbcl-html-template))
+(define-public ecl-mcclim
+ (let ((pkg (sbcl-package->ecl-package sbcl-mcclim)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; Tests fail with "FUNCTION: Not a valid argument (R1
+ ;; (GENERATE-REGION))." on ECL.
+ ((#:tests? _ #f) #f))))))
-(define-public sbcl-quickproject
+(define-public sbcl-md5
(package
- (name "sbcl-quickproject")
- (version "1.4.1")
+ (name "sbcl-md5")
+ (version "2.0.5")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/xach/quickproject";)
- (commit (string-append "release-" version))))
- (file-name (git-file-name name version))
+ (url "https://github.com/pmai/md5";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name "md5" version))
(sha256
- (base32 "1szs8p2wr1yr9mjmj3h3557l6wxzzga0iszimb68z0hb1jj3lva6"))))
+ (base32 "1g20np6rhn3y08z8mlmlk721mw2207s52v2pwp4smm3lz25sx3q5"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("cl-fad" ,sbcl-cl-fad)
- ("html-template" ,sbcl-html-template)))
- (home-page "https://xach.com/lisp/quickproject/";)
- (synopsis "Create Common Lisp project skeletons")
+ (home-page "https://github.com/pmai/md5";)
+ (synopsis
+ "Common Lisp implementation of the MD5 Message-Digest Algorithm (RFC
1321)")
(description
- "Quickproject provides a quick way to make a Common Lisp project. After
-creating a project, it extends the ASDF registry so the project may be
-immediately loaded.")
- (license license:expat)))
-
-(define-public ecl-quickproject
- (sbcl-package->ecl-package sbcl-quickproject))
-
-(define-public cl-quickproject
- (sbcl-package->cl-source-package sbcl-quickproject))
-
-(define-public sbcl-bodge-math
- (let ((commit "9159b7faf88d440024c07110dbef2abddb20b9af")
- (revision "1"))
- (package
- (name "sbcl-bodge-math")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/borodust/bodge-math";)
- (commit commit)))
- (file-name (git-file-name "bodge-math" version))
- (sha256
- (base32 "0r3vnl9lywn4ksy34apcv6j825qp7l1naddawr14v4lwacndb80v"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bodge-utilities sbcl-rtg-math))
- (home-page "https://github.com/borodust/bodge-math";)
- (synopsis "Common Lisp core math utilities of BODGE library collection")
- (description
- "This Common Lisp package contains the core math utilities of the
-@emph{Bodge} library collection.")
- (license license:expat))))
+ "This package implements The MD5 Message-Digest Algorithm, as defined in
+RFC 1321 by R. Rivest, published April 1992.")
+ (license license:public-domain)))
-(define-public ecl-bodge-math
- (sbcl-package->ecl-package sbcl-bodge-math))
+(define-public cl-md5
+ (sbcl-package->cl-source-package sbcl-md5))
-(define-public cl-bodge-math
- (sbcl-package->cl-source-package sbcl-bodge-math))
+(define-public ecl-md5
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-md5))
+ (inputs
+ (list ecl-flexi-streams))))
-(define-public sbcl-cl-mathstats
- (let ((commit "4df38ea1b9de069cf939919253565a9ca9538eca")
+(define-public sbcl-messagebox
+ (let ((commit "ea3688d9a9954bee7079c0173bc7b3f327021e9f")
(revision "1"))
(package
- (name "sbcl-cl-mathstats")
- (version (git-version "0.8.2" revision commit))
+ (name "sbcl-messagebox")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/cl-mathstats";)
+ (url "https://github.com/Shinmera/messagebox";)
(commit commit)))
- (file-name (git-file-name "cl-mathstats" version))
+ (file-name (git-file-name "messagebox" version))
(sha256
- (base32 "0gsjvmkmnxc4hp5z9mkm5vsllywqyg7kx8jgz88vnx47yj3va1s8"))))
+ (base32 "0jkbzlca0wvspgsfj0b0hjwlyyy8jlywsldsbkp79q48fc3aa8jd"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lift))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-zenity-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "zenity.lisp"
+ (("\"zenity\"")
+ (string-append "\"" (assoc-ref inputs "zenity")
+ "/bin/zenity\""))))))))
(inputs
- (list sbcl-cl-containers sbcl-metatilities-base))
- (home-page "https://github.com/hraban/cl-mathstats";)
- (synopsis "Common Lisp collection of mathematical routines")
+ `(("documentation-utils" ,sbcl-documentation-utils)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("zenity" ,zenity)))
+ (home-page "https://shinmera.github.io/messagebox/";)
+ (synopsis "Display a native GUI message box")
(description
- "This package provides Common Lisp math and statistics routines.")
- (license license:expat))))
+ "This is a small library to display a native GUI message box. This can
be
+useful to show error messages and other informational pieces should the
+application fail and be unable to do so using its standard UI.")
+ (license license:zlib))))
-(define-public ecl-cl-mathstats
- (sbcl-package->ecl-package sbcl-cl-mathstats))
+(define-public cl-messagebox
+ (sbcl-package->cl-source-package sbcl-messagebox))
-(define-public cl-mathstats
- (sbcl-package->cl-source-package sbcl-cl-mathstats))
+(define-public ecl-messagebox
+ (sbcl-package->ecl-package sbcl-messagebox))
-(define-public sbcl-bodge-blobs-support
- (let ((commit "c5034ca5f4fc3a44dbadeba215a09afd59a404b0")
- (revision "1"))
+(define-public sbcl-meta
+ (let ((commit "74faea662139fbbfb9c99341aaed989f5b0e9da3")
+ (revision "0"))
(package
- (name "sbcl-bodge-blobs-support")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/borodust/bodge-blobs-support";)
- (commit commit)))
- (file-name (git-file-name "bodge-blobs-support" version))
- (sha256
- (base32 "02nd1x6y1akp1ymv1y4z9ympwbnpd1drwi4f86xbjszxqff6jyj8"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-trivial-features))
- (inputs
- (list sbcl-cffi sbcl-alexandria))
- (home-page "https://github.com/borodust/bodge-blobs-support";)
- (synopsis "Common Lisp utilities for blob packages")
- (description
- "This is a Common Lisp library for simplifying packaging and loading of
-compiled foreign library collection.")
- (license license:unlicense))))
-
-(define-public cl-bodge-blobs-support
- (sbcl-package->cl-source-package sbcl-bodge-blobs-support))
-
-(define-public ecl-bodge-blobs-support
- (sbcl-package->ecl-package sbcl-bodge-blobs-support))
-
-(define-public sbcl-cl-conspack
- (let ((commit "6e529d7b3a7223ef1bb5c7b9f18384ba67b50b09")
- (revision "2"))
- (package
- (name "sbcl-cl-conspack")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/conspack/cl-conspack";)
- (commit commit)))
- (file-name (git-file-name "cl-conspack" version))
- (sha256
- (base32 "0y5wp5c89ph44k2xjppy1c1jf2ac3q9yrk22da2rkwnbxn0h1a8d"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-test-systems '("cl-conspack-test")))
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-fast-io
- sbcl-ieee-floats
- sbcl-trivial-garbage
- sbcl-trivial-utf-8))
- (home-page "https://github.com/conspack/cl-conspack";)
- (synopsis "CONSPACK implementation for Common Lisp")
- (description
- "This package provides a CONSPACK implementation for Common Lisp.")
- (license license:bsd-3))))
-
-(define-public ecl-cl-conspack
- (sbcl-package->ecl-package sbcl-cl-conspack))
-
-(define-public cl-conspack
- (sbcl-package->cl-source-package sbcl-cl-conspack))
-
-(define-public sbcl-binpack
- (let ((commit "e67f56bb697bdeac81e28e1cca4a5d117a9cf125")
- (revision "1"))
- (package
- (name "sbcl-binpack")
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/lispgames/binpack";)
- (commit commit)))
- (file-name (git-file-name "binpack" version))
- (sha256
- (base32 "1pcnsg60pqywd3k72m5pwimq01sm3jyvc1c3rbkij740r7grdxi1"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/lispgames/binpack";)
- (synopsis "Common Lisp rectangle packer for sprite/texture atlases")
- (description
- "This library features a rectangle packer for sprite and texture
atlases.")
- (license license:expat))))
-
-(define-public ecl-binpack
- (sbcl-package->ecl-package sbcl-binpack))
-
-(define-public cl-binpack
- (sbcl-package->cl-source-package sbcl-binpack))
-
-(define-public sbcl-cl-opengl
- (let ((commit "e2d83e0977b7e7ac3f3d348d8ccc7ccd04e74d59")
- (revision "1"))
- (package
- (name "sbcl-cl-opengl")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-meta")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/cl-opengl";)
+ (url "https://gitlab.common-lisp.net/frideau/meta";)
(commit commit)))
- (file-name (git-file-name "cl-opengl" version))
+ (file-name (git-file-name "cl-meta" version))
(sha256
- (base32 "0mhqmll09f079pnd6mgswz9nvr6h5n27d4q7zpmm2igf1v460id7"))))
+ (base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("cl-opengl" "cl-glu" "cl-glut")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gl/library.lisp"
- (("libGL.so" all)
- (search-input-file inputs "/lib/libGL.so")))
- (substitute* "glu/library.lisp"
- (("libGLU.so" all)
- (search-input-file inputs "/lib/libGLU.so")))
- (substitute* "glut/library.lisp"
- (("libglut.so" all)
- (search-input-file inputs "/lib/libglut.so"))))))))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("float-features" ,sbcl-float-features)
- ("freeglut" ,freeglut)
- ("glu" ,glu)
- ("mesa" ,mesa)))
- (home-page "https://github.com/3b/cl-opengl";)
- (synopsis "Common Lisp bindings to OpenGL, GLU and GLUT APIs")
+ (list sbcl-named-readtables))
+ (home-page "https://gitlab.common-lisp.net/frideau/meta";)
+ (synopsis "Recursive-descent parser DSL for Common Lisp")
(description
- "This package provides a set of bindings and utilities for accessing the
-OpenGL (Mesa), GLU and GLUT (FreeGLUT) APIs using CFFI.")
- (license license:bsd-3))))
+ "This package provides a recursive-descent parser DSL for Common Lisp.
+It's intended as a simpler alternative to parser generators.")
+ (license license:bsd-2))))
-(define-public ecl-cl-opengl
- (sbcl-package->ecl-package sbcl-cl-opengl))
+(define-public cl-meta
+ (sbcl-package->cl-source-package sbcl-meta))
-(define-public cl-opengl
- (sbcl-package->cl-source-package sbcl-cl-opengl))
+(define-public ecl-meta
+ (sbcl-package->ecl-package sbcl-meta))
-(define-public sbcl-shadow
- (let ((commit "b2031adbfba3579b48c9d39ad997e19b79b6852f")
- (revision "1"))
+(define-public sbcl-metabang-bind
+ (let ((commit "08196426cb099db0623e6cae2aeca566e0b788b2")
+ (revision "2"))
(package
- (name "sbcl-shadow")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-metabang-bind")
+ (version (git-version "0.8.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.mfiano.net/mfiano/shadow";)
+ (url "https://github.com/hraban/metabang-bind";)
(commit commit)))
- (file-name (git-file-name "shadow" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0w1i734gkdkziin74ql2nhx7jdjxx02ylssaa6qdrvnj4br1124a"))))
+ (base32
+ "14g7k3zhm8cd6bssc5mm5h6iq1dv5lfhiq33aimcmj5a6vbiq47d"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cffi
- sbcl-cl-opengl
- sbcl-glsl-packing
- sbcl-golden-utils
- sbcl-static-vectors
- sbcl-varjo))
- (home-page "https://git.mfiano.net/mfiano/shadow";)
- (synopsis "Management system for OpenGL shader programs")
+ (native-inputs
+ (list sbcl-lift))
+ (synopsis "Macro that generalizes @code{multiple-value-bind} etc.")
(description
- "This package provides a Common Lisp library for defining OpenGL shader
-programs. There are also functions for referencing shader programs by name,
-querying for basic information about them, modifying uniform variables
-throughout the lifecycle of an OpenGL application, and managing certain OpenGL
-buffer object types (UBO, SSBO currently).")
+ "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 ecl-shadow
- (sbcl-package->ecl-package sbcl-shadow))
+(define-public cl-metabang-bind
+ (sbcl-package->cl-source-package sbcl-metabang-bind))
-(define-public cl-shadow
- (sbcl-package->cl-source-package sbcl-shadow))
+(define-public ecl-metabang-bind
+ (sbcl-package->ecl-package sbcl-metabang-bind))
-(define-public sbcl-umbra
- (let ((commit "d6ef2f6cbfa26180929061129eaf325bf17f73d8")
- (revision "1"))
+(define-public sbcl-metacopy
+ (let ((commit "df7856f2a43fa91124fe780ef22f792040bc130c")
+ (revision "2"))
(package
- (name "sbcl-umbra")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-metacopy")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.mfiano.net/mfiano/umbra";)
+ ;; Upstream changed the maintaner.
+ ;; legacy https://github.com/gwkkwg/metacopy
+ (url "https://github.com/hraban/metacopy";)
(commit commit)))
- (file-name (git-file-name "umbra" version))
+ (file-name (git-file-name "cl-metacopy" version))
(sha256
- (base32 "04vyh2j00zdpb8ryxr8g81wjcmqlz9wrn55r3cypcj4qg970r5wi"))))
+ (base32 "0l5ryg8pvqz9sn9s8bsvd0plvcnm7crsx86iqk5wxblkialaizip"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-asdf-system-connections sbcl-lift))
(inputs
- (list sbcl-golden-utils sbcl-shadow sbcl-varjo))
- (home-page "https://git.mfiano.net/mfiano/umbra";)
- (synopsis "Common Lisp library of reusable GPU shader functions")
+ (list sbcl-contextl sbcl-moptilities))
+ (home-page "https://github.com/hraban/metacopy";)
+ (synopsis "Flexible Common Lisp shallow/deep copy mechanism")
(description
- "This is a Common Lisp library consisting of a collection of useful GPU
-shader functions, written with @code{Shadow}.")
+ "This package provides a flexible shallow/deep copy mechanism for
+Common Lisp.")
(license license:expat))))
-(define-public ecl-umbra
- (sbcl-package->ecl-package sbcl-umbra))
+(define-public cl-metacopy
+ (sbcl-package->cl-source-package sbcl-metacopy))
-(define-public cl-umbra
- (sbcl-package->cl-source-package sbcl-umbra))
+(define-public ecl-metacopy
+ (sbcl-package->ecl-package sbcl-metacopy))
-(define-public sbcl-abstract-classes
- (let ((commit "7fa74f1e057f9ba7c1ffecff14f049f979e45267")
- (revision "1"))
+(define-public sbcl-metatilities-base
+ (let ((commit "ef04337759972fd622c9b27b53149f3d594a841f")
+ (revision "2"))
(package
- (name "sbcl-abstract-classes")
- (version (git-version "1.7.0" revision commit))
+ (name "sbcl-metatilities-base")
+ (version (git-version "0.6.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://bitbucket.org/eeeickythump/cl-abstract-classes";)
+ (url "https://github.com/hraban/metatilities-base";)
(commit commit)))
- (file-name (git-file-name "cl-abstract-classes" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "06lby4i6xbbgs7kgb0f3fqybvyskyg6djhrf967lnysv7hn3zpg9"))))
+ (base32
+ "069rk5ncwvjnnzvvky6xiriynl72yzvjpnzl6jw9jf3b8na14zrk"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("closer-mop" ,sbcl-closer-mop)))
- (arguments
- `(#:asd-systems '("abstract-classes" "singleton-classes")))
- (home-page "https://bitbucket.org/eeeickythump/cl-abstract-classes";)
- (synopsis "Abstract, final, and singleton metaclasses for CLOS")
+ (native-inputs
+ (list sbcl-lift))
+ (synopsis "Core of the metatilities Common Lisp library")
(description
- "This package provides Common Lisp extension to the MOP to allow
-abstract, final and singleton classes.")
- (license license:public-domain))))
+ "Metatilities-base is the core of the metatilities Common Lisp library
+which implements a set of utilities.")
+ (home-page "https://common-lisp.net/project/metatilities-base/";)
+ (license license:expat))))
-(define-public ecl-abstract-classes
- (sbcl-package->ecl-package sbcl-abstract-classes))
+(define-public cl-metatilities-base
+ (sbcl-package->cl-source-package sbcl-metatilities-base))
-(define-public cl-abstract-classes
- (sbcl-package->cl-source-package sbcl-abstract-classes))
+(define-public ecl-metatilities-base
+ (sbcl-package->ecl-package sbcl-metatilities-base))
-(define-public sbcl-coalton
- (let ((commit "939342495f55991812c2c2767322c5e51e755216")
- (revision "4"))
+(define-public sbcl-metering
+ (let ((commit "62dbaa5e8d29d2f213b881d740114941c2c3d1be")
+ (revision "0"))
(package
- (name "sbcl-coalton")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-metering")
+ (version (git-version "3.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/coalton-lang/coalton";)
+ (url "https://gitlab.common-lisp.net/dkochmanski/metering";)
(commit commit)))
- (file-name (git-file-name "cl-coalton" version))
+ (file-name (git-file-name "cl-metering" version))
(sha256
- (base32 "08qzj3v4fvn9h87whyqg650rpap8lva7jr94d1akv6m2z62l5q68"))))
+ (base32 "0jx3ypk8m815yp7208xkcxkvila847mvna25a2p22ihnj0ms9rn1"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiasco))
- (inputs
- (list sbcl-alexandria
- sbcl-concrete-syntax-tree
- sbcl-eclector
- sbcl-float-features
- sbcl-fset
- sbcl-named-readtables
- sbcl-trivial-garbage))
- (home-page "https://coalton-lang.github.io";)
- (synopsis "Dialect of ML in Common Lisp")
+ (native-inputs (list sbcl-fiveam))
+ (synopsis "Common Lisp code profiling tool")
(description
- "Coalton is a dialect of ML embedded in Common Lisp. It emphasizes
-practicality and interoperability with Lisp, and is intended to be a DSL that
-allows one to gradually make their programs safer.")
- (license license:expat))))
+ "The Metering System is a portable Common Lisp code profiling tool.
+It gathers timing and consing statistics for specified functions while
+a program is running.")
+ (home-page "https://gitlab.common-lisp.net/dkochmanski/metering";)
+ (license license:public-domain))))
-(define-public ecl-coalton
- (sbcl-package->ecl-package sbcl-coalton))
+(define-public cl-metering
+ (sbcl-package->cl-source-package sbcl-metering))
-(define-public cl-coalton
- (sbcl-package->cl-source-package sbcl-coalton))
+(define-public ecl-metering
+ (sbcl-package->ecl-package sbcl-metering))
-(define-public sbcl-clip
- (let ((commit "7afa68702fbb99c47ed115ea0faccd97a29d9b2e")
+(define-public sbcl-mgl-gpr
+ (let ((commit "cb6ce51e2f87bf1d589f3703c13eea6e25780afe")
(revision "1"))
(package
- (name "sbcl-clip")
- (version (git-version "0.7.0" revision commit))
+ (name "sbcl-mgl-gpr")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/shinmera/clip";)
+ (url "https://github.com/melisgl/mgl-gpr";)
(commit commit)))
- (file-name (git-file-name "clip" version))
+ (file-name (git-file-name "cl-mgl-gpr" version))
(sha256
- (base32 "13kkajkva2shm19fvn4yashsw18l6imv2rmy3hmpcky7g5ay7bv3"))))
+ (base32 "0w51dqixh277k6sl8bqvvp1400y6kd1l5h3d9q2f40l9bpxy8gjx"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-array-utils sbcl-lquery))
- (home-page "https://shinmera.github.io/clip/";)
- (synopsis "Common Lisp HTML templating engine")
+ (list sbcl-cl-random sbcl-mgl-pax))
+ (home-page "https://melisgl.github.io/mgl-gpr/";)
+ (synopsis "Common Lisp library of evolutionary algorithms")
(description
- "Clip is an attempt at a templating library that allows you to write
-templates in a way that is both accessible to direct webdesign and
-flexible. The main idea is to incorporate transformation commands into an HTML
-file through tags and attributes. Clip is heavily dependent on Plump and
-lQuery.")
- (license license:zlib))))
+ "@code{MGL-GPR} is a library of evolutionary algorithms such as
+Genetic Programming (evolving typed expressions from a set of operators and
+constants) and Differential Evolution.")
+ (license license:expat))))
-(define-public ecl-clip
- (sbcl-package->ecl-package sbcl-clip))
+(define-public cl-mgl-gpr
+ (sbcl-package->cl-source-package sbcl-mgl-gpr))
-(define-public cl-clip
- (sbcl-package->cl-source-package sbcl-clip))
+(define-public ecl-mgl-gpr
+ (sbcl-package->ecl-package sbcl-mgl-gpr))
-(define-public sbcl-pathname-utils
- (let ((commit "f28068a79825f37002e96d13dfd739172382bf94")
- (revision "3"))
+(define-public sbcl-mgl-pax
+ (let ((commit "6782eb041c152721972420dfafa192692d16b7ce")
+ (revision "1"))
(package
- (name "sbcl-pathname-utils")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-mgl-pax")
+ (version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/pathname-utils";)
+ (url "https://github.com/melisgl/mgl-pax";)
(commit commit)))
- (file-name (git-file-name "cl-pathname-utils" version))
(sha256
- (base32 "10xs0wnnkbdiirr1cb7q7hzi2zmksfsrj0p7yws0j1l215vz8qs8"))))
+ (base32 "0fjbzc2fn17m80lfsc8121sa0bk7fg42fqlwhm01sk1fj4s48pma"))
+ (file-name (git-file-name "cl-mgl-pax" version))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
+ ;; (native-inputs
+ ;; (list sbcl-try))
(inputs
- (list sbcl-trivial-features))
- (home-page "https://shinmera.github.io/pathname-utils/";)
- (synopsis "Collection of utilities to help with pathname operations")
+ (list sbcl-3bmd
+ sbcl-alexandria
+ sbcl-colorize
+ sbcl-md5
+ sbcl-named-readtables
+ sbcl-pythonic-string-reader
+ sbcl-slime-swank
+ sbcl-trivial-utf-8))
+ (arguments
+ `(#:asd-systems '("mgl-pax"
+ "mgl-pax/navigate"
+ "mgl-pax/document"
+ "mgl-pax/transcribe")
+ ;; Tests disabled because of a circular dependency
+ ;; try -> mgl-pax -> try
+ #:tests? #f))
+ (synopsis "Exploratory programming environment and documentation
generator")
(description
- "This package provides a Common Lisp system a with collection of common
-tests and operations to help handling pathnames. It does not actually deal in
-handling the accessing of files on the underlying system however.")
- (license license:zlib))))
-
-(define-public ecl-pathname-utils
- (package
- (inherit (sbcl-package->ecl-package sbcl-pathname-utils))
- (arguments
- `(;; FIXME: It might be an issue in implementation of UIOP for ECL:
- ;;
- ;; Condition of type: TYPE-ERROR
- ;; :HOME is not of type SEQUENCE.
- ;; Available restarts:
- ;; 1. (RESTART-TOPLEVEL) Go back to Top-Level REPL.
- ;; Broken at SI:BYTECODES. [Evaluation of: (MAKE-PATHNAME :DIRECTORY
- ;; '(:ABSOLUTE :HOME))] In: #<process TOP-LEVEL 0x7faa2f991f80>.
- ;;
- #:tests? #f))))
+ "PAX provides an extremely poor man's Explorable Programming
+environment. Narrative primarily lives in so called sections that mix markdown
+docstrings with references to functions, variables, etc, all of which should
+probably have their own docstrings.
-(define-public cl-pathname-utils
- (sbcl-package->cl-source-package sbcl-pathname-utils))
+The primary focus is on making code easily explorable by using SLIME's
+@command{M-.} (@command{slime-edit-definition}). See how to enable some
+fanciness in Emacs Integration. Generating documentation from sections and all
+the referenced items in Markdown or HTML format is also implemented.
-(define-public sbcl-terrable
- (let ((commit "e4fe23ffa08e8d53a8168105b413861da59cc786")
- (revision "1"))
- (package
- (name "sbcl-terrable")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shirakumo/terrable";)
- (commit commit)))
- (file-name (git-file-name "terrable" version))
- (sha256
- (base32 "0pnqflgz410zydc1ivwnd8hcl24bgr7x12yjzr7g4lq3ibc8y97b"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-documentation-utils sbcl-fast-io sbcl-ieee-floats
- sbcl-static-vectors sbcl-trivial-garbage))
- (home-page "https://shirakumo.github.io/terrable/";)
- (synopsis "Parser library for Terragen TER terrain files")
- (description
- "This package provides Common Lisp support for reading the Terragen
-@code{.TER} format. The format specification can be found at
-@url{https://planetside.co.uk/wiki/index.php?title=Terragen_.TER_Format}";)
- (license license:zlib))))
+With the simplistic tools provided, one may accomplish similar effects as with
+Literate Programming, but documentation is generated from code, not vice versa
+and there is no support for chunking yet. Code is first, code must look
+pretty, documentation is code.")
+ (home-page "https://melisgl.github.io/mgl-pax/";)
+ (license license:expat))))
-(define-public ecl-terrable
- (sbcl-package->ecl-package sbcl-terrable))
+(define-public cl-mgl-pax
+ (sbcl-package->cl-source-package sbcl-mgl-pax))
-(define-public cl-terrable
- (sbcl-package->cl-source-package sbcl-terrable))
+(define-public ecl-mgl-pax
+ (sbcl-package->ecl-package sbcl-mgl-pax))
-(define-public sbcl-simple-rgb
- (let ((commit "ba9b0689362c28aa6a91c0636796c6c372657293")
+(define-public sbcl-mgrs
+ (let ((commit "c06f268f9ccb00dfc94c8a07771ce1ca82df26a2")
(revision "1"))
(package
- (name "sbcl-simple-rgb")
- (version (git-version "0.01" revision commit))
+ (name "sbcl-mgrs")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/wmannis/simple-rgb/";)
+ (url "https://codeberg.org/glv/mgrs";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mgrs" version))
(sha256
- (base32 "0ggv0h2n4mvwnggjr1b40gw667gnyykzki2zadaczi38ydzyzlp1"))))
+ (base32 "1n4kd734qjj7mrcg0q28hml3npam1rm067iwljwc87zshnxh5gmn"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/wmannis/simple-rgb";)
- (synopsis "Manipulate colors in RGB format")
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-utm-ups))
+ (synopsis
+ "Convert coordinates between latitude/longitude and MGRS")
(description
- "This Common Lisp library focuses on the small set of basic color
-manipulations (lightening, compliments, etc.) you might use to generate a
-color palette for a GUI or web page.")
- (license license:bsd-2))))
+ "This a Common Lisp library to convert geographic coordinates between
+latitude/longitude and MGRS.")
+ (home-page "https://codeberg.org/glv/mgrs";)
+ (license license:gpl3+))))
-(define-public ecl-simple-rgb
- (sbcl-package->ecl-package sbcl-simple-rgb))
+(define-public cl-mgrs
+ (sbcl-package->cl-source-package sbcl-mgrs))
-(define-public cl-simple-rgb
- (sbcl-package->cl-source-package sbcl-simple-rgb))
+(define-public ecl-mgrs
+ (sbcl-package->ecl-package sbcl-mgrs))
-(define-public sbcl-cl-qprint
- (let ((commit "bfe398551cbfb7ca84a9ba59a26a1116ac5c06eb")
+(define-public sbcl-misc-extensions
+ (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
(revision "1"))
(package
- (name "sbcl-cl-qprint")
- (version (git-version "0.9.0" revision commit))
+ (name "sbcl-misc-extensions")
+ (version (git-version "3.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eugeneia/cl-qprint/";)
+ (url "https://gitlab.common-lisp.net/misc-extensions/devel.git";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "099h0rrdzxnlmn8avi72mg2dl0kccp7w01b2p9nwyy4b8yr32cir"))))
+ (base32
+ "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-flexi-streams))
- (home-page "https://github.com/eugeneia/cl-qprint/";)
- (synopsis "Implementation of the quoted-printable encoding")
+ (synopsis "Collection of small macros and extensions for Common Lisp")
(description
- "This Common Lisp library implements the quoted-printable encoding as
-described in RFC 2045 (see @url{http://tools.ietf.org/html/rfc2045}).")
- (license license:lgpl2.1))))
+ "This project is intended as a catchall for small, general-purpose
+extensions to Common Lisp. It contains:
-(define-public ecl-cl-qprint
- (sbcl-package->ecl-package sbcl-cl-qprint))
+@itemize
+@item @code{new-let}, a macro that combines and generalizes @code{let},
+@code{let*} and @code{multiple-value-bind},
+@item @code{gmap}, an iteration macro that generalizes @code{map}.
+@end itemize\n")
+ (home-page "https://common-lisp.net/project/misc-extensions/";)
+ (license license:public-domain))))
-(define-public cl-qprint
- (sbcl-package->cl-source-package sbcl-cl-qprint))
+(define-public cl-misc-extensions
+ (sbcl-package->cl-source-package sbcl-misc-extensions))
-(define-public sbcl-cl-mime
- (let ((commit "d30a28e0a40393bd3af7d138daa05319ed2e9d07")
- (revision "1"))
+(define-public ecl-misc-extensions
+ (sbcl-package->ecl-package sbcl-misc-extensions))
+
+(define-public sbcl-mito
+ (let ((commit "47ba4865ca4bb2894b53703a49a299e973f8eb86")
+ (revision "3"))
(package
- (name "sbcl-cl-mime")
- ;; One commit says "update to cl-mime-0.5.3", even though the .asd is at
0.5.1.
- (version (git-version "0.5.3" revision commit))
+ (name "sbcl-mito")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/fukamachi/mito";)
(source
(origin
(method git-fetch)
(uri (git-reference
- ;; Maintained fork according to http://www.cliki.net/CL-MIME:
- (url "https://github.com/40ants/cl-mime";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "mito" version))
(sha256
- (base32 "0qn8if0fj6vzc897pqqqs0m1y107gmzqngpqhqmwrcsp1ckj5k0v"))))
+ (base32 "0313nxlj1zqw6zyc23xpf85v0jk32sg0543ql8363jki0pmg7yhs"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-ppcre sbcl-cl-base64 sbcl-cl-qprint))
(native-inputs
- (list sbcl-rove))
- (home-page "https://github.com/40ants/cl-mime/";)
- (synopsis "Read and print MIME content in Common Lisp")
- (description
- "This is a Common Lisp library for reading and printing MIME content.
-It supports automatic conversion between 7-bit, quoted-printable and base64
-encodings.")
- (license license:lgpl2.1))))
+ (list sbcl-prove))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-package-locks" ,sbcl-cl-package-locks)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("cl-reexport" ,sbcl-cl-reexport)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("dbi" ,sbcl-dbi)
+ ("dissect" ,sbcl-dissect)
+ ("esrap" ,sbcl-esrap)
+ ("local-time" ,sbcl-local-time)
+ ("sxql" ,sbcl-sxql)
+ ("trivia" ,sbcl-trivia)
+ ("uuid" ,sbcl-uuid)))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'remove-non-functional-tests
+ (lambda _
+ (substitute* "mito-test.asd"
+ (("\\(:test-file \"db/mysql\"\\)") "")
+ (("\\(:test-file \"db/postgres\"\\)") "")
+ (("\\(:test-file \"dao\"\\)") "")
+ ;; TODO: migration/sqlite3 should work, re-enable once
+ ;; upstream has fixed it:
+ ;; https://github.com/fukamachi/mito/issues/70
+ (("\\(:test-file \"migration/sqlite3\"\\)") "")
+ (("\\(:test-file \"migration/mysql\"\\)") "")
+ (("\\(:test-file \"migration/postgres\"\\)") "")
+ (("\\(:test-file \"postgres-types\"\\)") "")
+ (("\\(:test-file \"mixin\"\\)") ""))
+ #t)))
+ #:asd-systems '("mito-test" "mito")))
+ (synopsis "ORM for Common Lisp with migrations and relationships
support")
+ (description "Mito is yet another object relational mapper, and it aims
+to be a successor of Integral.
-(define-public ecl-cl-mime
- (sbcl-package->ecl-package sbcl-cl-mime))
+@itemize
+@item Support MySQL, PostgreSQL and SQLite3.
+@item Add id (serial/uuid primary key), created_at and updated_at by default
+like Ruby's ActiveRecord.
+@item Migrations.
+@item Database schema versioning.
+@end itemize\n")
+ (license license:llgpl))))
-(define-public cl-mime
- (sbcl-package->cl-source-package sbcl-cl-mime))
+(define-public cl-mito
+ (sbcl-package->cl-source-package sbcl-mito))
-(define-public sbcl-cl-mimeparse
- (let ((commit "93cbdf6f6fe8a2eb5f652f8adec453eb98ea0547")
+(define-public ecl-mito
+ (sbcl-package->ecl-package sbcl-mito))
+
+(define-public sbcl-mk-string-metrics
+ (package
+ (name "sbcl-mk-string-metrics")
+ (version "0.1.2")
+ (home-page "https://github.com/cbaggers/mk-string-metrics/";)
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit version)))
+ (sha256
+ (base32 "0bg0bv2mfd4k0g3x72x563hvmrx18xavaffr6xk5rh4if5j7kcf6"))
+ (file-name (git-file-name name version))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Calculate various string metrics efficiently in Common Lisp")
+ (description "This library implements efficient algorithms that calculate
+various string metrics in Common Lisp:
+
+@itemize
+@item Damerau-Levenshtein distance
+@item Hamming distance
+@item Jaccard similarity coefficient
+@item Jaro distance
+@item Jaro-Winkler distance
+@item Levenshtein distance
+@item Normalized Damerau-Levenshtein distance
+@item Normalized Levenshtein distance
+@item Overlap coefficient
+@end itemize\n")
+ (license license:x11)))
+
+(define-public cl-mk-string-metrics
+ (sbcl-package->cl-source-package sbcl-mk-string-metrics))
+
+(define-public ecl-mk-string-metrics
+ (sbcl-package->ecl-package sbcl-mk-string-metrics))
+
+(define-public sbcl-mmap
+ (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
(revision "0"))
(package
- (name "sbcl-cl-mimeparse")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-mmap")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/cl-mimeparse";)
+ (url "https://github.com/Shinmera/mmap";)
(commit commit)))
- (file-name (git-file-name "cl-mimeparse" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0gdkpi3620va0a3q56svcn1q9f5w0pqfhx30lnldg8fjnrdfiwkk"))))
+ (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-test-systems '("cl-mimeparse-tests")))
(native-inputs
- (list sbcl-rt))
+ (list sbcl-alexandria sbcl-cffi sbcl-parachute
+ sbcl-trivial-features))
(inputs
- (list sbcl-cl-ppcre sbcl-parse-number))
- (home-page "https://github.com/mmontone/cl-mimeparse/";)
- (synopsis "Common Lisp library for parsing MIME types")
+ (list sbcl-cffi sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/mmap/";)
+ (synopsis "File memory mapping for Common Lisp")
(description
- "This package provides a library for parsing MIME types, in the spirit
-of http://code.google.com/p/mimeparse/, with a Common Lisp flavor.")
- (license license:expat))))
+ "This is a utility library providing access to the @emph{mmap} family of
+functions in a portable way. It allows you to directly map a file into the
+address space of your process without having to manually read it into memory
+sequentially. Typically this is much more efficient for files that are larger
+than a few Kb.")
+ (license license:zlib))))
-(define-public cl-mimeparse
- (sbcl-package->cl-source-package sbcl-cl-mimeparse))
+(define-public cl-mmap
+ (sbcl-package->cl-source-package sbcl-mmap))
-(define-public ecl-cl-mimeparse
- (sbcl-package->ecl-package sbcl-cl-mimeparse))
+(define-public ecl-mmap
+ (sbcl-package->ecl-package sbcl-mmap))
-(define-public sbcl-cl-mixed
- (let ((commit "4aaff134d3902d93a2a8605c10de4bcfc62d7afa")
+(define-public sbcl-modf
+ (let ((commit "dea93fe62c6bf7f66f32f52ac0c555aedbf7abad")
(revision "0"))
(package
- (name "sbcl-cl-mixed")
- (version (git-version "2.1.0" revision commit))
+ (name "sbcl-modf")
+ (version (git-version "0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-mixed";)
+ (url "https://github.com/smithzvk/modf";)
(commit commit)))
- (file-name (git-file-name "cl-mixed" version))
+ (file-name (git-file-name "cl-modf" version))
(sha256
- (base32 "1mrj95lxb1gbxxm89x8gy1ifw2ic1p5wwpapkxcd2jr8abw7zny0"))
- (modules '((guix build utils)))
- (snippet
- ;; Delete bundled libraries.
- `(begin
- (delete-file-recursively "static")))))
+ (base32
+ "1aap7ldy7lv942khp026pgndgdzfkkqa9xcq1ykinrmflrgdazay"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-mixed"
- "cl-mixed-examples"
- "cl-mixed-flac"
- "cl-mixed-vorbis"
- "cl-mixed-alsa"
- "cl-mixed-jack"
- "cl-mixed-mpg123"
- "cl-mixed-mpt"
- "cl-mixed-out123"
- "cl-mixed-pulse"
- "cl-mixed-sdl2"
- "cl-mixed-wav")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "low-level.lisp"
- (("libmixed.so.2")
- (search-input-file inputs "/lib/libmixed.so.2"))))))))
(inputs
- (list libmixed
- sbcl-alexandria
- sbcl-cffi
- sbcl-cl-flac
- sbcl-cl-mpg123
- sbcl-cl-out123
- sbcl-cl-vorbis
- sbcl-documentation-utils
- sbcl-sdl2
- sbcl-static-vectors
- sbcl-trivial-features))
- (home-page "https://shirakumo.github.io/cl-mixed/";)
- (synopsis "Extended audio library for Common Lisp")
- (description
- "This package provides CFFI binding to @code{libmixed} audio library for
-Common Lisp with support of other audio formats available on GNU/Linux systems:
-
-@itemize
-
-@item @acronym{Alsa, Advanced Linux Sound Architecture}
-@item @acronym{Jack, JackAudio toolkit}
-@item @acronym{Openmpt, Libopenmpt playback drain for tracker files}
-@item @acronym{PulseAudio, PulseAudio based playback drain}
-@item Flac (via CL-FLAC)
-@item Mpg123 (via CL-MPG123)
-@item Ogg/vorbis (via CL-VORBIS)
-@item Out123 (via CL-OUT123)
-@item WAV
-
-@end itemize")
- (license license:zlib))))
+ (list sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-iterate))
+ (native-inputs
+ (list sbcl-stefil))
+ (home-page "https://github.com/smithzvk/modf";)
+ (synopsis "SETF like macro for functional programming in Common Lisp")
+ (description "This library simplifies functional programming in Common
+Lisp by making it easier to make new data structures with specified changes in
+place.")
+ (license license:bsd-3))))
-(define-public ecl-cl-mixed
- (sbcl-package->ecl-package sbcl-cl-mixed))
+(define-public cl-modf
+ (sbcl-package->cl-source-package sbcl-modf))
-(define-public cl-mixed
- (sbcl-package->cl-source-package sbcl-cl-mixed))
+(define-public ecl-modf
+ (sbcl-package->ecl-package sbcl-modf))
-(define-public sbcl-lispbuilder-sdl
- (let ((commit "589b3c6d552bbec4b520f61388117d6c7b3de5ab"))
+(define-public sbcl-modularize
+ (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba")
+ (revision "1"))
(package
- (name "sbcl-lispbuilder-sdl")
- (version (git-version "0.9.8.2" "1" commit))
+ (name "sbcl-modularize")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispbuilder/lispbuilder";)
+ (url "https://github.com/Shinmera/modularize";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0zga59fjlhq3mhwbf80qwqwpkjkxqnn2mhxajlb8563vhn3dbafp"))))
+ (base32 "1zys29rfkb649rkgl3snxhajk8d5yf7ryxkrwy020kwdh7zdsg7d"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("cffi" ,sbcl-cffi)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("sdl" ,sdl)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'cd-sdl
- (lambda _
- (chdir "lispbuilder-sdl")
- #t))
- (add-after 'cd-sdl 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "cffi/library.lisp"
- (("libSDL[^\"]*" all)
- (string-append (assoc-ref inputs "sdl") "/lib/" all)))
- #t)))))
- (home-page
"https://github.com/lispbuilder/lispbuilder/wiki/LispbuilderSDL";)
- (synopsis "Common Lisp wrapper for SDL")
+ `(("documentation-utils" ,sbcl-documentation-utils)
+ ("trivial-package-local-nicknames"
,sbcl-trivial-package-local-nicknames)))
+ (home-page "https://shinmera.github.io/modularize/";)
+ (synopsis "Common Lisp modularization framework")
(description
- "This library is an SDL wrapper as part of an umbrella project that
-provides cross-platform packages for building large, interactive applications
-in Common Lisp.")
- (license license:expat))))
-
-(define-public ecl-lispbuilder-sdl
- (sbcl-package->ecl-package sbcl-lispbuilder-sdl))
-
-(define-public cl-lispbuilder-sdl
- (sbcl-package->cl-source-package sbcl-lispbuilder-sdl))
-
-(define-public sbcl-dufy
- (package
- (name "sbcl-dufy")
- (version "0.4.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/privet-kitty/dufy";)
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "15vrp1kayhjb5c1vc9x8wlm8rimk73vpa7yc101cf0gsg1fjazl6"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-cl-ppcre))
- (native-inputs
- (list sbcl-fiveam sbcl-cl-csv sbcl-parse-float sbcl-lispbuilder-sdl
- sbcl-lparallel))
- (home-page "https://github.com/privet-kitty/dufy";)
- (synopsis "Color library for Common Lisp")
- (description
- "Dufy is a library for exact color manipulation and conversion in various
-color spaces, which supports many color models.")
- (license license:expat)))
+ "@code{MODULARIZE} is an attempt at providing a common interface to
+segregate major application components. This is achieved by adding special
+treatment to packages. Each module is a package that is specially registered,
+which allows it to interact and co-exist with other modules in better ways.
For
+instance, by adding module definition options you can introduce mechanisms to
+tie modules together in functionality, hook into each other and so on.")
+ (license license:zlib))))
-(define-public ecl-dufy
- (sbcl-package->ecl-package sbcl-dufy))
+(define-public ecl-modularize
+ (sbcl-package->ecl-package sbcl-modularize))
-(define-public cl-dufy
- (sbcl-package->cl-source-package sbcl-dufy))
+(define-public cl-modularize
+ (sbcl-package->cl-source-package sbcl-modularize))
-(define-public sbcl-bknr-datastore
- (let ((commit "c98d44f47cc88d19ff91ca3eefbd9719a8ace022")
+(define-public sbcl-modularize-hooks
+ (let ((commit "e0348ed3ffd59a9ec31ca4ab28289e748bfbf96a")
(revision "1"))
(package
- (name "sbcl-bknr-datastore")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-modularize-hooks")
+ (version (git-version "1.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hanshuebner/bknr-datastore";)
+ (url "https://github.com/Shinmera/modularize-hooks";)
(commit commit)))
- (file-name (git-file-name "bknr-datastore" version))
+ (file-name (git-file-name "modularize-hooks" version))
(sha256
- (base32 "1vi3w65fnczqvswkm381n6liqfrzjrg40y698qvj7skj28dm5vrm"))))
+ (base32 "12kjvin8hxidwkzfb7inqv5b6g5qzcssnj9wc497v2ixc56fqdz7"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems
- '("bknr.datastore"
- "bknr.impex"
- "bknr.indices"
- "bknr.skip-list"
- "bknr.utils"
- "bknr.xml")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'enter-source-directory
- (lambda _
- (chdir "src")
- #t)))))
- (native-inputs
- `(("cl-store" ,sbcl-cl-store)
- ("fiveam" ,sbcl-fiveam)
- ("unit-test" ,sbcl-unit-test)))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("closer-mop" ,sbcl-closer-mop)
- ("cl-interpol" ,sbcl-cl-interpol)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("cxml" ,sbcl-cxml)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("md5" ,sbcl-md5)
- ("trivial-utf-8" ,sbcl-trivial-utf-8)
- ("yason" ,sbcl-yason)))
- (home-page "https://github.com/hanshuebner/bknr-datastore";)
- (synopsis "In-memory database for Common Lisp")
+ (list sbcl-closer-mop sbcl-lambda-fiddle sbcl-modularize
+ sbcl-trivial-arguments))
+ (home-page "https://shinmera.github.io/modularize-hooks/";)
+ (synopsis "Generic hooks and triggers extension for Modularize")
(description
- "BKNR.DATASTORE is an in-memory CLOS based database with transactions
-for Common Lisp.")
- (license license:bsd-0))))
+ "This is a simple extension to @code{MODULARIZE} that allows modules to
+define and trigger hooks, which other modules can hook on to.")
+ (license license:zlib))))
-;; NOTE: (Sharlatan-20210429T191426+0100):
-;; There is no port for ECL in upstream yet
-;; (define-public ecl-bknr-datastore
-;; (sbcl-package->ecl-package sbcl-bknr-datastore))
+(define-public ecl-modularize-hooks
+ (sbcl-package->ecl-package sbcl-modularize-hooks))
-(define-public cl-bknr-datastore
- (sbcl-package->cl-source-package sbcl-bknr-datastore))
+(define-public cl-modularize-hooks
+ (sbcl-package->cl-source-package sbcl-modularize-hooks))
-(define-public sbcl-authentic
- (let ((commit "4e9194dda227b98f56dda1c2a2480efcc2d1f973")
- (revision "2"))
+(define-public sbcl-modularize-interfaces
+ (let ((commit "96353657afb8c7aeba7ef5b51eb04c5ed3bcb6ef")
+ (revision "1"))
(package
- (name "sbcl-authentic")
- (version (git-version "0.1.2" revision commit))
+ (name "sbcl-modularize-interfaces")
+ (version (git-version "0.9.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charje/cl-authentic";)
+ (url "https://github.com/Shinmera/modularize-interfaces";)
(commit commit)))
- (file-name (git-file-name "cl-authentic" version))
+ (file-name (git-file-name "modularize-interfaces" version))
(sha256
- (base32 "0ncsxrybnx0pjsndv3j8w4lphlpcsld8sxg3c5b46fb3a8nd4ssf"))))
+ (base32 "0bjf4wy39cwf75m7vh0r7mmcchs09yz2lrbyap98hnq8blq70fhc"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-clsql sbcl-ironclad))
- (home-page "https://github.com/charje/cl-authentic";)
- (synopsis "User/password management for Common Lisp applications")
- (description "Authentic provides a light-weight and extendible
-solution to user/password management for Common Lisp applications. It has
-features such as safe password storage in a database, password reset, user
-confirmation tokens, and user authentication.")
- (license license:llgpl))))
+ (list sbcl-lambda-fiddle sbcl-modularize sbcl-trivial-arguments
+ sbcl-trivial-indent))
+ (home-page "https://shinmera.github.io/modularize-interfaces/";)
+ (synopsis "Programmatical interfaces extension for Modularize")
+ (description
+ "This is an extension to @code{MODULARIZE} that allows your application
+to define interfaces in-code that serve both as a primary documentation and as
+compliance control.")
+ (license license:zlib))))
-(define-public ecl-authentic
- (sbcl-package->ecl-package sbcl-authentic))
+(define-public ecl-modularize-interfaces
+ (sbcl-package->ecl-package sbcl-modularize-interfaces))
-(define-public cl-authentic
- (sbcl-package->cl-source-package sbcl-authentic))
+(define-public cl-modularize-interfaces
+ (sbcl-package->cl-source-package sbcl-modularize-interfaces))
-(define-public sbcl-3d-vectors
- (let ((commit "257969402864ac3859d77b981abf0aa5373c4e78")
- (revision "2"))
+(define-public sbcl-moira
+ (let ((commit "21f1cfd5942fcaea2ed2e4f6055b2a5a39ac4c6e")
+ (revision "0"))
(package
- (name "sbcl-3d-vectors")
- (version (git-version "3.1.0" revision commit))
+ (name "sbcl-moira")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/3d-vectors";)
+ (url "https://github.com/ruricolist/moira";)
(commit commit)))
- (file-name (git-file-name "cl-3d-vectors" version))
+ (file-name (git-file-name "cl-moira" version))
(sha256
- (base32 "0vmf7nycc49ydcy0dfs25cgs655kwjc6jcjvpwxw61jq4gl2fh7x"))))
+ (base32 "0r6hvq8j04y1i85f8jwhhafylgfrkg8c1z5746nsbv0v0348sf5h"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
(inputs
- (list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/3d-vectors/";)
- (synopsis "Utility library implementing 2D, 3D, and 4D vectors")
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-osicat
+ sbcl-serapeum
+ sbcl-trivial-features
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/ruricolist/moira";)
+ (synopsis "Monitor and restart background threads")
(description
- "@code{3D-VECTORS} is a library for vector math in 3D space. It
contains
-most of the vector operations one would usually expect out of such a library
and
-offers them both in non-modifying and modifying versions where applicable.")
- (license license:zlib))))
+ "Moira is a library for monitoring and, if necessary, restarting
+long-running threads. In principle, it is like an in-Lisp process
supervisor.")
+ (license license:expat))))
-(define-public ecl-3d-vectors
- (sbcl-package->ecl-package sbcl-3d-vectors))
+(define-public cl-moira
+ (sbcl-package->cl-source-package sbcl-moira))
-(define-public cl-3d-vectors
- (sbcl-package->cl-source-package sbcl-3d-vectors))
+(define-public ecl-moira
+ (sbcl-package->ecl-package sbcl-moira))
-(define-public sbcl-3d-matrices
- (let ((commit "b4f5a58299f8437fad2d77f0879c374e3430f4b5")
- (revision "2"))
+(define-public sbcl-montezuma
+ (let ((commit "ee2129eece7065760de4ebbaeffaadcb27644738")
+ (revision "1"))
(package
- (name "sbcl-3d-matrices")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-montezuma")
+ (version (git-version "0.1.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/3d-matrices";)
+ (url "https://github.com/sharplispers/montezuma";)
(commit commit)))
- (file-name (git-file-name "cl-3d-matrices" version))
+ (file-name (git-file-name "cl-montezuma" version))
(sha256
- (base32 "1s8b4zlmqwyplghs73riz1khf0c5sk64w6b12jd599091d5nr6sr"))))
+ (base32 "0svmvsbsirydk3c1spzfvj8qmkzcs9i69anpfvk1843i62wb7x2c"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ ;; The _darcs directory contains a second copy of
+ ;; montezuma-indexfiles.asd. Remove the directory to
+ ;; prevent build failure caused by .asd files that have
+ ;; the same filename.
+ (add-after 'unpack 'remove-darcs-directory
+ (lambda _
+ (delete-file-recursively
+ "contrib/montezuma-indexfiles/_darcs")))
+ ;; Tests fail with: :FORCE and :FORCE-NOT arguments not
+ ;; allowed in a nested call to ASDF/OPERATE:OPERATE unless
+ ;; identically to toplevel.
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "montezuma.asd"
+ ((":force t") "")))))))
(inputs
- (list sbcl-3d-vectors sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/3d-matrices/";)
- (synopsis "Utility library implementing 2x2, 3x3, 4x4 and NxM matrices")
+ `(("babel" ,sbcl-babel)
+ ("cl-fad" ,sbcl-cl-fad)
+ ("cl-ppcre" ,sbcl-cl-ppcre)))
+ (native-inputs
+ (list sbcl-trivial-timeout))
+ (home-page "https://github.com/sharplispers/montezuma";)
+ (synopsis "Full-text indexing and search for Common Lisp")
(description
- "@code{3D-MATRICES} is a library implementing common matrix operations,
-mainly intended as the counterpiece to @code{3d-vectors} and thus being aimed
at
-operations in 3D space.")
- (license license:zlib))))
+ "Montezuma is a text search engine library for Lisp based on the Ferret
+library for Ruby, which is itself based on the Lucene library for Java.")
+ (license (list license:expat ; montezuma
+ license:gpl3+))))) ; contrib/montezuma-indexfiles
-(define-public ecl-3d-matrices
- (sbcl-package->ecl-package sbcl-3d-matrices))
+(define-public cl-montezuma
+ (sbcl-package->cl-source-package sbcl-montezuma))
-(define-public cl-3d-matrices
- (sbcl-package->cl-source-package sbcl-3d-matrices))
+(define-public ecl-montezuma
+ (let ((pkg (sbcl-package->ecl-package sbcl-montezuma)))
+ (package
+ (inherit pkg)
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ;; Tests fail with "Pathname without a physical namestring" error
+ ;; on ECL.
+ ((#:tests? _ #f) #f))))))
-(define-public sbcl-3d-quaternions
- (let ((commit "b79c15cca8d9c409216a6cee8ec9e182dcdec9e2")
- (revision "0"))
+(define-public sbcl-moptilities
+ (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
(package
- (name "sbcl-3d-quaternions")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-moptilities")
+ (version (git-version "0.3.13" "1" commit))
+ (home-page "https://github.com/gwkkwg/moptilities/";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/3d-quaternions";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-3d-quaternions" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1mrq6yhb90mhvxdkg3fx58ci5yj5xlixbbzf1q6p76wyq40qjv76"))))
+ (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
(inputs
- (list sbcl-3d-matrices sbcl-3d-vectors sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/3d-quaternions/";)
- (synopsis "Quaternion and dual-quaternion functionality in Common Lisp")
+ `(("closer-mop" ,sbcl-closer-mop)))
+ (native-inputs
+ (list sbcl-lift))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "lift-standard.config"
+ ((":relative-to lift-test")
+ ":relative-to moptilities-test"))
+ #t))
+ (add-after 'install 'remove-test-results
+ ;; Otherwise the drag the SBCL package into the closure of the CL
+ ;; package.
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let* ((out (assoc-ref outputs "out"))
+ (source-path (string-append out "/share/common-lisp/"
+ (%lisp-type)
"/moptilities/")))
+ (delete-file-recursively
+ (string-append source-path "/test-results")))
+ #t)))))
+ (synopsis "Compatibility layer for Common Lisp MOP implementation
differences")
(description
- "This is a library for quaternions. It contains most of the quaternion
-operations one would usually expect out of such a library and offers them both
-in non-modifying and modifying versions where applicable. It also tries to be
-efficient where plausible. Each quaternion is made up of @code{float}s, which
-by default are @code{single-float}s, as they do not require value boxing on
-most modern systems and compilers.")
- (license license:zlib))))
+ "MOP utilities provide a common interface between Lisps and make the
+MOP easier to use.")
+ (license license:expat))))
-;; TODO: Build failure:
-;; https://github.com/Shinmera/3d-quaternions/issues/2
-;;
-;; (define-public ecl-3d-quaternions
-;; (sbcl-package->ecl-package sbcl-3d-quaternions))
+(define-public cl-moptilities
+ (sbcl-package->cl-source-package sbcl-moptilities))
-(define-public cl-3d-quaternions
- (sbcl-package->cl-source-package sbcl-3d-quaternions))
+(define-public ecl-moptilities
+ (let ((pkg (sbcl-package->ecl-package sbcl-moptilities)))
+ (package
+ (inherit pkg)
+ (arguments
+ ;; Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is
+ ;; undefined" on ECL.
+ '(#:tests? #f)))))
-(define-public sbcl-interface
- (let ((commit "6d8bd74214053debcbc0b174d65ea73c271c1563")
- (revision "0"))
+(define-public sbcl-mssql
+ (let ((commit "045602a19a32254108f2b75871049293f49731eb")
+ (revision "1"))
(package
- (name "sbcl-interface")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-mssql")
+ (version (git-version "0.0.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/stylewarning/interface";)
+ (url "https://github.com/archimag/cl-mssql";)
(commit commit)))
- (file-name (git-file-name "cl-interface" version))
+ (file-name (git-file-name "cl-mssql" version))
(sha256
- (base32 "0h1bckhyig2znl6nrd3agjzz7knrm2kyh2vfyk7j60kzki9rpzxy"))))
+ (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm"))))
(build-system asdf-build-system/sbcl)
- (inputs (list sbcl-alexandria sbcl-global-vars))
- (synopsis "System for defining interfaces")
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("freetds" ,freetds)
+ ("garbage-pools" ,sbcl-garbage-pools)
+ ("iterate" ,sbcl-iterate)
+ ("parse-number" ,sbcl-parse-number)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/mssql.lisp"
+ (("libsybdb" all)
+ (string-append (assoc-ref inputs "freetds") "/lib/" all)))
+ #t)))))
+ (home-page "https://github.com/archimag/cl-mssql";)
+ (synopsis "Common Lisp library to interact with MS SQL Server databases")
(description
- "This library contains an implementation of interfaces and
-implementations. They're sometimes called protocols in other
-languages. Broadly speaking, an @emph{interface} is some collection of
-function @emph{prototypes} that a valid implementation must implement.")
- (home-page "https://github.com/stylewarning/interface";)
- (license license:bsd-3))))
+ "@code{cl-mssql} provides an interface to connect to Microsoft SQL
+server. It uses the @code{libsybdb} foreign library provided by the FreeTDS
+project.")
+ (license license:llgpl))))
-(define-public ecl-interface
- (sbcl-package->ecl-package sbcl-interface))
+(define-public cl-mssql
+ (sbcl-package->cl-source-package sbcl-mssql))
-(define-public cl-interface
- (sbcl-package->cl-source-package sbcl-interface))
+(define-public ecl-mssql
+ (sbcl-package->ecl-package sbcl-mssql))
-(define-public sbcl-cl-syslog
- (let ((commit "d5d46f777f0735938e6f650cf17d814b88b70305")
- (revision "0"))
+(define-public sbcl-mt19937
+ (package
+ (name "sbcl-mt19937")
+ (version "1.1")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/asdf-packaging/";
+ "mt19937-latest.tar.gz"))
+ (sha256
+ (base32
+ "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Mersenne Twister pseudo-random number generator")
+ (description
+ "MT19937 is a portable Mersenne Twister pseudo-random number generator
+for Common Lisp.")
+ (home-page "https://www.cliki.net/mt19937";)
+ (license license:public-domain)))
+
+(define-public cl-mt19937
+ (sbcl-package->cl-source-package sbcl-mt19937))
+
+(define-public ecl-mt19937
+ (sbcl-package->ecl-package sbcl-mt19937))
+
+(define-public sbcl-multilang-documentation
+ (let ((commit "59e798a07e949e8957a20927f52aca425d84e4a0"))
(package
- (name "sbcl-cl-syslog")
- (version (git-version "0.2.4" revision commit))
+ (name "sbcl-multilang-documentation")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmaul/cl-syslog";)
+ (url "https://github.com/Shinmera/multilang-documentation";)
(commit commit)))
- (file-name (git-file-name "cl-syslog" version))
+ (file-name (git-file-name name commit))
(sha256
- (base32 "1qcz55jiqwk91b01hsahxnha884f6zf2883j2m51sqph0mvj69mh"))))
+ (base32 "13y5jskx8n2b7kimpfarr8v777w3b7zj5swg1b99nj3hk0843ixw"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cffi
- sbcl-global-vars
- sbcl-local-time
- sbcl-split-sequence
- sbcl-usocket))
- (arguments
- (list #:tests? #f))
- (synopsis "Common Lisp interface to local and remote Syslog facilities")
- (description "@code{cl-syslog} is a Common Lisp library that provides
-access to the syslog logging facility.")
- (home-page "https://cl-syslog.common-lisp.dev/";)
- (license license:bsd-3))))
-
-(define-public ecl-cl-syslog
- (sbcl-package->ecl-package sbcl-cl-syslog))
-
-(define-public cl-syslog
- (sbcl-package->cl-source-package sbcl-cl-syslog))
-
-(define-public sbcl-alexa
- (package
- (name "sbcl-alexa")
- (version "2.1.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/quil-lang/alexa";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-alexa" version))
- (sha256
- (base32 "1y9jyz9gfmd02h492kf7v3mmpbhc0yfh4ka2rzd1vczq6fl8qgqv"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiasco))
- (inputs (list sbcl-alexandria sbcl-cl-ppcre))
- (synopsis "Lexical Analyzer Generator for Common Lisp")
- (description
- "ALEXA is a tool similar to lex or flex for generating lexical analyzers.
-Unlike tools like lex, however, ALEXA defines a domain-specific language
-within your Lisp program, so you don't need to invoke a separate tool.")
- (home-page "https://github.com/quil-lang/alexa";)
- (license license:bsd-3)))
-
-(define-public ecl-alexa
- (sbcl-package->ecl-package sbcl-alexa))
-
-(define-public cl-alexa
- (sbcl-package->cl-source-package sbcl-alexa))
-
-(define-public sbcl-metering
- (let ((commit "62dbaa5e8d29d2f213b881d740114941c2c3d1be")
- (revision "0"))
- (package
- (name "sbcl-metering")
- (version (git-version "3.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.common-lisp.net/dkochmanski/metering";)
- (commit commit)))
- (file-name (git-file-name "cl-metering" version))
- (sha256
- (base32 "0jx3ypk8m815yp7208xkcxkvila847mvna25a2p22ihnj0ms9rn1"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (synopsis "Common Lisp code profiling tool")
+ (list sbcl-documentation-utils sbcl-language-codes
+ sbcl-system-locale))
+ (home-page "https://shinmera.github.io/multilang-documentation/";)
+ (synopsis "Add multiple languages support to Common Lisp documentation")
(description
- "The Metering System is a portable Common Lisp code profiling tool.
-It gathers timing and consing statistics for specified functions while
-a program is running.")
- (home-page "https://gitlab.common-lisp.net/dkochmanski/metering";)
- (license license:public-domain))))
+ "This library provides a drop-in replacement function for
+cl:documentation that supports multiple docstrings per-language, allowing you
+to write documentation that can be internationalised.")
+ (license license:zlib))))
-(define-public ecl-metering
- (sbcl-package->ecl-package sbcl-metering))
+(define-public cl-multilang-documentation
+ (sbcl-package->cl-source-package sbcl-multilang-documentation))
-(define-public cl-metering
- (sbcl-package->cl-source-package sbcl-metering))
+(define-public ecl-multilang-documentation
+ (sbcl-package->ecl-package sbcl-multilang-documentation))
-(define-public sbcl-cl-grnm
- (let ((commit "778a312e9eb3d3de7541457b516ea3d9055a15aa")
+(define-public sbcl-music-spelling
+ (let ((commit "a2d492af440ad30a21042140cf8ffce4b73fbd42")
(revision "0"))
(package
- (name "sbcl-cl-grnm")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-music-spelling")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/quil-lang/cl-grnm";)
+ (url "https://github.com/ntrocado/music-spelling";)
(commit commit)))
- (file-name (git-file-name "cl-grnm" version))
+ (file-name (git-file-name "cl-music-spelling" version))
(sha256
- (base32 "1hb5n37n3x2ylrghcqsia2g9a6f5wg24l659jiz4ncpi5bsv4m3s"))))
+ (base32 "0fgahb0jjr4sp2739d55gylmx8alsghnx3spyaqfqci4cxfrys52"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp implementation of (grid restrained) Nelder-Mead")
- (description
- "These common lisp sources contain two variants of the Nelder-Mead
-algorithm. The original algorithm and a provably convergent, reliable variant
-by A. Bürmen et al, called the
-@acronym{GRNMA, Grid Restrained Nelder Mead Algorithm}.")
- (home-page "https://github.com/quil-lang/cl-grnm";)
- (license license:expat))))
+ (inputs (list sbcl-alexandria))
+ (home-page "https://github.com/ntrocado/music-spelling/";)
+ (synopsis "Automatically spell musical pitches and rhythms")
+ (description "This package implements an algorithm for the spelling
+of enharmonics and dealing with ties and dots in rhythm notation.")
+ (license license:asl2.0))))
-(define-public ecl-cl-grnm
- (sbcl-package->ecl-package sbcl-cl-grnm))
+(define-public cl-music-spelling
+ (sbcl-package->cl-source-package sbcl-music-spelling))
-(define-public cl-grnm
- (sbcl-package->cl-source-package sbcl-cl-grnm))
+(define-public ecl-music-spelling
+ (sbcl-package->ecl-package sbcl-music-spelling))
-(define-public sbcl-priority-queue
- (let ((commit "011b8d52ef7ba7f8e6bc26608eedef222b38aaa8")
- (revision "0"))
+(define-public sbcl-mw-equiv
+ (let ((commit "3ae871458685b1ef7cd6a996ee22c8c5e738a03d")
+ (revision "1"))
(package
- (name "sbcl-priority-queue")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-mw-equiv")
+ (version (git-version "0.1.2" revision commit))
+ (home-page "https://github.com/sharplispers/mw-equiv/";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dsorokin/priority-queue";)
+ (url "https://github.com/sharplispers/mw-equiv/";)
(commit commit)))
- (file-name (git-file-name "cl-priority-queue" version))
+ (file-name (git-file-name "cl-mw-equiv" version))
(sha256
- (base32 "0y5a1fid8xzzl58hfdj64n8mrzq0kr06a0lnmdjpgi0czc3x0jcy"))))
+ (base32 "1fl90wp0jp7l90mps53fq0kzb28f10qfr739527h03xwqccyylad"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Priority queue for Common Lisp")
- (description "This package provides a priority queue implemented with
-an array-based heap.")
- (home-page "https://github.com/dsorokin/priority-queue";)
- (license license:expat))))
+ (synopsis "Extensible object equivalence protocol for Common Lisp")
+ (description "Common Lisp comes with quite some functions to compare
+objects for equality, yet none is applicable in every situation and in general
+this is hard, as equality of objects depends on the semantics of operations on
+them. As consequence, users find themselves regularly in a situation where
+they have to roll their own specialized equality test.
-(define-public ecl-priority-queue
- (sbcl-package->ecl-package sbcl-priority-queue))
+This module provides one of many possible equivalence relations between
+standard Common Lisp objects. However, it can be extended for new objects
+through a simple CLOS protocol. The rules when two objects are considered
+equivalent distinguish between @emph{mutating} and @emph{frozen objects}. A
+frozen object is promised not to be mutated in the future in a way that
+operations on it can notice the difference.
-(define-public cl-priority-queue
- (sbcl-package->cl-source-package sbcl-priority-queue))
+We have chosen to compare mutating objects only for identity (pointer
+equality), to avoid various problems. Equivalence for frozen objects on the
+other hand is established by recursing on the objects' constituent parts and
+checking their equivalence. Hence, two objects are equivalent under the
+@code{OBJECT=} relation, if they are either identical, or if they are frozen
+and structurally equivalent, i.e. their constituents are point-wise
+equivalent.
-(define-public sbcl-cl-messagepack
- (let ((commit "8ff2060ed20677feef8ac01558690df0aeac30b6")
- (revision "0"))
- (package
- (name "sbcl-cl-messagepack")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mbrezu/cl-messagepack";)
- (commit commit)))
- (file-name (git-file-name "cl-messagepack" version))
- (sha256
- (base32 "1hjd1q18lz46k46afz94ljflp76mfr30d6z4jrsgd26y2lc4gchc"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-cl-json sbcl-fiveam))
- (inputs (list sbcl-babel sbcl-closer-mop sbcl-flexi-streams))
- (synopsis "Common Lisp implementation of MessagePack")
- (description
- "This is a Common Lisp implementation of the MessagePack
-(@url{http://msgpack.org/}) serialization/deserialization format,
-implemented according to
-@url{http://wiki.msgpack.org/display/MSGPACK/Format+specification}.";)
- (home-page "https://github.com/mbrezu/cl-messagepack";)
+Since many objects are potentially mutable, but are not necessarily mutated
+from a certain point in their life time on, it is possible to promise to the
+equivalence relation that they remain frozen for the rest of their life time,
+thus enabling coarser equivalence than the often too fine-grained pointer
+equality.")
(license license:bsd-2))))
-(define-public ecl-cl-messagepack
- (sbcl-package->ecl-package sbcl-cl-messagepack))
+(define-public cl-mw-equiv
+ (sbcl-package->cl-source-package sbcl-mw-equiv))
-(define-public cl-messagepack
- (sbcl-package->cl-source-package sbcl-cl-messagepack))
+(define-public ecl-mw-equiv
+ (sbcl-package->ecl-package sbcl-mw-equiv))
-(define-public sbcl-cl-permutation
- (let ((commit "20c10e9ca56452d2fafc3ec0984dcdf78b4f4b19")
- (revision "0"))
+(define-public sbcl-myway
+ (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7")
+ (revision "1"))
(package
- (name "sbcl-cl-permutation")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/stylewarning/cl-permutation";)
- (commit commit)))
- (file-name (git-file-name "cl-permutation" version))
- (sha256
- (base32 "0i932g0k50y24hxizni6zfya4kcw77yk3b0llivm9g50s7fxj9dk"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiasco))
- (inputs
- (list sbcl-alexandria
- sbcl-bordeaux-fft
- sbcl-cl-algebraic-data-type
- sbcl-cl-cont
- sbcl-closer-mop
- sbcl-iterate
- sbcl-priority-queue))
- (synopsis "Permutations and permutation groups in Common Lisp")
- (description
- "This is a Commin Lisp library for operating on permutations and
-permutation groups.")
- (home-page "https://github.com/stylewarning/cl-permutation";)
- (license license:bsd-3))))
-
-(define-public ecl-cl-permutation
- (sbcl-package->ecl-package sbcl-cl-permutation))
-
-(define-public cl-permutation
- (sbcl-package->cl-source-package sbcl-cl-permutation))
-
-(define-public sbcl-magicl
- (package
- (name "sbcl-magicl")
- (version "0.9.1")
- (source
- (origin
+ (name "sbcl-myway")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/quil-lang/magicl";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-magicl" version))
- (sha256
- (base32 "0x9p55qin399jhr5md88nij8fv78b64xjhww7ys364pkjnx8ak9v"))))
+ (url "https://github.com/fukamachi/myway";)
+ (commit commit)))
+ (file-name (git-file-name "myway" version))
+ (sha256
+ (base32 "0briia9bk3lbr0frnx39d1qg6i38dm4j6z9w3yga3d40k6df4a90"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("myway-test" "myway")))
+ (native-inputs
+ (list sbcl-prove))
+ (inputs
+ (list sbcl-cl-ppcre sbcl-quri sbcl-map-set))
+ (home-page "https://github.com/fukamachi/myway";)
+ (synopsis "Sinatra-compatible URL routing library for Common Lisp")
+ (description "My Way is a Sinatra-compatible URL routing library.")
+ (license license:llgpl))))
+
+(define-public cl-myway
+ (sbcl-package->cl-source-package sbcl-myway))
+
+(define-public ecl-myway
+ (sbcl-package->ecl-package sbcl-myway))
+
+(define-public sbcl-nactivitypub
+ (package
+ (name "sbcl-nactivitypub")
+ (version "0.0.5")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/nactivitypub";)
+ (commit version)))
+ (file-name (git-file-name "cl-nactivitypub" version))
+ (sha256
+ (base32
+ "0m2vwi11zp0bpvr0hglq1svdxlp3cc70yvix30yksfzp6kk3amyn"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list gfortran sbcl-fiasco))
- (inputs
- (list lapack
- sbcl-alexandria
- sbcl-abstract-classes
- sbcl-cffi
- sbcl-interface
- sbcl-policy-cond
- sbcl-static-vectors
- sbcl-trivial-garbage))
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/extensions/blas/load-libs.lisp"
- (("libblas.so")
- (search-input-file inputs "/lib/libblas.so")))
- (substitute* "src/extensions/lapack/load-libs.lisp"
- (("liblapack.so")
- (search-input-file inputs "/lib/liblapack.so"))))))))
- (synopsis "Matrix Algebra proGrams In Common Lisp")
+ (inputs (list sbcl-cl-str
+ sbcl-dexador
+ sbcl-local-time
+ sbcl-lparallel
+ sbcl-njson
+ sbcl-quri
+ sbcl-serapeum))
+ (home-page "https://github.com/atlas-engineer/nactivitypub";)
+ (synopsis
+ "Common Lisp implementation of ActivityPub and ActivityStreams standards")
(description
- "This package provides matrix algebra functions for Common Lisp.")
- (home-page "https://github.com/quil-lang/magicl";)
+ "This package provides a Common Lisp implementation of ActivityPub and
+ActivityStreams standards for social networking.
+
+Features:
+@itemize
+
+@item Parsing and un-parsing ActivityStreams JSON-LD objects to/from CLOS
+objects with convenient accessors on those.
+
+@item Sending and fetching ActivityStreams objects to/from the
+ActivityStreams-enabled HTTP(S) URLs.
+
+@item Semantic info extraction with methods like @code{name*}, @code{url*},
+@code{author*}, and @code{published*}.
+
+@item No reliance on JSON parser. @code{njson} is used for parser-independent
+JSON handling. Load the parser backend you prefer!
+
+@end itemize")
(license license:bsd-3)))
-(define-public cl-magicl
- (sbcl-package->cl-source-package sbcl-magicl))
+(define-public cl-nactivitypub
+ (sbcl-package->cl-source-package sbcl-nactivitypub))
-(define-public sbcl-messagebox
- (let ((commit "ea3688d9a9954bee7079c0173bc7b3f327021e9f")
- (revision "1"))
+(define-public ecl-nactivitypub
+ (sbcl-package->ecl-package sbcl-nactivitypub))
+
+(define-public sbcl-named-readtables
+ (let ((commit "d5ff162ce02035ec7de1acc9721385f325e928c0")
+ (revision "4"))
(package
- (name "sbcl-messagebox")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-named-readtables")
+ (version (git-version "0.9" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/messagebox";)
+ (url "https://github.com/melisgl/named-readtables";)
(commit commit)))
- (file-name (git-file-name "messagebox" version))
(sha256
- (base32 "0jkbzlca0wvspgsfj0b0hjwlyyy8jlywsldsbkp79q48fc3aa8jd"))))
+ (base32 "0gfgxywzbmavy0kpnxav11vz10qfzxwwrpgqaak9sgzg17g8x5yv"))
+ (file-name (git-file-name "cl-named-readtables" version))))
(build-system asdf-build-system/sbcl)
+ ;; (native-inputs (list sbcl-try))
+ ;; Tests disabled because of a circular dependency issue:
+ ;; try -> named-readtables -> mgl-pax -> try
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-zenity-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "zenity.lisp"
- (("\"zenity\"")
- (string-append "\"" (assoc-ref inputs "zenity")
- "/bin/zenity\""))))))))
- (inputs
- `(("documentation-utils" ,sbcl-documentation-utils)
- ("trivial-features" ,sbcl-trivial-features)
- ("zenity" ,zenity)))
- (home-page "https://shinmera.github.io/messagebox/";)
- (synopsis "Display a native GUI message box")
+ (list #:tests? #f))
+ (home-page "https://github.com/melisgl/named-readtables/";)
+ (synopsis "Library that creates a namespace for named readtables")
(description
- "This is a small library to display a native GUI message box. This can
be
-useful to show error messages and other informational pieces should the
-application fail and be unable to do so using its standard UI.")
- (license license:zlib))))
+ "Named readtables is a library that creates a namespace for named
+readtables, which is akin to package namespacing in Common Lisp.")
+ (license license:bsd-3))))
-(define-public ecl-messagebox
- (sbcl-package->ecl-package sbcl-messagebox))
+(define-public cl-named-readtables
+ (sbcl-package->cl-source-package sbcl-named-readtables))
-(define-public cl-messagebox
- (sbcl-package->cl-source-package sbcl-messagebox))
+(define-public ecl-named-readtables
+ (sbcl-package->ecl-package sbcl-named-readtables))
-(define-public sbcl-3d-transforms
- (let ((commit "1d44509387d0747cd0351e95a533eca609058632")
+(define-public sbcl-napa-fft3
+ (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
(revision "0"))
(package
- (name "sbcl-3d-transforms")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-napa-fft3")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/3d-transforms";)
+ (url "https://github.com/pkhuong/Napa-FFT3";)
(commit commit)))
- (file-name (git-file-name "cl-3d-transforms" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "03pmv7dh1j6kl16ch6lnvxzjrld4jbr3jx8slzkiipgzdxg74pcx"))))
+ (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-3d-matrices
- sbcl-3d-quaternions
- sbcl-3d-vectors
- sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/3d-transforms/";)
- (synopsis
- "Common structure to encapsulate spatial transformations in Common
Lisp")
+ (home-page "https://github.com/pkhuong/Napa-FFT3";)
+ (synopsis "Fast Fourier Transform routines in Common Lisp")
(description
- "This is a library that uses the other 3d-* math libraries to present an
-encapsulation for a spatial transformation. It offers convenience functions
for
-operating on such transformations and for converting between them and the
-alternative 4x4 matrix representation.")
- (license license:zlib))))
-
-;; TODO: Build failure:
-;; https://github.com/Shinmera/3d-quaternions/issues/2
-;;
-;; (define-public ecl-3d-transforms
-;; (sbcl-package->ecl-package sbcl-3d-transforms))
+ "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
+buildings blocks to express common operations that involve DFTs: filtering,
+convolutions, etc.")
+ (license license:bsd-3))))
-(define-public cl-3d-transforms
- (sbcl-package->cl-source-package sbcl-3d-transforms))
+(define-public cl-napa-fft3
+ (sbcl-package->cl-source-package sbcl-napa-fft3))
-(define-public sbcl-type-templates
- (let ((commit "5b389ebcff61b81585a64d0b899b69fa12aa5f96")
- (revision "0"))
+(define-public sbcl-nasdf
+ (let ((commit "ab7a018f3a67a999c72710644b10b4545130c139"))
(package
- (name "sbcl-type-templates")
- (version (git-version "4.0.0" revision commit))
+ (name "sbcl-nasdf")
+ (version "0.1.8")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/type-templates";)
+ (url "https://github.com/atlas-engineer/ntemplate";)
(commit commit)))
- (file-name (git-file-name "cl-type-templates" version))
+ (file-name (git-file-name "cl-ntemplate" version))
(sha256
- (base32 "1zmz3bmwg8ncqbnjwimn8n7q9ik9arnhd5ijd22ap1nwhbnmk1rj"))))
+ (base32 "15j7kqxvn0blr0i2xgk0il0ia91p28clfqxdh00vlp423v9a2wbx"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; No tests
- (list #:tests? #f))
- (inputs
- (list sbcl-alexandria
- sbcl-documentation-utils
- sbcl-form-fiddle))
- (home-page "https://shinmera.github.io/type-templates/";)
- (synopsis "Library for defining and expanding templated functions")
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'cd-sdl
+ (lambda _
+ (chdir "nasdf"))))))
+ (home-page "https://github.com/atlas-engineer/ntemplate";)
+ (synopsis "ASDF helpers for system setup, testing and installation")
(description
- "The Type-Templates library allows you to define types and “template
-functions” that can be expanded into various type-specialized versions to
-eliminate runtime dispatch overhead. It was specifically designed to
-implement low-level numerical data types and functionality.")
- (license license:zlib))))
+ "NASDF is an ASDF extension providing utilities to ease system setup,
+testing and installation.
-(define-public cl-type-templates
- (sbcl-package->cl-source-package sbcl-type-templates))
+@itemize
+@item Simple way to fetch Git submodules and “do the right thing” for
+setup. This may effectively supersede Quicklisp. A benefit of using Git
+submodules over the default Quicklisp distribution is improved
+reproducibility.
+@item Test helpers, like distinction between offline and online tests, or
+continuous integration options, and warning reports.
+@item Installation helpers, for instance to install libraries, icons and
+desktop files to the right directories.
+@end itemize\n")
+ (license license:bsd-3))))
-(define-public ecl-type-templates
- (sbcl-package->ecl-package sbcl-type-templates))
+(define-public cl-nasdf
+ (sbcl-package->cl-source-package sbcl-nasdf))
-(define-public sbcl-3d-math
- (let ((commit "3831b1706d225def95a7301ef48b393b563f0114")
- (revision "0"))
- (package
- (name "sbcl-3d-math")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/3d-math";)
- (commit commit)))
- (file-name (git-file-name "cl-3d-math" version))
- (sha256
- (base32 "052vzx5j7bag9dxvl0j0wrm244js1djldyn31rwxgkq7965rmi5r"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-documentation-utils
- sbcl-type-templates))
- (home-page "https://shinmera.github.io/3d-math/";)
- (synopsis "Linear algebra for 2D and 3D computations")
- (description
- "The @code{3d-math} library implements types, operators, and algorithms
-commonly used in math for 2D and 3D graphics. It supersedes and combines the
-prior libraries @code{3d-vectors}, @code{3d-matrices}, @code{3d-quaternions},
-and @code{3d-transforms}. The new API is largely but not entirely backwards
-compatible, and adds new functionality.")
- (license license:zlib))))
-
-(define-public cl-3d-math
- (sbcl-package->cl-source-package sbcl-3d-math))
-
-(define-public ecl-3d-math
- (sbcl-package->ecl-package sbcl-3d-math))
-
-(define-public sbcl-3d-spaces
- (let ((commit "a93f4915affcf65617366297ad8bd2ec77bae702")
- (revision "0"))
- (package
- (name "sbcl-3d-spaces")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shirakumo/3d-spaces";)
- (commit commit)))
- (file-name (git-file-name "cl-3d-spaces" version))
- (sha256
- (base32 "1m5cg5zy1731dcgkm1p4m53z1zsp387xligxh32pdrnrhc2lzhmf"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-3d-math
- sbcl-documentation-utils
- sbcl-for
- sbcl-trivial-extensible-sequences))
- (home-page "https://shirakumo.github.io/3d-spaces/";)
- (synopsis "Implementations of various spatial query structures")
- (description
- "The 3D-Spaces library implements a number of spatial query data
-structures; structures that can answer spatial range queries for optimized
-lookup, particularly suited for games.")
- (license license:zlib))))
+(define-public ecl-nasdf
+ (sbcl-package->ecl-package sbcl-nasdf))
-(define-public cl-3d-spaces
- (sbcl-package->cl-source-package sbcl-3d-spaces))
+(define-public sbcl-nclasses
+ (package
+ (name "sbcl-nclasses")
+ (version "0.6.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/nclasses";)
+ (commit version)))
+ (file-name (git-file-name "cl-nclasses" version))
+ (sha256
+ (base32
+ "00is7fg1jsj9r3jawphbk5gh8kmiixl7g60xg1ic2q2cpilfd1by"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-moptilities))
+ (native-inputs
+ (list sbcl-lisp-unit2))
+ (home-page "https://github.com/atlas-engineer/nclasses";)
+ (synopsis "Simplify class, condition, and generic function definitions.")
+ (description
+ "NClasses provides helper macros to help write classes, conditions,
+generic functions, and CLOS code in general with less boilerplate.
-(define-public ecl-3d-spaces
- (sbcl-package->ecl-package sbcl-3d-spaces))
+It's a fork of @code{hu.dwim.defclass-star}. It includes some bug fixes and
+extra features like type inference.")
+ (license license:public-domain)))
-(define-public sbcl-glsl-toolkit
- (let ((commit "4c4889e75c635772c4df70b11d6f14e7a596da43")
- (revision "2"))
- (package
- (name "sbcl-glsl-toolkit")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shirakumo/glsl-toolkit";)
- (commit commit)))
- (file-name (git-file-name "cl-glsl-toolkit" version))
- (sha256
- (base32 "0vrk8nqijqdi1rwf85rhd93yj7q8qkxnigxn3bw0cbrzvzrks9rl"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-ppcre sbcl-documentation-utils sbcl-parse-float
- sbcl-trivial-indent))
- (home-page "https://shirakumo.github.io/glsl-toolkit/";)
- (synopsis "Parser for OpenGL Shader Language source files")
- (description
- "This package provides Common Lisp system collecting tools written to
-wrangle OpenGL Shader Language (GLSL) source files.")
- (license license:zlib))))
+(define-public cl-nclasses
+ (sbcl-package->cl-source-package sbcl-nclasses))
-(define-public ecl-glsl-toolkit
- (sbcl-package->ecl-package sbcl-glsl-toolkit))
+(define-public ecl-nclasses
+ (sbcl-package->ecl-package sbcl-nclasses))
-(define-public cl-glsl-toolkit
- (sbcl-package->cl-source-package sbcl-glsl-toolkit))
+(define-public sbcl-ndebug
+ (package
+ (name "sbcl-ndebug")
+ (version "0.2.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/ndebug";)
+ (commit version)))
+ (file-name (git-file-name "cl-ndebug" version))
+ (sha256
+ (base32 "1sndg4qclkdr53xkxrfjskx8gcqx0bn4r0vslzfx1kgznl4hbf1d"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-dissect
+ sbcl-trivial-custom-debugger
+ sbcl-bordeaux-threads
+ sbcl-trivial-gray-streams))
+ (native-inputs
+ (list sbcl-lisp-unit2))
+ (home-page "https://github.com/atlas-engineer/ndebug/";)
+ (synopsis "Toolkit to build UI-aware Common Lisp debugger hooks")
+ (description
+ "NDebug provides a small set of utilities to make graphical (or, rather
+non-REPL-resident) Common Lisp applications easier to integrate with the
+standard Lisp debugger (@code{*debugger-hook*}, namely) and
+implementation-specific debugger hooks (via @code{trivial-custom-debugger}),
+especially in a multi-threaded context.")
+ (license license:bsd-3)))
-(define-public sbcl-simple-tasks
- (let ((commit "745d4b54eac9bf5d6909792e63ecd2ef8d303cf2")
- (revision "1"))
- (package
- (name "sbcl-simple-tasks")
- (version (git-version "1.3.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/simple-tasks";)
- (commit commit)))
- (file-name (git-file-name "simple-tasks" version))
- (sha256
- (base32 "1ls1pij7dvb65g4nam7nvik1218jvfk5iplr48vy290fw3lq7v98"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-array-utils sbcl-bordeaux-threads sbcl-dissect))
- (home-page "https://shinmera.github.io/simple-tasks/";)
- (synopsis "Simple task scheduling framework")
- (description "This is a task scheduling framework for Common Lisp.")
- (license license:zlib))))
+(define-public cl-ndebug
+ (sbcl-package->cl-source-package sbcl-ndebug))
-(define-public ecl-simple-tasks
- (sbcl-package->ecl-package sbcl-simple-tasks))
+(define-public ecl-ndebug
+ (sbcl-package->ecl-package sbcl-ndebug))
-(define-public cl-simple-tasks
- (sbcl-package->cl-source-package sbcl-simple-tasks))
+(define-public sbcl-net.didierverna.asdf-flv
+ (package
+ (name "sbcl-net.didierverna.asdf-flv")
+ (version "2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/didierverna/asdf-flv";)
+ (commit (string-append "version-" version))))
+ (file-name (git-file-name "asdf-flv" version))
+ (sha256
+ (base32 "1fi2y4baxan103jbg4idjddzihy03kwnj2mzbwrknw4d4x7xlgwj"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp ASDF extension to provide support for file-local
variables")
+ (description "ASDF-FLV provides support for file-local variables through
+ASDF. A file-local variable behaves like @code{*PACKAGE*} and
+@code{*READTABLE*} with respect to @code{LOAD} and @code{COMPILE-FILE}: a new
+dynamic binding is created before processing the file, so that any
+modification to the variable becomes essentially file-local.
-(define-public sbcl-trivial-main-thread
- (let ((commit "25f114973bb69eb63e01d0bbfead31f8e682846a")
- (revision "1"))
- (package
- (name "sbcl-trivial-main-thread")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/trivial-main-thread";)
- (commit commit)))
- (file-name (git-file-name "trivial-main-thread" version))
- (sha256
- (base32 "0bw1887i7396lqg75qvmgjfzz4xbiq9w5dp8wxdgrcsm0qwlraw7"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bordeaux-threads sbcl-simple-tasks sbcl-trivial-features))
- (home-page "https://shinmera.github.io/trivial-main-thread/";)
- (synopsis "Compatibility library to run things in the main thread")
- (description
- "This package provides a Common Lisp system which wraps the
-BORDEAUX-THREADS system to be able to run things in the main thread of the
-implementation, for example drawing calls of GUI applications.")
- (license license:zlib))))
+In order to make one or several variables file-local, use the macros
+@code{SET-FILE-LOCAL-VARIABLE(S)}.")
+ (home-page
"https://www.lrde.epita.fr/~didier/software/lisp/misc.php#asdf-flv";)
+ (license (license:non-copyleft
+
"https://www.gnu.org/prep/maintain/html_node/License-Notices-for-Other-Files.html";
+ "GNU All-Permissive License"))))
-(define-public ecl-trivial-main-thread
- (sbcl-package->ecl-package sbcl-trivial-main-thread))
+(define-public cl-net.didierverna.asdf-flv
+ (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
-(define-public cl-trivial-main-thread
- (sbcl-package->cl-source-package sbcl-trivial-main-thread))
+(define-public ecl-net.didierverna.asdf-flv
+ (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
-(define-public sbcl-trivial-monitored-thread
- (let ((commit "b0bab23f9a9bd06f0f33809635c7ba4e6a3d5a21")
- (revision "0"))
- (package
- (name "sbcl-trivial-monitored-thread")
- (version (git-version "0.3.11" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://gitlab.com/ediethelm/trivial-monitored-thread";)
- (commit commit)))
- (file-name (git-file-name "trivial-monitored-thread" version))
- (sha256
- (base32 "1ipnp2l944hc587bifxsnmiymw468imar0v8bqvgxv8pc5sym4ib"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-iterate sbcl-log4cl sbcl-trivial-utilities))
- (home-page "https://gitlab.com/ediethelm/trivial-monitored-thread";)
- (synopsis "Thread monitoring library for Common Lisp")
- (description
- "Trivial Monitored Thread offers a very simple (aka trivial) way of
-spawning threads and being informed when one any of them crash and die.")
- (license license:expat))))
-
-(define-public cl-trivial-monitored-thread
- (sbcl-package->cl-source-package sbcl-trivial-monitored-thread))
-
-(define-public ecl-trivial-monitored-thread
- (sbcl-package->ecl-package sbcl-trivial-monitored-thread))
-
-(define-public sbcl-moira
- (let ((commit "21f1cfd5942fcaea2ed2e4f6055b2a5a39ac4c6e")
- (revision "0"))
- (package
- (name "sbcl-moira")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/ruricolist/moira";)
- (commit commit)))
- (file-name (git-file-name "cl-moira" version))
- (sha256
- (base32 "0r6hvq8j04y1i85f8jwhhafylgfrkg8c1z5746nsbv0v0348sf5h"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-osicat
- sbcl-serapeum
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (home-page "https://github.com/ruricolist/moira";)
- (synopsis "Monitor and restart background threads")
- (description
- "Moira is a library for monitoring and, if necessary, restarting
-long-running threads. In principle, it is like an in-Lisp process
supervisor.")
- (license license:expat))))
-
-(define-public cl-moira
- (sbcl-package->cl-source-package sbcl-moira))
-
-(define-public ecl-moira
- (sbcl-package->ecl-package sbcl-moira))
-
-(define-public sbcl-with-user-abort
- (let ((commit "60693b4a1354faf17107ad6003b0b870cca37081")
- (revision "0"))
- (package
- (name "sbcl-with-user-abort")
- (version (git-version "0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/compufox/with-user-abort";)
- (commit commit)))
- (file-name (git-file-name "cl-with-user-abort" version))
- (sha256
- (base32 "0k1xxfvncdw4fx8nncis1ma128bqq05zky1mrzak5rjbivzjm8j1"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/compufox/with-user-abort";)
- (synopsis "Portability library for catching SIGINT from Common Lisp")
- (description
- "@code{with-user-abort} is a Common Lisp portability library providing a
-like-named macro that catches the SIGINT signal.")
- (license license:bsd-3))))
-
-(define-public cl-with-user-abort
- (sbcl-package->cl-source-package sbcl-with-user-abort))
-
-(define-public ecl-with-user-abort
- (sbcl-package->ecl-package sbcl-with-user-abort))
-
-(define-public sbcl-cl-package-locks
- (let ((commit "96a358ede7cef416d61d2f699e724fe1d9de602c")
- (revision "1"))
- (package
- (name "sbcl-cl-package-locks")
- (version (git-version "0.0.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/elliottjohnson/cl-package-locks";)
- (commit commit)))
- (file-name (git-file-name "cl-package-locks" version))
- (sha256
- (base32 "0g3gfljnvpgd66ccd2sqawlkwqx4a0wsdrg5180va61w869cgxqq"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/elliottjohnson/cl-package-locks";)
- (synopsis "Compatibility layer for dealing with package locks")
- (description
- "This is a Common Lisp library providing a unified way to work with
-package locks across supported Common Lisp implementations.")
- (license license:expat))))
-
-(define-public ecl-cl-package-locks
- (sbcl-package->ecl-package sbcl-cl-package-locks))
-
-(define-public cl-package-locks
- (sbcl-package->cl-source-package sbcl-cl-package-locks))
-
-(define-public sbcl-cl-typesetting
- (let ((commit "86eba981fc4254addebecf765578ec350d6e3b75")
- (revision "1"))
- (package
- (name "sbcl-cl-typesetting")
- (version (git-version "0.8.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mbattyani/cl-typesetting";)
- (commit commit)))
- (file-name (git-file-name "cl-typesetting" version))
- (sha256
- (base32 "0fcs5mq0gxfczbrg7ay8r4bf5r4g6blvpdbjkhcl8dapcikyn35h"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; NOTE: (Sharlatan-20210515T213014+0100): Circular dependencies with
- ;; cl-typegraph
- `(#:tests? #f))
- (inputs
- `(("cl-pdf" ,sbcl-cl-pdf)
- ("xmls" ,sbcl-xmls)))
- (home-page "https://github.com/mbattyani/cl-typesetting";)
- (synopsis "Stand-alone Common Lisp typesetting system")
- (description
- "CL-TYPESETTING is a cross-platform Common Lisp typesetting library for
-all kind of typesetting applications.")
- (license license:bsd-2))))
-
-(define-public ecl-cl-typesetting
- (sbcl-package->ecl-package sbcl-cl-typesetting))
-
-(define-public cl-typesetting
- (sbcl-package->cl-source-package sbcl-cl-typesetting))
-
-(define-public sbcl-shasht
- (let ((commit "27ba0a8842e103f2d575b3c8bbcfc19bd172d9ea")
- (revision "2"))
- (package
- (name "sbcl-shasht")
- (version (git-version "0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/yitzchak/shasht";)
- (commit commit)))
- (file-name (git-file-name "cl-shasht" version))
- (sha256
- (base32 "1y7qh8kdhk06243vkmxzdk0y9rax4g8pv28bd01j48ix777mpcdc"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria sbcl-parachute))
- (inputs
- (list sbcl-closer-mop sbcl-trivial-do))
- (home-page "https://yitzchak.github.io/shasht/";)
- (synopsis "Common Lisp JSON reading and writing library")
- (description
- "This package provides a Common Lisp library to work with the JSON file
-format.")
- (license license:expat))))
-
-(define-public ecl-shasht
- (sbcl-package->ecl-package sbcl-shasht))
-
-(define-public cl-shasht
- (sbcl-package->cl-source-package sbcl-shasht))
-
-(define-public sbcl-cl-speedy-queue
- (let ((commit "0425c7c62ad3b898a5ec58cd1b3e74f7d91eec4b")
- (revision "1"))
- (package
- (name "sbcl-cl-speedy-queue")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/zkat/cl-speedy-queue";)
- (commit commit)))
- (file-name (git-file-name "cl-speedy-queue" version))
- (sha256
- (base32 "0czhnvxn9lvbjz9h1lb7y18nqrsq3drq5icd3lqdaa07362alriq"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/zkat/cl-speedy-queue";)
- (synopsis "Lightweight optimized queue for Common Lisp")
- (description
- "This is a lightweight, non-consing, optimized queue implementation for
-Common Lisp.")
- (license license:expat))))
-
-(define-public cl-speedy-queue
- (sbcl-package->cl-source-package sbcl-cl-speedy-queue))
-
-(define-public ecl-cl-speedy-queue
- (sbcl-package->ecl-package sbcl-cl-speedy-queue))
-
-(define-public sbcl-lev
- (let ((commit "7d03c68dad44f1cc4ac2aeeab2d24eb525ad941a")
- (revision "1"))
- (package
- (name "sbcl-lev")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/lev";)
- (commit commit)))
- (file-name (git-file-name "lev" version))
- (sha256
- (base32 "14lfnrvfyg2nnvlwck896p6vgarzc6g4kijmvhi2d8wra7gxzifh"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; NOTE: (Sharlatan-20210520T163300+0100): No tests in upstream
- `(#:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-libev-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/lev.lisp"
- (("libev.so" _)
- (search-input-file inputs "/lib/libev.so"))))))))
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("libev" ,libev)))
- (home-page "https://github.com/fukamachi/lev";)
- (synopsis "Common Lisp bindings for libev")
- (description "This package provides Common Lisp bindings for libev.")
- (license license:bsd-2))))
-
-(define-public cl-lev
- (sbcl-package->cl-source-package sbcl-lev))
-
-(define-public ecl-lev
- (sbcl-package->ecl-package sbcl-lev))
-
-(define-public sbcl-woo
- (let ((commit "fba3567be95ed6e782d98a4c1477d3a74b8ad124")
- (revision "1"))
- (package
- (name "sbcl-woo")
- (version (git-version "0.12.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/woo";)
- (commit commit)))
- (file-name (git-file-name "woo" version))
- (sha256
- (base32 "06f95x8s8v523gxmrkn9wwgw2pvc3bc66znbgrzhqb30y4aar5v5"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; FIXME: Tests fail because they try to compile clack-test:
- ;;
- ;; Error opening #P"/gnu/store/...-sbcl-clack-2.0.0-1.e3e0328/
- ;; lib/common-lisp/sbcl/clack/src/test-tmpGHU3ALSV.fasl":
- ;;
- ;; Permission denied
- ;;
- ;; clack-test should be compiled when building the sbcl-clack package,
- ;; but it isn't right now because of the circular dependency between
- ;; clack-test and dexador.
- `(#:tests? #f))
- (native-inputs
- (list sbcl-clack sbcl-rove))
- (inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-cl-speedy-queue ;; Required for ecl build
- sbcl-clack
- sbcl-fast-http
- sbcl-fast-io
- sbcl-lev
- sbcl-quri
- sbcl-rove
- sbcl-smart-buffer
- sbcl-static-vectors
- sbcl-swap-bytes
- sbcl-trivial-utf-8
- sbcl-vom))
- (home-page "https://github.com/fukamachi/woo";)
- (synopsis "Non-blocking HTTP server based on libev")
- (description
- "This package provides the Common Lisp HTTP server @code{WOO}, which
-is built on top of the @code{libev} event library.")
- (license license:expat))))
-
-(define-public cl-woo
- (sbcl-package->cl-source-package sbcl-woo))
-
-(define-public ecl-woo
- (sbcl-package->ecl-package sbcl-woo))
-
-(define-public sbcl-json-streams
- (let ((commit "5da012e8133affbf75024e7500feb37394690752")
- (revision "1"))
- (package
- (name "sbcl-json-streams")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rotatef/json-streams";)
- (commit commit)))
- (file-name (git-file-name "json-streams" version))
- (sha256
- (base32 "0cia3721im04q73dfkd688d8splgpz03qa4h8s3r39kar4w3xll2"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-cl-quickcheck sbcl-flexi-streams))
- (home-page "https://github.com/rotatef/json-streams";)
- (synopsis "Common Lisp library for reading and writing JSON")
- (description
- "This package provides a stream based JSON parser/writer, well suited as
-building block for higher level libraries.")
- (license license:gpl3+))))
-
-(define-public cl-json-streams
- (sbcl-package->cl-source-package sbcl-json-streams))
-
-(define-public ecl-json-streams
- (sbcl-package->ecl-package sbcl-json-streams))
-
-(define-public sbcl-arnesi
- (let ((commit "1e7dc4cb2cad8599113c7492c78f4925e839522e")
- (revision "1"))
- (package
- (name "sbcl-arnesi")
- (version (git-version "2.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/AccelerationNet/arnesi";)
- (commit commit)))
- (file-name (git-file-name "arnesi" version))
- (sha256
- (base32 "0jgj2xgd1gq6rf8ia43lkmbrbxnp8rgs053br9azfa25ygk3ikbh"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; FIXME: (Sharlatan-20210523T190315+0100): Tests failed on
- ;; special-lisp-var-rebount-in/cc
- ;;
- ;; ; processing (TEST SPECIAL-LISP-VAR-REBOUND-IN/CC ...)
- ;; ; wrote .../sbcl/arnesi/t/call-cc-tmp5GEXGEG5.fasl
- ;; ; compilation finished in 0:00:00.028
- ;; Unhandled SIMPLE-ERROR in thread
- ;; #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>:
- ;; Sorry, No walker for the special operater DECLARE defined.
- ;;
- ;; Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>
- ;; 0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SIMPLE-ERROR "Sorry,
- ;; No walker for the special operater ~S defined."
- ;; {1001FAF9D3}> #<unused argument> :QUIT T)
- ;;
- `(#:tests? #f))
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("collectors" ,sbcl-collectors)
- ("swank" ,sbcl-slime-swank)))
- (home-page "https://github.com/AccelerationNet/arnesi";)
- (synopsis "Common Lisp utility suite")
- (description
- "ARNESI is Common Lisp utilities library similar to ALEXANDRIA, ANAPHORA
-or GOLDEN-UTILS.")
- (license license:bsd-3))))
+(define-public sbcl-nfiles
+ (package
+ (name "sbcl-nfiles")
+ (version "1.1.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/nfiles";)
+ (commit version)))
+ (file-name (git-file-name "cl-nfiles" version))
+ (sha256
+ (base32
+ "1a8zsphbbl9r4sdm95kgm4ljd9b148c9fnwlq7f930fh9826kf72"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list gnupg
+ sbcl-alexandria
+ sbcl-nclasses
+ sbcl-quri
+ sbcl-serapeum
+ sbcl-trivial-garbage
+ sbcl-trivial-package-local-nicknames
+ sbcl-trivial-types))
+ (native-inputs
+ (list sbcl-lisp-unit2))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gpg.lisp"
+ (("\"gpg\"")
+ (string-append "\"" (assoc-ref inputs "gnupg")
"/bin/gpg\""))))))))
+ (home-page "https://github.com/atlas-engineer/nfiles";)
+ (synopsis "Manage file persistence and loading in Common Lisp")
+ (description
+ "NFiles is a Common Lisp library to help manage file persistence and
+loading, in particular user-centric files like configuration files. It boasts
+the following features:
-(define-public ecl-arnesi
- (sbcl-package->ecl-package sbcl-arnesi))
+@itemize
+@item Dynamic and customizable path expansion.
-(define-public cl-arnesi
- (sbcl-package->cl-source-package sbcl-arnesi))
+@item Extensible serialization and deserialization.
-(define-public sbcl-gettext
- (let ((commit "a432020cbad99fc22cbe6bb9aa8a83a35000d7aa")
- (revision "1"))
- (package
- (name "sbcl-gettext")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rotatef/gettext";)
- (commit commit)))
- (file-name (git-file-name "gettext" version))
- (sha256
- (base32 "1pzhamgni6k5hi6bbvlb3dm659pcllrrr3vhhn3rpjn238zxg5ar"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-stefil))
- (inputs
- (list sbcl-flexi-streams sbcl-split-sequence sbcl-cl-yacc))
- (home-page "https://github.com/rotatef/gettext";)
- (synopsis "Common Lisp implementation of Gettext")
- (description
- "This package provides GNU @code{gettext} completely implemented in
-Common Lisp without any C library bindings.")
- (license license:lgpl3+))))
+@item Cached reads and writes. When a file object expands to the same path as
+another one, a read or write on it won’t do anything in case there was no
+change since last write.
-(define-public ecl-gettext
- (sbcl-package->ecl-package sbcl-gettext))
+@item (Experimental!) On-the-fly PGP encryption.
-(define-public cl-gettext
- (sbcl-package->cl-source-package sbcl-gettext))
+@item Profile support.
-(define-public sbcl-parser-combinators
- (let ((commit "9c7569a4f6af5e60c0d3a51d9c15c16d1714c845")
- (revision "1"))
- (package
- (name "sbcl-parser-combinators")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Ramarren/cl-parser-combinators";)
- (commit commit)))
- (file-name (git-file-name "parser-combinators" version))
- (sha256
- (base32 "1k49vha5xm2cklayzpqwg73n4v93xwsbs5in6342pkkiimnidhs8"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; FIXME: (Sharlatan-20210523T184237+0100): Tests require `femlisp',
which
- ;; is quite chunky not packaged system yet, enable them when it's
packed.
- `(#:tests? #f))
- ;; (native-inputs
- ;; `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)
- ;; ("infix" ,sbcl-femlisp)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-containers" ,sbcl-cl-containers)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("iterate" ,sbcl-iterate)))
- (home-page "https://github.com/Ramarren/cl-parser-combinators";)
- (synopsis "Parser combinators in Common Lisp")
- (description
- "PARSER-COMBINATORS is a library implementing monadic parser
-combinators in Common Lisp, similar in concept to Haskell Parsec system.")
- (license license:bsd-3))))
+@item On read error, existing files are backed up.
-(define-public ecl-parser-combinators
- (sbcl-package->ecl-package sbcl-parser-combinators))
+@item On write error, no file is written to disk, the existing file is
preserved.
+@end itemize\n")
+ (license license:bsd-3)))
-(define-public cl-parser-combinators
- (sbcl-package->cl-source-package sbcl-parser-combinators))
+(define-public cl-nfiles
+ (package
+ (inherit (sbcl-package->cl-source-package sbcl-nfiles))
+ (inputs
+ (cons (list "iolib" cl-iolib)
+ (package-inputs sbcl-nfiles)))))
-(define-public sbcl-cl-locale
- (let ((commit "0a36cc0dcf5e0a8c8bf97869cd6199980ca25eec")
- (revision "1"))
+(define-public ecl-nfiles
+ (let ((pkg (sbcl-package->ecl-package sbcl-nfiles)))
(package
- (name "sbcl-cl-locale")
- (version (git-version "0.1.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/cl-locale";)
- (commit commit)))
- (file-name (git-file-name "cl-locale" version))
- (sha256
- (base32 "1rhannhpsw1yg1fpflam483a3w9qb1izgyvmnmiddv3dn4qsmn9p"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-locale-test" "cl-locale")))
- (native-inputs
- `(("prove" ,sbcl-prove)
- ("flexi-streams" ,sbcl-flexi-streams)))
+ (inherit pkg)
(inputs
- `(("anaphora" ,sbcl-anaphora)
- ("arnesi" ,sbcl-arnesi)
- ("cl-annot" ,sbcl-cl-annot)
- ("cl-syntax" ,sbcl-cl-syntax)))
- (home-page "https://github.com/fukamachi/cl-locale";)
- (synopsis "Internalization library for Common Lisp")
- (description
- "This package provides a Common Lisp translation library similar to
-CL-I18N and CL-L10N.")
- (license license:llgpl))))
+ (cons (list "iolib" ecl-iolib)
+ (package-inputs pkg))))))
-(define-public ecl-cl-locale
- (sbcl-package->ecl-package sbcl-cl-locale))
+(define-public sbcl-nhooks
+ (package
+ (name "sbcl-nhooks")
+ (version "1.2.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/nhooks";)
+ (commit version)))
+ (file-name (git-file-name "cl-nhooks" version))
+ (sha256
+ (base32
+ "1m9dfp7wjm8k16x45qnw258ca8gnic3k2ik79sdn5gxcx6qxy3g8"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-serapeum))
+ (native-inputs
+ (list sbcl-lisp-unit2))
+ (home-page "https://github.com/atlas-engineer/nhooks";)
+ (synopsis "Hook facility for Common Lisp")
+ (description "This package holds an enhanced implementation of
+hooks (extension points). It works similarly to Emacs hooks with crucial
+improvements:
-(define-public cl-locale
- (sbcl-package->cl-source-package sbcl-cl-locale))
+@itemize
-(define-public sbcl-cl-slice
- (let ((commit "c531683f287216aebbb0affbe090611fa1b5d697")
- (revision "1"))
- (package
- (name "sbcl-cl-slice")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tpapp/cl-slice";)
- (commit commit)))
- (file-name (git-file-name "cl-slice" version))
- (sha256
- (base32 "1ybznf4y5lda6bn163jcvj281qzhm24dfcwhbgxmm5n6f27gdccl"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-clunit))
- (inputs
- (list sbcl-alexandria sbcl-anaphora sbcl-let-plus))
- (home-page "https://github.com/tpapp/cl-slice";)
- (synopsis "Array slices for Common Lisp")
- (description
- "This package provides a DSL for array slices in Common Lisp.")
- (license license:expat))))
+@item If the compiler allows it (such as SBCL), type-checking is performed at
+compile-time and at run-time when adding handlers to a hook.
-(define-public ecl-cl-slice
- (sbcl-package->ecl-package sbcl-cl-slice))
+@item On failure, multiple restarts are offered, such as disabling the
+offending handler or simply continuing to the next function.
-(define-public cl-slice
- (sbcl-package->cl-source-package sbcl-cl-slice))
+@item The hook handler execution order and combination can be customized.
-(define-public sbcl-djula
- (let ((commit "6f142594e0372437e64f610b796350ad89ba0be1")
- (revision "2"))
- (package
- (name "sbcl-djula")
- (version (git-version "0.2.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mmontone/djula";)
- (commit commit)))
- (file-name (git-file-name "cl-djula" version))
- (sha256
- (base32 "0yyg61hrql1vrwllyd23vidiff28ridh0avxyvnqb89v060d1j83"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-access
- sbcl-alexandria
- sbcl-anaphora
- sbcl-babel
- sbcl-cl-locale
- sbcl-cl-ppcre
- sbcl-cl-slice
- sbcl-closer-mop
- sbcl-gettext
- sbcl-iterate
- sbcl-local-time
- sbcl-parser-combinators
- sbcl-split-sequence
- sbcl-trivial-backtrace))
- (home-page "https://mmontone.github.io/djula/djula/";)
- (synopsis "Common Lisp port of the Django templating language")
- (description
- "This package provides a Common Lisp templating system based on Python
-Django with a syntax similar to Python Jinja2.")
- (license license:expat))))
+@item Anonymous functions (lambdas) can be added to hooks as handler objects.
+When inspecting hooks, readable names are thus exposed instead of lambda
+blackboxes. Handlers are compared through their names (through the mandatory
+name slot). A hook can not contain multiple handlers with the same name.
+
+@item A special provision is taken for “setters”, handlers that are meant to
+set a given place to a given values. Such handler objects can be compared and
+identified uniquely.
-(define-public ecl-djula
- (sbcl-package->ecl-package sbcl-djula))
+@end itemize\n")
+ (license license:expat)))
-(define-public cl-djula
- (sbcl-package->cl-source-package sbcl-djula))
+(define-public cl-nhooks
+ (sbcl-package->cl-source-package sbcl-nhooks))
-(define-public sbcl-for
- (let ((commit "a39782991292e44ee3b5e2e25cddaa8115f6d363")
- (revision "1"))
+(define-public ecl-nhooks
+ (sbcl-package->ecl-package sbcl-nhooks))
+
+(define-public sbcl-nibbles
+ ;; No tagged release since 2018.
+ (let ((commit "a46a67736e07b548cdd7485cb36834f7942313f1")
+ (revision "3"))
(package
- (name "sbcl-for")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-nibbles")
+ (version (git-version "0.14" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/for";)
+ (url "https://github.com/sharplispers/nibbles/";)
(commit commit)))
- (file-name (git-file-name "cl-for" version))
+ (file-name (git-file-name "cl-nibbles" version))
(sha256
- (base32 "07jdwqkyb3qd65mng60cs723z7p0bv2769hhalz4c0mfzn8qrn99"))))
+ (base32 "12qjich11hp31dhbvbsixyjbddmr6faaajigrivgbxy9kw6d279j"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-documentation-utils sbcl-form-fiddle sbcl-lambda-fiddle))
- (home-page "https://shinmera.github.io/for/";)
- (synopsis "Extensible iteration macro library")
+ (native-inputs
+ ;; Tests only.
+ (list sbcl-rt))
+ (synopsis
+ "Common Lisp library for accessing octet-addressed blocks of data")
(description
- "For is a library for an extensible iteration macro. It allows you to
write
-concise looping constructs similar to @code{loop} and @code{iterate}. Unlike
-loop however it is extensible and sensible, and unlike iterate it does not
-require code-walking and is easier to extend.")
- (license license:zlib))))
+ "When dealing with network protocols and file formats, it's common to
+have to read or write 16-, 32-, or 64-bit datatypes in signed or unsigned
+flavors. Common Lisp sort of supports this by specifying :element-type for
+streams, but that facility is underspecified and there's nothing similar for
+read/write from octet vectors. What most people wind up doing is rolling their
+own small facility for their particular needs and calling it a day.
-(define-public ecl-for
- (sbcl-package->ecl-package sbcl-for))
+This library attempts to be comprehensive and centralize such
+facilities. Functions to read 16-, 32-, and 64-bit quantities from octet
+vectors in signed or unsigned flavors are provided; these functions are also
+SETFable. Since it's sometimes desirable to read/write directly from streams,
+functions for doing so are also provided. On some implementations,
+reading/writing IEEE singles/doubles (i.e. single-float and double-float) will
+also be supported.")
+ (home-page "https://github.com/sharplispers/nibbles";)
+ (license license:bsd-3))))
-(define-public cl-for
- (sbcl-package->cl-source-package sbcl-for))
+(define-public cl-nibbles
+ (sbcl-package->cl-source-package sbcl-nibbles))
-(define-public sbcl-flare
- (let ((commit "4f9f17a4fc5b368c2a1988b9a20288695b8d8c48")
- (revision "1"))
+(define-public ecl-nibbles
+ (sbcl-package->ecl-package sbcl-nibbles))
+
+(define-public sbcl-ningle
+ (let ((commit "2e85675bbb668d6ef341514fc9f22391a0f506b1")
+ (revision "2"))
(package
- (name "sbcl-flare")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-ningle")
+ (version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/flare";)
+ (url "https://github.com/fukamachi/ningle";)
(commit commit)))
- (file-name (git-file-name "flare" version))
+ (file-name (git-file-name "cl-ningle" version))
(sha256
- (base32 "00nm3sjngbflj2gd5q0xs2m136w4kix6krww23nk64pkkyq2fs86"))))
+ (base32 "0s9nn8ml1j4839rycvdjcbsynkqnhxw1zmrgpjz48smscwdf1f8p"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:tests? #f)) ; TODO: pull in clack-test
+ (native-inputs
+ (list sbcl-prove))
(inputs
- (list sbcl-3d-vectors
- sbcl-array-utils
- sbcl-documentation-utils
- sbcl-for
- sbcl-lambda-fiddle
- sbcl-trivial-garbage))
- (home-page "https://shinmera.github.io/flare/";)
- (synopsis "Easy particle systems with fine grained control")
+ (list sbcl-cl-syntax sbcl-myway sbcl-lack sbcl-alexandria
+ sbcl-babel))
+ (home-page "https://8arrow.org/ningle/";)
+ (synopsis "Super micro framework for Common Lisp")
(description
- "FLARE is a library designed to allow quick and precise particle effect
-creations. It does not concern itself with displaying and only with the
-management and movement of particles. As such, it can easily be integrated
into
-any existing or future application.")
- (license license:zlib))))
+ "Ningle is a lightweight web application framework for Common Lisp.")
+ (license license:llgpl))))
-(define-public ecl-flare
- (sbcl-package->ecl-package sbcl-flare))
+(define-public cl-ningle
+ (sbcl-package->cl-source-package sbcl-ningle))
-(define-public cl-flare
- (sbcl-package->cl-source-package sbcl-flare))
+(define-public ecl-ningle
+ (sbcl-package->ecl-package sbcl-ningle))
-(define-public sbcl-simple-inferiors
- (let ((commit "deac886354e03f8a9502ce96f12a0459ce3be671"))
- (package
- (name "sbcl-simple-inferiors")
- (version (git-version "1.1.0" "1" commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/simple-inferiors";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "08vsvqv3768bwb2y8mwxbw5wyqzzwqr7rd004r6gafdgf9p9mcx3"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bordeaux-threads sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/simple-inferiors/";)
- (synopsis "Common Lisp library to use inferior processes")
- (description
- "This is a library to allow easy handling of external processes, and
-primarily to get their output. It handles proper copying of the standard and
-error outputs of the process simultaneously, both in a sequential and parallel
-fashion. It also features a lazy directory switching mechanism, to avoid
-running into parallelism problems when having to change directory.")
- (license license:zlib))))
+(define-public sbcl-njson
+ (package
+ (name "sbcl-njson")
+ (version "1.2.2")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/njson";)
+ (commit version)))
+ (file-name (git-file-name "cl-njson" version))
+ (sha256
+ (base32
+ "05v5bk3l47mds4ihxs8jlqm19gqq7hb4q0161bgg99w9847l63lk"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs (list sbcl-cl-json sbcl-jzon))
+ (native-inputs (list sbcl-lisp-unit2))
+ (arguments
+ '(#:asd-systems '("njson" "njson/cl-json" "njson/jzon")))
+ (home-page "https://github.com/atlas-engineer/njson";)
+ (synopsis "JSON handling framework for Common Lisp")
+ (description
+ "NJSON aims to make it convenient for one to decode, encode,
+and process JSON data, in the minimum keystrokes/minutes possible.
-(define-public ecl-simple-inferiors
- (sbcl-package->ecl-package sbcl-simple-inferiors))
+NJSON is parser-independent, with existing Common Lisp JSON parsers being
+loadable as additional system. @code{jzon} is included by default, though.
+Conveniences that NJSON provides are:
-(define-public cl-simple-inferiors
- (sbcl-package->cl-source-package sbcl-simple-inferiors))
+@itemize
+@item @code{encode} and @code{decode} as single entry points for JSON reading
+and writing, be it from streams/string/files, or from those.
-(define-public sbcl-metacopy
- (let ((commit "df7856f2a43fa91124fe780ef22f792040bc130c")
- (revision "2"))
- (package
- (name "sbcl-metacopy")
- (version (git-version "0.2.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- ;; Upstream changed the maintaner.
- ;; legacy https://github.com/gwkkwg/metacopy
- (url "https://github.com/hraban/metacopy";)
- (commit commit)))
- (file-name (git-file-name "cl-metacopy" version))
- (sha256
- (base32 "0l5ryg8pvqz9sn9s8bsvd0plvcnm7crsx86iqk5wxblkialaizip"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-asdf-system-connections sbcl-lift))
- (inputs
- (list sbcl-contextl sbcl-moptilities))
- (home-page "https://github.com/hraban/metacopy";)
- (synopsis "Flexible Common Lisp shallow/deep copy mechanism")
- (description
- "This package provides a flexible shallow/deep copy mechanism for
-Common Lisp.")
- (license license:expat))))
+@item @code{jget}, @code{jcopy}, @code{jkeys}, and their aliases to
+manipulate the decoded objects' properties without the need to worry
+about the low-level details of how these values are decoded.
+
+@item @code{jif}, @code{jwhen}, @code{jor}, @code{jand}, and other macros
+mimicking Lisp ones, while using truth values of JSON-decoded data.
+
+@item @code{jbind} and @code{jmatch} macros to destructure and
+validate parsed JSON.
+
+@item @code{njson/aliases} package to nickname to @code{j} for all the
+forms conveniently accessible as @code{j:get}, @code{j:copy},
+@code{j:if} etc.
+
+@end itemize\n")
+ (license license:bsd-3)))
+
+(define-public cl-njson
+ (sbcl-package->cl-source-package sbcl-njson))
+
+(define-public ecl-njson
+ (sbcl-package->ecl-package sbcl-njson))
+
+(define-public sbcl-nkeymaps
+ (package
+ (name "sbcl-nkeymaps")
+ (version "1.1.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/nkeymaps";)
+ (commit version)))
+ (file-name (git-file-name "cl-nkeymaps" version))
+ (sha256
+ (base32 "179hrnkn3pkwkp4ap6ax0zgp7xcr9cq7icff42r79gh43ri3kpzy"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-fset
+ sbcl-cl-str
+ sbcl-trivial-package-local-nicknames))
+ (native-inputs
+ (list sbcl-lisp-unit2))
+ (home-page "https://github.com/atlas-engineer/nkeymaps";)
+ (synopsis "Keymap facility for Common Lisp")
+ (description
+ "This is a keymap facility for Common Lisp inspired by Emacsy
+(keymap.scm) which is inspired by Emacs.
+@itemize
+
+@item Support prefix keys to other keymaps. For instance, if you prefix
+my-mode-map with C-c, then all bindings for my-mode will be accessible after
+pressing C-c.
-(define-public ecl-metacopy
- (sbcl-package->ecl-package sbcl-metacopy))
+@item List all bindings matching a given prefix. (Also known as which-key in
+Emacs.)
-(define-public cl-metacopy
- (sbcl-package->cl-source-package sbcl-metacopy))
+@item List the bindings associated to a command.
-(define-public sbcl-legit
- (let ((commit "9c677b9b798803d37ab6f5e0e0705441872f7230")
- (revision "3"))
- (package
- (name "sbcl-legit")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/legit";)
- (commit commit)))
- (file-name (git-file-name "cl-legit" version))
- (sha256
- (base32 "0jy021ywrbnkgbgb63ip6j7kr40m4wz2pz1v5ybn6xkkn6dyprsz"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-git-executable
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "process.lisp"
- (("\"git")
- (string-append "\"" (search-input-file inputs
- "/bin/git")))))))))
- (inputs
- (list git
- sbcl-cl-ppcre
- sbcl-documentation-utils
- sbcl-lambda-fiddle
- sbcl-simple-inferiors))
- (home-page "https://shinmera.github.io/legit/";)
- (synopsis "Interface to the git binary")
- (description
- "This is an interface to the @code{git} binary to make controlling it
-from within Common Lisp much easier. It might not ever reach full coverage of
-all features given git's immense size, but features will be added as they are
-needed. The low-level command API is fully mapped however.")
- (license license:zlib))))
+@item Support multiple inheritance.
-(define-public ecl-legit
- (sbcl-package->ecl-package sbcl-legit))
+@item Support keycode.
-(define-public cl-legit
- (sbcl-package->cl-source-package sbcl-legit))
+@item Validate keyspec at compile time.
-(define-public sbcl-flow
- (let ((commit "6d925af009cdfe033650d7048197a5e6ee937d15")
- (revision "1"))
- (package
- (name "sbcl-flow")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/flow";)
- (commit commit)))
- (file-name (git-file-name "flow" version))
- (sha256
- (base32 "0ysw1kwiqlf8kzllhnz8v3q40dmvwf83fzq8bfkbmwy5hfjh3pxp"))))
- (build-system asdf-build-system/sbcl)
- ;; FIXME: (Sharlatan-20210527T203118+0100): FLOW-VISUALIZER requires
- ;; COMMONQT which is not packed yet and required tweaks with QT. Remove
- ;; this when it's ready.
- (inputs
- `(("closer-mop" ,sbcl-closer-mop)
- ("documentation-utils" ,sbcl-documentation-utils)))
- (home-page "https://shinmera.github.io/flow/";)
- (synopsis "Tools for the representation of graphs and flowcharts")
- (description
- "FLOW is a flowchart graph library. Unlike other graphing libraries,
-this one focuses on nodes in a graph having distinct @code{ports} through which
-connections to other nodes are formed. This helps in many concrete scenarios
-where it is important to distinguish not only which nodes are connected, but
-also how they are connected to each other.
+@item define-key can set multiple bindings in a single call.
-Particularly, a lot of data flow and exchange problems can be reduced to such
-a @code{flowchart}. For example, an audio processing library may present its
-pipeline as a flowchart of segments that communicate with each other through
-audio sample buffers. Flow gives a convenient view onto this kind of problem,
-and even allows the generic visualisation of graphs in this format.")
- (license license:zlib))))
+@item Support multiple scheme to make it easy to switch between, say,
+Emacs-style and VI-style bindings. This orthogonality to keymaps composes
+better than having multiple keymaps: changing scheme applies to the entire
+program, which is easier than looping through all keymaps to change them.
-(define-public ecl-flow
- (sbcl-package->ecl-package sbcl-flow))
+@item Translate keyspecs as a fallback. For instance if shift-a is not bound,
+check A.
-(define-public cl-flow
- (sbcl-package->cl-source-package sbcl-flow))
+@item Behaviour can be customized with global parameters such as
+*print-shortcut*.
-(define-public sbcl-cl-glfw3
- (let ((commit "32c3f34d592d55ee7ce932ed85804c1a9c4158c6")
+@item The compose function can merge multiple keymaps together.
+
+@item Support multiple arguments when that makes sense (e.g. multiple keymaps
+for lookup-key).
+
+@item Key remapping à-la Emacs.
+
+@item Typed keymaps, i.e. keymaps where bound values can only be of a given
+type. This is convenient to catch typos, for instance when binding 'FOO
+instead of #'FOO.
+@end itemize")
+ (license license:bsd-3)))
+
+(define-public cl-nkeymaps
+ (sbcl-package->cl-source-package sbcl-nkeymaps))
+
+(define-public ecl-nkeymaps
+ (sbcl-package->ecl-package sbcl-nkeymaps))
+
+(define-public sbcl-nodgui
+ (let ((commit "9d0c9731bc2f2b434f0ddabe4b3796432aad8cba")
(revision "1"))
(package
- (name "sbcl-cl-glfw3")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-nodgui")
+ (version (git-version "0.6.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AlexCharlton/cl-glfw3";)
+ (url "https://codeberg.org/cage/nodgui.git";)
(commit commit)))
- (file-name (git-file-name "cl-glfw3" version))
+ (file-name (git-file-name "cl-nodgui" version))
(sha256
- (base32 "1wzr43nckdx4rlgxzhm1r4kfc264q969mc43y0js9ramh7l8gba5"))))
+ (base32 "0j98mcq0mn3wrlqm3j29pv530q0pkq00sk6liai97an51i1n08g6"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-glfw-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "glfw-bindings.lisp"
- (("libglfw.so.3" _)
- (search-input-file inputs "/lib/libglfw.so.3"))))))))
+ (native-inputs
+ (list sbcl-clunit2))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-opengl" ,sbcl-cl-opengl)
- ("glfw" ,glfw)
- ("trivial-main-thread" ,sbcl-trivial-main-thread)))
- (home-page "https://github.com/AlexCharlton/cl-glfw3";)
- (synopsis "Common Lisp bindings to GLFW version 3.x")
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cl-colors2
+ sbcl-cl-ppcre-unicode
+ sbcl-cl-unicode
+ sbcl-esrap
+ sbcl-flexi-streams
+ sbcl-jpeg-turbo
+ sbcl-named-readtables
+ sbcl-cl-opengl
+ sbcl-parse-number
+ sbcl-pngload
+ sbcl-sdl2
+ sbcl-static-vectors
+ sbcl-trivial-garbage
+ sbcl-zpng
+ tk
+ tklib))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/wish-communication.lisp"
+ (("#-freebsd \"wish\"")
+ (string-append "#-freebsd \""
+ (search-input-file inputs "/bin/wish")
+ "\""))))))))
+ (synopsis "Common Lisp bindings for the Tk GUI toolkit")
(description
- "This package provides a Common Lisp bindings to @code{glfw}, an OpenGL
-application development library.")
- (license license:bsd-2))))
+ "Nodgui (@emph{No Drama GUI}) is a Common Lisp binding for the Tk GUI
+toolkit. It also provides a few additional widgets more than the standard Tk
+ones.")
+ (home-page "https://www.autistici.org/interzona/nodgui.html";)
+ (license license:llgpl))))
-(define-public ecl-cl-glfw3
- (sbcl-package->ecl-package sbcl-cl-glfw3))
+(define-public cl-nodgui
+ (sbcl-package->cl-source-package sbcl-nodgui))
-(define-public cl-glfw3
- (sbcl-package->cl-source-package sbcl-cl-glfw3))
+(define-public ecl-nodgui
+ (sbcl-package->ecl-package sbcl-nodgui))
-(define-public sbcl-cl-gltf
- (let ((commit "7a3af05a7f491d8973b217f096806ef12a97474b")
- (revision "1"))
+(define-public sbcl-nsymbols
+ (package
+ (name "sbcl-nsymbols")
+ (version "0.3.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/nsymbols";)
+ (commit version)))
+ (file-name (git-file-name "cl-nsymbols" version))
+ (sha256
+ (base32 "1awh793s4fwhddllfcjz4sbkxwinh5w54s3glxh7rv00c7skdjd6"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-lisp-unit2))
+ (inputs (list cl-closer-mop))
+ (arguments
+ '(#:asd-systems '("nsymbols" "nsymbols/star")))
+ (synopsis
+ "Functions to search, filter, and group symbols in chosen packages")
+ (home-page "https://github.com/atlas-engineer/nsymbols";)
+ (description "Nsymbols extends the regular package API of ANSI CL with more
+operations, allowing one to list:
+
+@itemize
+@item @code{package-symbols}.
+@item @code{package-variables}.
+@item @code{package-functions}.
+@item @code{package-generic-functions}.
+@item @code{package-macros}.
+@item @code{package-classes}.
+@item @code{package-structures}.
+@item And other symbol types, given @code{define-symbol-type} for those.
+@end itemize
+
+Nsymbols can also find symbols by their name/matching symbol with
+@code{resolve-symbol}. All these operations are aware of symbol
+visibility in the given packages, due to a @code{symbol-visibility}
+function.
+
+An additional @code{nsymbols/star} system has a set of functions
+mirroring the regular Nsymbols ones, but using @code{closer-mop} to
+provide better results and returning structured data instead of
+symbols.")
+ (license license:bsd-3)))
+
+(define-public cl-nsymbols
+ (sbcl-package->cl-source-package sbcl-nsymbols))
+
+(define-public ecl-nsymbols
+ (sbcl-package->ecl-package sbcl-nsymbols))
+
+(define-public sbcl-numcl
+ (let ((commit "a28f612d072e5f93137584de5155a42243b3bd6b")
+ (revision "3"))
(package
- (name "sbcl-cl-gltf")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-numcl")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-gltf";)
+ (url "https://github.com/numcl/numcl";)
(commit commit)))
- (file-name (git-file-name "cl-gltf" version))
+ (file-name (git-file-name "numcl" version))
(sha256
- (base32 "1d64fg2l2c0wns3wpp1xypd8687gnp3k70fv9fb48m1kpzg4kvrh"))))
+ (base32 "15m4spbgayawnw5jjz04zfp0jnk9g6hgq5fmr648hzjzj50j1d78"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; No tests provided.
- `(#:tests? #f))
+ `(;; Tests often fail because they require a dynamic-space-size much
+ ;; bigger than the default one. Disable them for now.
+ #:tests? #f))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-documentation-utils
- sbcl-cffi
- sbcl-jzon
- sbcl-mmap
- sbcl-nibbles
- sbcl-qbase64
- sbcl-static-vectors
- sbcl-trivial-extensible-sequences))
- (home-page "https://shirakumo.github.io/cl-gltf/";)
- (synopsis "Common Lisp parser for glTF file format")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-randist" ,sbcl-cl-randist)
+ ("constantfold" ,sbcl-constantfold)
+ ("float-features" ,sbcl-float-features)
+ ("function-cache" ,sbcl-function-cache)
+ ("gtype" ,sbcl-gtype)
+ ("iterate" ,sbcl-iterate)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("specialized-function" ,sbcl-specialized-function)
+ ("trivia" ,sbcl-trivia)
+ ("type-r" ,sbcl-type-r)))
+ (home-page "https://numcl.github.io/numcl/";)
+ (synopsis "Numpy clone in Common Lisp")
(description
- "This package provides a Common Lisp parser for glTF file format.")
- (license license:zlib))))
+ "This package is a Python Numpy clone implemented in pure Common Lisp.")
+ (license license:lgpl3+))))
-;; FIXME: ECL part is failing
-;; ;;; Internal error:
-;;
-;; ** There is no package with the name SEQUENCE.An error occurred during
-;; initialization: COMPILE-FILE-ERROR while compiling #<cl-source-file
-;; "trivial-extensible-sequences" "fallback">.
-;;
-;; See <https://github.com/Shirakumo/cl-gltf/issues/3>
-;;
-;; (define-public ecl-cl-gltf
-;; (sbcl-package->ecl-package sbcl-cl-gltf))
+(define-public cl-numcl
+ (sbcl-package->cl-source-package sbcl-numcl))
-(define-public cl-gltf
- (sbcl-package->cl-source-package sbcl-cl-gltf))
+(define-public ecl-numcl
+ (sbcl-package->ecl-package sbcl-numcl))
-(define-public sbcl-chirp
- (let ((commit "01c79fa41939688216d1f86d0766a687becb0654")
- (revision "1"))
+(define-public sbcl-numerical-utilities
+ (let ((commit "44f45ba952b35675640630e40cf90df6f8279746")
+ (revision "0"))
(package
- (name "sbcl-chirp")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-numerical-utilities")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/chirp";)
+ (url "https://github.com/Lisp-Stat/numerical-utilities";)
(commit commit)))
- (file-name (git-file-name "chirp" version))
+ (file-name (git-file-name "cl-numerical-utilities" version))
(sha256
- (base32 "10xlz1vwdv3jv48kmpndpnrg6672m0r5vsjgm2pksfl8bc05j2m0"))))
+ (base32 "1dwz8zxhqzi31qp863zj1cn1lgljny14snycb9nk871qs121kmsd"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("chirp-core" "chirp-dexador" "chirp-drakma" "chirp")))
+ '(#:asd-systems '("num-utils" "num-utils/tests")))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)
- ("cl-base64" ,sbcl-cl-base64)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("dexador" ,sbcl-dexador)
- ("drakma" ,sbcl-drakma)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("ironclad" ,sbcl-ironclad)
- ("local-time" ,sbcl-local-time)
- ("split-sequence" ,sbcl-split-sequence)
- ("uuid" ,sbcl-uuid)
- ("yason" ,sbcl-yason)))
- (home-page "https://shinmera.github.io/chirp/";)
- (synopsis "Twitter client library for Common Lisp")
+ (list sbcl-alexandria
+ sbcl-alexandria-plus
+ sbcl-anaphora
+ sbcl-array-operations
+ sbcl-let-plus
+ sbcl-select))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://lisp-stat.github.io/numerical-utilities";)
+ (synopsis "Utilities for numerical programming")
(description
- "This package provides a Common Lisp Twitter client featuring full API
-coverage.")
- (license license:zlib))))
-
-(define-public ecl-chirp
- (sbcl-package->ecl-package sbcl-chirp))
-
-(define-public cl-chirp
- (sbcl-package->cl-source-package sbcl-chirp))
-
-(define-public sbcl-cepl
- (let ((commit "d1a10b6c8f4cedc07493bf06aef3a56c7b6f8d5b")
- (revision "1"))
- (package
- (name "sbcl-cepl")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cbaggers/cepl";)
- (commit commit)))
- (file-name (git-file-name "cepl" version))
- (sha256
- (base32 "0izbw2advqm3wailj3dpq6zqfrfirwn14pw5qmqh8i71r51xwmm2"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("cl-opengl" ,sbcl-cl-opengl)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("documentation-utils" ,sbcl-documentation-utils)
- ("float-features" ,sbcl-float-features)
- ("ieee-floats" ,sbcl-ieee-floats)
- ("split-sequence" ,sbcl-split-sequence)
- ("varjo" ,sbcl-varjo)))
- (propagated-inputs
- (list sbcl-quickproject))
- (home-page "https://github.com/cbaggers/cepl";)
- (synopsis "Development playground to work with OpenGL")
- (description
- "CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp
-library for working with OpenGL.
-
-Its definition of success is making the user feel that GPU programming has
-always been part of the languages standard.
-
-The usual approach to using CEPL is to start it at the beginning of your Lisp
-session and leave it open for the duration of your work. You can then treat
the
-window it creates as just another output for your graphics, analogous to how
-@code{*standard-output*} is treated for text.")
- (license license:bsd-2))))
+ "@code{cl-numerical-utilities} is a collection of packages useful in
+numerical applications, each big enough to be its own package, but too small
+to split out into a separate ASDF system.")
+ (license license:ms-pl))))
-(define-public ecl-cepl
- (sbcl-package->ecl-package sbcl-cepl))
+(define-public cl-numerical-utilities
+ (sbcl-package->cl-source-package sbcl-numerical-utilities))
-(define-public cl-cepl
- (sbcl-package->cl-source-package sbcl-cepl))
+(define-public ecl-numerical-utilities
+ (sbcl-package->ecl-package sbcl-numerical-utilities))
-(define-public sbcl-stmx
- ;; No release for years and recent commits contain fixes for recent SBCL
- ;; versions.
- (let ((commit "95f7dea8e1e58dee59e14a1deb148908d920839f")
- (revision "3"))
+(define-public sbcl-numpy-file-format
+ (let ((commit "e440c7bbc0d86b9abf73acb0fa665b77b82a6c98")
+ (revision "2"))
(package
- (name "sbcl-stmx")
- (version (git-version "2.0.5" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/cosmos72/stmx/";)
- (commit commit)))
- (file-name (git-file-name "cl-stmx" version))
- (sha256
- (base32 "1qq25y79casaa56a76gj9hk2f3hjcc5z3f4na4vy3sw99km54hn9"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-bordeaux-threads sbcl-log4cl
- sbcl-closer-mop sbcl-trivial-garbage))
- (home-page "https://stmx.org/";)
- (synopsis "High performance Transactional Memory for Common Lisp")
- (description
- "STMX is a high-performance implementation of composable Transactional
-Memory, which is a concurrency control mechanism aimed at making concurrent
-programming easier to write and understand. Instead of traditional lock-based
-programming, one programs with atomic memory transactions, which can be
-composed together to make larger atomic memory transactions.
-
-A memory transaction gets committed if it returns normally, while it gets
-rolled back if it signals an error (and the error is propagated to the
-caller).
-
-Finally, memory transactions can safely run in parallel in different threads,
-are re-executed from the beginning in case of conflicts or if consistent reads
-cannot be guaranteed, and their effects are not visible from other threads
-until they commit.
-
-Memory transactions give freedom from deadlocks, are immune to thread-safety
-bugs and race conditions, provide automatic roll-back on failure, and aim at
-resolving the tension between granularity and concurrency.")
- (license license:llgpl))))
+ (name "sbcl-numpy-file-format")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/marcoheisig/numpy-file-format";)
+ (commit commit)))
+ (file-name (git-file-name "cl-numpy-file-format" version))
+ (sha256
+ (base32 "1n0nixc44z1cymm20wif0l2100ydv0h69l6i6xz5bmwcb2zc4gqr"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-ieee-floats sbcl-trivial-features))
+ (home-page "https://github.com/marcoheisig/numpy-file-format";)
+ (synopsis "Read and write NumPy .npy and .npz files")
+ (description
+ "The NUMPY-FILE-FORMAT library is a Common Lisp library for reading and
+writing NumPy @file{.npy} and @file{.npz} files.")
+ (license license:expat))))
-(define-public ecl-stmx
- (sbcl-package->ecl-package sbcl-stmx))
+(define-public cl-numpy-file-format
+ (sbcl-package->cl-source-package sbcl-numpy-file-format))
-(define-public cl-stmx
- (sbcl-package->cl-source-package sbcl-stmx))
+(define-public ecl-numpy-file-format
+ (sbcl-package->ecl-package sbcl-numpy-file-format))
-(define-public sbcl-binding-arrows
- ;; Fork of sbcl-arrows that does not have a new tag.
- (let ((commit "46bcba8bb1ff27cd5caab3bda36f000d0489a4f2")
- (revision "2"))
- (package
- (name "sbcl-binding-arrows")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
+(define-public sbcl-object-class
+ (package
+ (name "sbcl-object-class")
+ (version "1.0")
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/binding-arrows";)
- (commit commit)))
- (file-name (git-file-name "cl-binding-arrows" version))
+ (url "https://github.com/Hexstream/object-class";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-object-class" version))
(sha256
- (base32 "0kzybw5qlb49czh9v2lnxniz9jzqx306a6lnarfv59x48a7cch22"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.stefil))
- (home-page "https://github.com/phoe/binding-arrows";)
- (synopsis "Threading macros based on binding anonymous variables")
- (description
- "This system implements binding threading macros -- a kind of threading
-macros with different semantics than classical, Clojure core threading macros
-or their extension, swiss-arrows. Two Common Lisp implementations of those are
-@code{arrows} and @code{arrow-macros}.
-
-This system is a fork of @code{arrows} with changes in semantics that make it
-impossible to merge back upstream.")
- (license license:expat))))
+ (base32 "0qagmd2mxbr8b60l0y3jccj0maxjchds96p935pd3q805ry50683"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-closer-mop
+ sbcl-compatible-metaclasses
+ sbcl-enhanced-find-class))
+ (home-page "https://www.hexstreamsoft.com/libraries/object-class/";)
+ (synopsis "Cluster special subclasses of the standard-object")
+ (description
+ "This package ensures that special subclasses of standard-object cluster
+right in front of standard-object in the class precedence list.")
+ (license license:unlicense)))
-(define-public ecl-binding-arrows
- (sbcl-package->ecl-package sbcl-binding-arrows))
+(define-public cl-object-class
+ (sbcl-package->cl-source-package sbcl-object-class))
-(define-public cl-binding-arrows
- (sbcl-package->cl-source-package sbcl-binding-arrows))
+(define-public ecl-object-class
+ (sbcl-package->ecl-package sbcl-object-class))
-(define-public sbcl-atomics
- ;; No release in years.
- (let ((commit "b7477024894e322bff9c85e6d81e5e8d1d4eae59")
- (revision "2"))
+(define-public sbcl-olc
+ (let ((commit "0269ed747477d967f7d9331964906b6a0f18a9c4")
+ (revision "1"))
(package
- (name "sbcl-atomics")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-olc")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/atomics";)
+ (url "https://codeberg.org/glv/olc";)
(commit commit)))
- (file-name (git-file-name "cl-atomics" version))
+ (file-name (git-file-name "cl-olc" version))
(sha256
- (base32 "1ah6fgvfva0axnhj4sp1qy6gjyw41fkhpnv998di0wbp6hls8j39"))))
+ (base32 "02r6w9kfa6v4a12y2azmyjkxbn54r1y18c6a024vq4y6zp20fqnz"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-documentation-utils))
(native-inputs
- (list sbcl-parachute))
- (home-page "https://shinmera.github.io/atomics/";)
- (synopsis "Common Lisp portability layer for atomic operations")
+ (list sbcl-fiveam))
+ (synopsis
+ "Convert coordinates between latitude/longitude and Open Location Code")
(description
- "This is a library for access to atomic operation primitives such as
-compare-and-swap. It aims to be a rather thin layer over what the
-implementations offer.")
- (license license:zlib))))
+ "This a Common Lisp library to convert geographic coordinates between
+latitude/longitude and Open Location Code.")
+ (home-page "https://codeberg.org/glv/olc";)
+ (license license:gpl3+))))
-(define-public ecl-atomics
- (sbcl-package->ecl-package sbcl-atomics))
+(define-public cl-olc
+ (sbcl-package->cl-source-package sbcl-olc))
-(define-public cl-atomics
- (sbcl-package->cl-source-package sbcl-atomics))
+(define-public ecl-olc
+ (sbcl-package->ecl-package sbcl-olc))
-(define-public sbcl-cl-murmurhash
- ;; No release.
- (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364")
+(define-public sbcl-one-more-re-nightmare
+ (let ((commit "5b0b02e59f90964baf5737abd13300fa82f27667")
(revision "1"))
(package
- (name "sbcl-cl-murmurhash")
+ (name "sbcl-one-more-re-nightmare")
(version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/cl-murmurhash/";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/telekons/one-more-re-nightmare";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-one-more-re-nightmare" version))
(sha256
- (base32
- "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws"))))
+ (base32 "0mwgjgnp8dsf2zn0290px5q89z93zs0v4dhvs3rcir4mpiw8rbsn"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-test-systems '("one-more-re-nightmare-tests")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "Tests/one-more-re-nightmare-tests.asd"
+ ((":depends-on")
+ (string-append
+ ":perform (test-op (o c) (symbol-call
:one-more-re-nightmare-tests '#:run-tests))"
+ "\n :depends-on"))))))))
+ (native-inputs
+ (list sbcl-lparallel sbcl-parachute))
(inputs
- (list sbcl-babel))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-dynamic-mixins
+ sbcl-esrap
+ sbcl-stealth-mixin
+ sbcl-trivia
+ sbcl-trivial-indent))
+ (home-page "https://github.com/telekons/one-more-re-nightmare";)
+ (synopsis "Regular expression compiler in Common Lisp")
+ (description "@code{one-more-re-nightmare} is a regular expression engine
+that uses the technique presented in Regular-expression derivatives
+re-examined (Owens, Reppy and Turon, 2009;
+@url{doi:10.1017/S0956796808007090}) to interpret and compile regular
+expressions.")
+ (license license:bsd-2))))
+
+(define-public cl-one-more-re-nightmare
+ (sbcl-package->cl-source-package sbcl-one-more-re-nightmare))
+
+(define-public ecl-one-more-re-nightmare
+ (sbcl-package->ecl-package sbcl-one-more-re-nightmare))
+
+(define-public sbcl-opticl
+ (let ((commit "f6fc4dc5fa61ae3f2527b77e4bda99001ba37dcb")
+ (revision "1"))
+ (package
+ (name "sbcl-opticl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slyrus/opticl";)
+ (commit commit)))
+ (file-name (git-file-name "cl-opticl" version))
+ (sha256
+ (base32 "1jx9n78d4lf53iz24yid34l92zrpqxfihv6049ixcy0xigf7j4ac"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
- (synopsis "32-bit version of Murmurhash3 for Common Lisp")
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cl-jpeg
+ sbcl-cl-tga
+ sbcl-opticl-core
+ sbcl-png-read
+ sbcl-pngload
+ sbcl-retrospectiff
+ sbcl-skippy
+ sbcl-zpng))
+ (home-page "https://github.com/slyrus/opticl";)
+ (synopsis "Image processing library for Common Lisp")
(description
- "This Common Lisp package offers an implementation of the 32-bit
-variant of MurmurHash3 (@url{https://github.com/aappleby/smhasher}), a fast
-non-crytographic hashing algorithm.")
- (license license:expat))))
+ "Opticl is a Common Lisp library for representing, processing, loading,
+and saving 2-dimensional pixel-based images.")
+ (license license:bsd-2))))
-(define-public ecl-cl-murmurhash
- (sbcl-package->ecl-package sbcl-cl-murmurhash))
+(define-public cl-opticl
+ (sbcl-package->cl-source-package sbcl-opticl))
-(define-public cl-murmurhash
- (sbcl-package->cl-source-package sbcl-cl-murmurhash))
+(define-public ecl-opticl
+ (sbcl-package->ecl-package sbcl-opticl))
-(define-public sbcl-cl-hamt
- ;; No release
- (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208"))
+(define-public sbcl-opticl-core
+ (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
+ (revision "0"))
(package
- (name "sbcl-cl-hamt")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-opticl-core")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/danshapero/cl-hamt/";)
+ (url "https://github.com/slyrus/opticl-core";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5"))))
+ (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-murmurhash))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/danshapero/cl-hamt";)
- (synopsis "Dictionary & set data structure using hash array-mapped
tries")
+ (list sbcl-alexandria))
+ (home-page "https://github.com/slyrus/opticl-core";)
+ (synopsis "Core classes and pixel access macros for Opticl")
(description
- "This library provides purely functional dictionaries and sets in
-Common Lisp based on the hash array-mapped trie data structure.")
- (license license:bsd-3))))
+ "This Common Lisp library contains the core classes and pixel access
+macros for the Opticl image processing library.")
+ (license license:bsd-2))))
-(define-public ecl-cl-hamt
- (sbcl-package->ecl-package sbcl-cl-hamt))
+(define-public cl-opticl-core
+ (sbcl-package->cl-source-package sbcl-opticl-core))
-(define-public cl-hamt
- (sbcl-package->cl-source-package sbcl-cl-hamt))
+(define-public ecl-opticl-core
+ (sbcl-package->ecl-package sbcl-opticl-core))
-(define-public sbcl-cl-gserver
- (package
- (name "sbcl-cl-gserver")
- (version "1.8.0")
- (source
- (origin
+(define-public sbcl-optima
+ (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
+ (revision "1"))
+ (package
+ (name "sbcl-optima")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1.0" 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
+ (list sbcl-eos))
+ (arguments
+ ;; XXX: Circular dependencies: tests depend on optima.ppcre which
depends on optima.
+ `(#:tests? #f))
+ (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 cl-optima
+ (sbcl-package->cl-source-package sbcl-optima))
+
+(define-public ecl-optima
+ (sbcl-package->ecl-package sbcl-optima))
+
+(define-public sbcl-org-sampler
+ (let ((commit "ee135a417750e5b1d810bb9574eb85223cb3038a")
+ (revision "1"))
+ (package
+ (name "sbcl-org-sampler")
+ (version (git-version "0.2.1" revision commit))
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mdbergmann/cl-gserver";)
-
- ;; The "1.8.0" tag must have been moved from
- ;; c83d92a66102faa514b546029a9bd2078b95dc0f to
- ;; 90832f02f0556463e332cd055c3c1be58f323aea, 22 commits later!
- (commit "c83d92a66102faa514b546029a9bd2078b95dc0f")))
- (file-name (git-file-name "cl-gserver" version))
+ (url "https://github.com/jphmrst/cl-org-sampler";)
+ (commit commit)))
+ (file-name (git-file-name "cl-org-sampler" version))
(sha256
- (base32 "1bfz7z8v417dvsp1jz76ir3ihcs8g7zis2d56xx1dpzqzjd95g7z"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-lparallel
- sbcl-cl-speedy-queue
- sbcl-log4cl
- sbcl-cl-str
- sbcl-blackbird
- sbcl-cl-hamt
- sbcl-binding-arrows
- sbcl-atomics))
- (native-inputs
- (list sbcl-fiveam sbcl-cl-mock))
- (home-page "https://mdbergmann.github.io/cl-gserver/index.html";)
- (synopsis "Actor framework for easy access to state and async operations")
- (description
- "@code{cl-gserver} is a 'message passing' library / framework with actors
-similar to Erlang or Akka. It supports creating reactive systems for parallel
-computing and event based message handling.")
- (license license:agpl3)))
+ (base32 "1dg029in14928qfxvfshyxmdwhzskzhxx3na0zy98ybx69b21qla"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-iterate))
+ (home-page "https://github.com/jphmrst/cl-org-sampler";)
+ (synopsis "Extracting Common Lisp docstrings as Emacs Org-mode documents")
+ (description
+ "ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode
+text for inclusion into a larger document.")
+ (license license:llgpl))))
-(define-public ecl-cl-gserver
- (sbcl-package->ecl-package sbcl-cl-gserver))
+(define-public cl-org-sampler
+ (sbcl-package->cl-source-package sbcl-org-sampler))
-(define-public cl-gserver
- (sbcl-package->cl-source-package sbcl-cl-gserver))
+(define-public ecl-org-sampler
+ (sbcl-package->ecl-package sbcl-org-sampler))
-(define-public sbcl-assoc-utils
- (let ((commit "74af16a3c0f10ad35e406167de02984744fc7854")
+(define-public sbcl-origin
+ (let ((commit "d646134302456408d6d43580bb05299f1695ab8e")
(revision "1"))
(package
- (name "sbcl-assoc-utils")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-origin")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/assoc-utils";)
+ (url "https://git.mfiano.net/mfiano/origin";)
(commit commit)))
- (file-name (git-file-name "cl-assoc-utils" version))
+ (file-name (git-file-name "origin" version))
(sha256
- (base32 "1yac1v7zmdxj0p6rvwrrhyqvy7yjfhmqbchkwqhhr89gpjvvaick"))))
+ (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("assoc-utils-test" "assoc-utils")))
(native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/fukamachi/assoc-utils";)
- (synopsis "Utilities for manipulating association lists in Common Lisp")
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-golden-utils sbcl-specialization-store))
+ (home-page "https://git.mfiano.net/mfiano/origin";)
+ (synopsis "Common Lisp graphics math library")
(description
- "@code{assoc-utils} provides utilities for manipulating association
-lists in Common Lisp.")
- (license license:public-domain))))
+ "This is a native Common Lisp graphics math library with an emphasis on
+performance and correctness.")
+ (license license:expat))))
-(define-public cl-assoc-utils
- (sbcl-package->cl-source-package sbcl-assoc-utils))
+(define-public ecl-origin
+ (sbcl-package->ecl-package sbcl-origin))
-(define-public ecl-assoc-utils
- (sbcl-package->ecl-package sbcl-assoc-utils))
+(define-public cl-origin
+ (sbcl-package->cl-source-package sbcl-origin))
-(define-public sbcl-let-over-lambda
- (let ((commit "481b2e3ab4646186451dfdd2062113203287d520")
- (revision "1"))
+(define-public sbcl-osc
+ (let ((commit "f647738ccc22925ed740a8ca9132fda76a05baeb")
+ (revision "0"))
(package
- (name "sbcl-let-over-lambda")
- (version (git-version "1.0.1" revision commit))
- (source
+ (name "sbcl-osc")
+ (version (git-version "0.9" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/thephoeron/let-over-lambda";)
+ (url "https://github.com/zzkt/osc";)
(commit commit)))
- (file-name (git-file-name "cl-let-over-lambda" version))
+ (file-name (git-file-name "cl-osc" version))
(sha256
- (base32 "114p781lwi9lrbzg27dnkymz9m4cvm1k430j7qsykwd0b58d8qbk"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; All test cases pass, but tests successfully fail at the end:
- ;;
- ;; Summary:
- ;; All 1 file passed.
- ;; Unhandled ASDF/FIND-COMPONENT:MISSING-DEPENDENCY in thread
- ;; #<SB-THREAD:THREAD "main thread" RUNNING {1001860103}>:
- ;; Component LET-OVER-LAMBDA-ASD::LET-OVER-LAMBDA-TEST not found,
- ;; required by #<SYSTEM "let-over-lambda">
- `(#:tests? #f))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("named-readtables" ,sbcl-named-readtables)))
- (native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/thephoeron/let-over-lambda";)
- (synopsis "Macros from Let Over Lambda")
- (description
- "This package provides Doug Hoyte's \"Production\" version of macros
-from the Let Over Lambda book, including community updates.")
- (license license:bsd-3))))
+ (base32 "1x4cavspaxcr604g0hwak1ncy4m9cqq03ji4v56g2h1443n7h48a"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiveam))
+ (inputs (list sbcl-ieee-floats))
+ (synopsis "Implementation of the Open Sound Control protocol")
+ (description "This is a lisp implementation of the Open Sound Control
+protocol (or more accurately “data transport specification” or
+“encoding”). The code should be close to ANSI standard common lisp and
+provides self contained code for encoding and decoding of OSC data, messages,
+and bundles.")
+ (home-page "https://github.com/zzkt/osc/";)
+ (license license:gpl3+))))
-(define-public cl-let-over-lambda
- (sbcl-package->cl-source-package sbcl-let-over-lambda))
+(define-public cl-osc
+ (sbcl-package->cl-source-package sbcl-osc))
-(define-public ecl-let-over-lambda
- (sbcl-package->ecl-package sbcl-let-over-lambda))
+(define-public ecl-osc
+ (sbcl-package->ecl-package sbcl-osc))
-(define-public sbcl-flute
- (let ((commit "90ebcd6e82f637f49b6de7d625ccc51ec4c92900")
- (revision "1"))
+(define-public sbcl-osicat
+ (let ((commit "982327905b8980ff3173344ca87282e046565732")
+ (revision "4"))
(package
- (name "sbcl-flute")
- (version (git-version "0.2-dev" revision commit))
+ (name "sbcl-osicat")
+ (version (git-version "0.7.0" revision commit))
+ (home-page "https://www.common-lisp.net/project/osicat/";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ailisp/flute";)
+ (url "https://github.com/osicat/osicat";)
(commit commit)))
- (file-name (git-file-name "cl-flute" version))
+ (file-name (git-file-name "cl-osicat" version))
(sha256
- (base32 "0q8jhp040cvpppyn820mm6a550yfxyr1lar298x13c42mm807f4f"))))
+ (base32 "10q1dfkhrvp5ia860q10y4wdm11fmxf7xv8zl4viz2np9xzf5v22"))
+ (snippet
+ '(begin
+ ;; The useless release.sh drags `bash' into the closure.
+ (delete-file "scripts/release.sh")
+ #t))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-assoc-utils sbcl-let-over-lambda))
+ (list sbcl-alexandria sbcl-cffi sbcl-trivial-features))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/ailisp/flute";)
- (synopsis "HTML5 generation library in Common Lisp")
+ (list sbcl-rt))
+ (synopsis "Operating system interface for Common Lisp")
(description
- "Flute is an easily composable HTML5 generation library in Common
-Lisp.")
+ "Osicat is a lightweight operating system interface for Common Lisp on
+Unix-platforms. It is not a POSIX-style API, but rather a simple lispy
+accompaniment to the standard ANSI facilities.")
(license license:expat))))
-(define-public cl-flute
- (sbcl-package->cl-source-package sbcl-flute))
+(define-public cl-osicat
+ (sbcl-package->cl-source-package sbcl-osicat))
-(define-public ecl-flute
- (sbcl-package->ecl-package sbcl-flute))
+(define-public ecl-osicat
+ (sbcl-package->ecl-package sbcl-osicat))
-(define-public sbcl-cl-posix-mqueue
- (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f")
- (revision "1"))
+(define-public sbcl-ospm
+ (package
+ (name "sbcl-ospm")
+ (version "0.0.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/ospm";)
+ (commit version)))
+ (file-name (git-file-name "cl-ospm" version))
+ (sha256
+ (base32 "1z2wz2xg7rn7p1lladdhj789iz2f3wfjgpi2hjr08vkf1pkp15xf"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-calispel
+ sbcl-hu.dwim.defclass-star
+ sbcl-local-time
+ sbcl-moptilities
+ sbcl-named-readtables
+ sbcl-serapeum
+ sbcl-trivia))
+ (native-inputs
+ ;; FIXME: Tests have execution errors because of Guix being run in a
container.
+ (list sbcl-lisp-unit2 guix))
+ (home-page "https://github.com/atlas-engineer/ospm";)
+ (synopsis "System package manager in Common Lisp")
+ (description
+ "This library is a universal interface to the operating system package
manager.
+It has extensive support for Guix, among others:
+
+@itemize
+@item package listing and searching;
+@item package installation and uninstallation;
+@item package file listing;
+@item profile listing;
+@item manifest listing and installation;
+@item generation listing, switching and deletion.
+@end itemize\n")
+ (license license:bsd-3)))
+
+(define-public cl-ospm
+ (let ((pkg (sbcl-package->cl-source-package sbcl-ospm)))
+ (package
+ (inherit pkg)
+ (inputs
+ (cons (list "osicat" cl-osicat)
+ (package-inputs pkg))))))
+
+(define-public sbcl-overlord
+ ;; No release.
+ (let ((commit "a8f37b321a8aae1652fc50b78e74e57c771cc763"))
(package
- (name "sbcl-cl-posix-mqueue")
- (version (git-version "0.1.2" revision commit))
+ (name "sbcl-overlord")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/xFA25E/cl-posix-mqueue";)
+ (url "https://github.com/ruricolist/overlord/";)
(commit commit)))
- (file-name (git-file-name "cl-posix-mqueue" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "04519rg8vc782z097dzlb8nx0skab2fy2zd0m60r6mz2nw8xdvh6"))))
+ (base32 "1maqm53yhlhaa3cka8xcc4sq24ifrr4y3y0s5dyyn682xsh14hb4"))))
(build-system asdf-build-system/sbcl)
+ (inputs
+ `(("babel" ,sbcl-babel)
+ ("bit-smasher" ,sbcl-bit-smasher)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-strftime" ,sbcl-cl-strftime)
+ ("cmd" ,sbcl-cmd)
+ ("drakma" ,sbcl-drakma)
+ ("exit-hooks" ,sbcl-exit-hooks)
+ ("fset" ,sbcl-fset)
+ ("local-time" ,sbcl-local-time)
+ ("lparallel" ,sbcl-lparallel)
+ ("md5" ,sbcl-md5)
+ ("murmurhash" ,sbcl-cl-murmurhash)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("ppcre" ,sbcl-cl-ppcre)
+ ("serapeum" ,sbcl-serapeum)
+ ("trivia" ,sbcl-trivia)
+ ("trivial-file-size" ,sbcl-trivial-file-size)))
+ (propagated-inputs
+ `(("quickproject" ,sbcl-quickproject)))
+ (native-inputs
+ (list sbcl-fiveam))
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'patch-librt-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/spec.lisp"
- (("librt.so" all)
- (string-append (assoc-ref inputs "glibc") "/lib/" all))))))))
- (native-inputs
- `(("cl-ppcre" ,sbcl-cl-ppcre)
- ("rove" ,sbcl-rove)))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("babel" ,sbcl-babel)
- ("cffi" ,sbcl-cffi)
- ("glibc" ,glibc)
- ("local-time" ,sbcl-local-time)))
- (home-page "https://github.com/xFA25E/cl-posix-mqueue";)
- (synopsis "Common Lisp binding to POSIX mqueue")
+ (add-after 'unpack 'include-overlord/net
+ (lambda _
+ (substitute* "all.lisp"
+ (("\\(:import-from :overlord/kernel :nproc\\)")
+ (string-append
+ "(:import-from :overlord/kernel :nproc)"
+ "\n"
+ "(:import-from :overlord/net)")))
+ #t)))))
+ (home-page "https://github.com/ruricolist/overlord";)
+ (synopsis "Build system in Common Lisp")
(description
- "This package provides Common Lisp bindings to POSIX message queue, an
-@acronym{IPC, Inter-Process Communication} method that is easy to use and quick
-to setup.")
- (license license:gpl3))))
+ "Overlord is a build system in Common Lisp. It is a real build system,
+with all the modern features: rules with multiple outputs, parallel builds,
+immunity to clock issues, and dynamic dependencies.
-(define-public ecl-cl-posix-mqueue
- (sbcl-package->ecl-package sbcl-cl-posix-mqueue))
+But Overlord is more than another build system. Overlord is a uniform
+approach to dependencies inside or outside of a Lisp image. Overlord is to
+Make what Lisp macros are to C macros.
-(define-public cl-posix-mqueue
- (sbcl-package->cl-source-package sbcl-cl-posix-mqueue))
+Overlord is designed to be used from the Lisp REPL. A command line interface
+is available in a separate repository. See
+@url{https://github.com/ruricolist/overlord-cli}.";)
+ (license license:expat))))
-(define-public sbcl-glop
- (let ((commit "45e722ab4a0cd2944d550bf790206b3326041e38")
- (revision "1"))
+(define-public cl-overlord
+ (sbcl-package->cl-source-package sbcl-overlord))
+
+;; FIXME: Broken on ECL? https://github.com/ruricolist/overlord/issues/25
+;; (define-public ecl-overlord
+;; (sbcl-package->ecl-package sbcl-overlord))
+
+(define-public sbcl-parenscript
+ ;; Source archives are overwritten on every release, we use the Git repo
instead.
+ (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
(package
- (name "sbcl-glop")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-parenscript")
+ (version (git-version "2.7.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispgames/glop";)
+ (url "https://gitlab.common-lisp.net/parenscript/parenscript";)
(commit commit)))
- (file-name (git-file-name "glop" version))
+ (file-name (git-file-name "parenscript" version))
(sha256
- (base32 "1nm35kvigflfjlmsa8zwdajc61f02fh4sq08jv0wnqylhx8yg2bv"))))
+ (base32
+ "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'patch-lib-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/x11/xcomposite.lisp"
- (("libXcomposite.so")
- (search-input-file inputs "/lib/libXcomposite.so")))
- (substitute* "src/x11/xlib.lisp"
- (("libX11")
- (string-drop-right
- (search-input-file inputs "/lib/libX11.so") 3)))
- (substitute* "src/utils.lisp"
- (("libX11")
- (string-drop-right
- (search-input-file inputs "/lib/libX11.so") 3)))
- (substitute* "src/utils.lisp"
- (("libGL.so")
- (search-input-file inputs "/lib/libGL.so.1")))
- (substitute* "src/x11/glx.lisp"
- (("libGL.so")
- (search-input-file inputs "/lib/libGL.so")))
- (substitute* "src/x11/display-ctrl.lisp"
- (("libXrandr")
- (string-drop-right
- (search-input-file inputs "/lib/libXrandr.so")
3))))))))
- (native-inputs
- (list sbcl-cl-opengl))
(inputs
- (list libx11
- libxcomposite
- libxrandr
- mesa
- sbcl-cffi
- sbcl-split-sequence
- sbcl-trivial-garbage))
- (home-page "https://github.com/lispgames/glop";)
- (synopsis "Direct FFI bindings for OpenGL window and context management")
+ (list sbcl-cl-ppcre sbcl-anaphora sbcl-named-readtables))
+ (home-page "https://common-lisp.net/project/parenscript/";)
+ (synopsis "Translator from a subset of Common Lisp to JavaScript")
(description
- "This package provides Common Lisp bindings to create OpenGL window and
-context manipulation code as well as system input handling. Direct FFI
-bindings to system functions are used so no third party C lib is required
-except system libraries.")
- (license license:expat))))
+ "Parenscript is a translator from an extended subset of Common Lisp to
+JavaScript. Parenscript code can run almost identically on both the
+browser (as JavaScript) and server (as Common Lisp).
-(define-public ecl-glop
- (sbcl-package->ecl-package sbcl-glop))
+Parenscript code is treated the same way as Common Lisp code, making the full
+power of Lisp macros available for JavaScript. This provides a web
+development environment that is unmatched in its ability to reduce code
+duplication and provide advanced meta-programming facilities to web
+developers.
-(define-public cl-glop
- (sbcl-package->cl-source-package sbcl-glop))
+At the same time, Parenscript is different from almost all other \"language
+X\" to JavaScript translators in that it imposes almost no overhead:
-(define-public sbcl-sdl2
- (let ((commit "80410b514570ca06894675d4a2a5fc93287ea7b6")
- (revision "2"))
+@itemize
+@item No run-time dependencies: Any piece of Parenscript code is runnable
+as-is. There are no JavaScript files to include.
+@item Native types: Parenscript works entirely with native JavaScript data
+types. There are no new types introduced, and object prototypes are not
+touched.
+@item Native calling convention: Any JavaScript code can be called without the
+need for bindings. Likewise, Parenscript can be used to make efficient,
+self-contained JavaScript libraries.
+@item Readable code: Parenscript generates concise, formatted, idiomatic
+JavaScript code. Identifier names are preserved. This enables seamless
+debugging in tools like Firebug.
+@item Efficiency: Parenscript introduces minimal overhead for advanced Common
+Lisp features. The generated code is almost as fast as hand-written
+JavaScript.
+@end itemize\n")
+ (license license:bsd-3))))
+
+(define-public cl-parenscript
+ (sbcl-package->cl-source-package sbcl-parenscript))
+
+(define-public ecl-parenscript
+ (sbcl-package->ecl-package sbcl-parenscript))
+
+(define-public sbcl-parse
+ (let ((commit "2351ee78acac065fcf10b8713d3f404e2e910786")
+ (revision "1"))
(package
- (name "sbcl-sdl2")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-parse")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/massung/parse";)
+ (commit commit)))
+ (file-name (git-file-name "parse" version))
+ (sha256
+ (base32 "0l18yabyh7jizm5lgvra0jxi8s1cfwghidi6ix1pyixjkdbjlmvy"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/massung/parse";)
+ (synopsis "Monadic parsing for Common Lisp")
+ (description
+ "PARSE is a simple token parsing library for Common Lisp.")
+ (license license:asl2.0))))
+
+(define-public cl-parse
+ (sbcl-package->cl-source-package sbcl-parse))
+
+(define-public ecl-parse
+ (sbcl-package->ecl-package sbcl-parse))
+
+(define-public sbcl-parse-declarations
+ (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 "https://github.com/lispgames/cl-sdl2";)
+ (url (string-append
+ "https://gitlab.common-lisp.net/parse-declarations/";
+ "parse-declarations.git"))
(commit commit)))
- (file-name (git-file-name "cl-sdl2" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0sjy4k04k0hdhwpr57ns16ag3za0kz4laclbk17i91ql7qdjw9z2"))))
+ (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("sdl2" "sdl2/examples")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libSDL2-2.0.so.0")
- (search-input-file inputs "/lib/libSDL2-2.0.so.0"))))))))
- (inputs
- (list sbcl-alexandria
- sbcl-cl-autowrap
- sbcl-cl-opengl
- sbcl-cl-ppcre
- sbcl-trivial-channels
- sbcl-trivial-features
- sdl2))
- (home-page "https://github.com/lispgames/cl-sdl2";)
- (synopsis "Common Lisp bindings for SDL2 using C2FFI")
+ `(#:asd-systems '("parse-declarations-1.0")))
+ (home-page "https://common-lisp.net/project/parse-declarations/";)
+ (synopsis "Parse, filter, and build declarations")
(description
- "This package provides a Common Lisp wrapper system for the SDL 2.0
-C Library.")
+ "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 ecl-sdl2
- (sbcl-package->ecl-package sbcl-sdl2))
+(define-public cl-parse-declarations
+ (sbcl-package->cl-source-package sbcl-parse-declarations))
-(define-public cl-sdl2
- (sbcl-package->cl-source-package sbcl-sdl2))
+(define-public ecl-parse-declarations
+ (sbcl-package->ecl-package sbcl-parse-declarations))
-(define-public sbcl-sdl2-image
- (let ((commit "9c05c806286b66a5d9861ef829cfe68c4f3da077")
- (revision "1"))
+(define-public sbcl-parse-float
+ (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c")
+ (revision "2"))
(package
- (name "sbcl-sdl2-image")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-parse-float")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispgames/cl-sdl2-image";)
+ (url "https://github.com/soemraws/parse-float";)
(commit commit)))
- (file-name (git-file-name "cl-sdl2-image" version))
(sha256
- (base32 "1nr7mdl125q32m15m8rdlza5kwi7m0birh1cq846pyy6zl1sjms7"))))
+ (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr"))
+ (file-name (git-file-name "proc-parse" version))))
(build-system asdf-build-system/sbcl)
(arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libSDL2_image-2.0.so.0")
- (search-input-file inputs
"/lib/libSDL2_image-2.0.so.0"))))))))
+ ;; FIXME: https://github.com/soemraws/parse-float/issues/12
+ `(#:asd-systems '("parse-float" "parse-float-tests")))
+ (native-inputs
+ (list sbcl-lisp-unit))
(inputs
- (list sdl2-image
- sbcl-alexandria
- sbcl-cl-autowrap
- sbcl-defpackage-plus
- sbcl-sdl2))
- (home-page "https://github.com/lispgames/cl-sdl2-image";)
- (synopsis "SDL2_image wrapper for Common Lisp")
+ `(("alexandria" ,sbcl-alexandria)))
+ (home-page "https://github.com/soemraws/parse-float";)
+ (synopsis "Parse a floating point value from a string in Common Lisp")
(description
- "This is a (currently) brief but usable wrap for SDL2_image.")
- (license license:expat))))
+ "This package exports the following function to parse floating-point
+values from a string in Common Lisp.")
+ (license license:public-domain))))
-(define-public ecl-sdl2-image
- (sbcl-package->ecl-package sbcl-sdl2-image))
+(define-public cl-parse-float
+ (sbcl-package->cl-source-package sbcl-parse-float))
-(define-public cl-sdl2-image
- (sbcl-package->cl-source-package sbcl-sdl2-image))
+(define-public ecl-parse-float
+ (sbcl-package->ecl-package sbcl-parse-float))
-(define-public sbcl-sdl2-mixer
- (let ((commit "fdcc7ee7935dd01fd338e22690451db2cf126156")
+(define-public sbcl-parse-js
+ (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
(revision "1"))
(package
- (name "sbcl-sdl2-mixer")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-parse-js")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispgames/cl-sdl2-mixer";)
+ (url "http://marijn.haverbeke.nl/git/parse-js";)
(commit commit)))
- (file-name (git-file-name "cl-sdl2-mixer" version))
+ (file-name (git-file-name "cl-parse-js" version))
(sha256
- (base32 "0g6ywb3gqr0rif4z6kkz6m8vyv8nrr5wr1w9sc6d3zypbbnqgbp6"))))
+ (base32
+ "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libSDL2_mixer-2.0.so.0")
- (search-input-file inputs
"/lib/libSDL2_mixer-2.0.so.0"))))))))
- (inputs
- (list sbcl-alexandria
- sbcl-cl-autowrap
- sbcl-sdl2
- sbcl-trivial-garbage
- sdl2-mixer))
- (home-page "https://github.com/lispgames/cl-sdl2-mixer";)
- (synopsis "Bindings for sdl2_mixer using autowrap for Common Lisp")
- (description
- "This package provides a Common Lisp wrapper system for the SDL 2.0
Mixer C
-Library.")
- (license license:expat))))
+ (home-page "https://marijnhaverbeke.nl/parse-js/";)
+ (synopsis "Parse JavaScript")
+ (description "Parse-js is a Common Lisp package for parsing
+JavaScript (ECMAScript 3). It has basic support for ECMAScript 5.")
+ (license license:zlib))))
-(define-public ecl-sdl2-mixer
- (sbcl-package->ecl-package sbcl-sdl2-mixer))
+(define-public cl-parse-js
+ (sbcl-package->cl-source-package sbcl-parse-js))
-(define-public cl-sdl2-mixer
- (sbcl-package->cl-source-package sbcl-sdl2-mixer))
+(define-public ecl-parse-js
+ (sbcl-package->ecl-package sbcl-parse-js))
-(define-public sbcl-sdl2-ttf
- (let ((commit "6dd2df2fb3a79ec4f835e3bc882e60e8da039878")
+(define-public sbcl-parse-number
+ (package
+ (name "sbcl-parse-number")
+ (version "1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/sharplispers/parse-number/";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://www.cliki.net/PARSE-NUMBER";)
+ (synopsis "Parse numbers")
+ (description "@code{parse-number} is a library of functions for parsing
+strings into one of the standard Common Lisp number types without using the
+reader. @code{parse-number} accepts an arbitrary string and attempts to parse
+the string into one of the standard Common Lisp number types, if possible, or
+else @code{parse-number} signals an error of type @code{invalid-number}.")
+ (license license:bsd-3)))
+
+(define-public cl-parse-number
+ (sbcl-package->cl-source-package sbcl-parse-number))
+
+(define-public ecl-parse-number
+ (sbcl-package->ecl-package sbcl-parse-number))
+
+(define-public sbcl-parseq
+ (package
+ (name "sbcl-parseq")
+ (version "0.5.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mrossini-ethz/parseq";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-parseq" version))
+ (sha256
+ (base32 "0b4lnhwqdlaqccanyssdj2v0am2ygw6qr4543b49kz2rwirykw0w"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/mrossini-ethz/parseq";)
+ (synopsis "Parsing expression grammars for sequences")
+ (description
+ "Parseq (pronounced parsec) is a parsing library for common lisp. It can
+be used for parsing lisp's sequences types: strings, vectors (e.g. binary
+data) and lists. Furthermore, parseq is able to parse nested structures such
+as trees (e.g. lists of lists, lists of vectors, vectors of strings).
+
+Parseq uses parsing expression grammars (PEG) that can be defined through a
+simple interface. Extensions to the standard parsing expressions are
+available. Parsing expressions can be parameterised and made context
+aware. Additionally, the definition of each parsing expression allows the
+arbitrary transformation of the parsing tree.
+
+The library is inspired by Esrap and uses a very similar interface. No code
+is shared between the two projects, however. The features of Esrap are are
+mostly included in parseq and complemented with additional, orthogonal
+features. Any resemblance to esrap-liquid is merely coincidental.")
+ (license license:gpl2)))
+
+(define-public cl-parseq
+ (sbcl-package->cl-source-package sbcl-parseq))
+
+(define-public ecl-parseq
+ (sbcl-package->ecl-package sbcl-parseq))
+
+(define-public sbcl-parser-combinators
+ (let ((commit "9c7569a4f6af5e60c0d3a51d9c15c16d1714c845")
(revision "1"))
(package
- (name "sbcl-sdl2-ttf")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-parser-combinators")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispgames/cl-sdl2-ttf";)
+ (url "https://github.com/Ramarren/cl-parser-combinators";)
(commit commit)))
- (file-name (git-file-name "cl-sdl2-ttf" version))
+ (file-name (git-file-name "parser-combinators" version))
(sha256
- (base32 "07c1bl66dix6ccnyl9mqd6lbk10f9s25985zmv6lss95491ng7my"))))
+ (base32 "1k49vha5xm2cklayzpqwg73n4v93xwsbs5in6342pkkiimnidhs8"))))
(build-system asdf-build-system/sbcl)
(arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libSDL2_ttf-2.0.so.0")
- (search-input-file inputs
"/lib/libSDL2_ttf-2.0.so.0")))))
- (add-after 'unpack 'fix-critical-warning
- (lambda _
- (substitute* "src/helpers.lisp"
- (("nreverse") "reverse")))))))
+ ;; FIXME: (Sharlatan-20210523T184237+0100): Tests require `femlisp',
which
+ ;; is quite chunky not packaged system yet, enable them when it's
packed.
+ `(#:tests? #f))
+ ;; (native-inputs
+ ;; `(("hu.dwim.stefil" ,sbcl-hu.dwim.stefil)
+ ;; ("infix" ,sbcl-femlisp)))
(inputs
- (list sdl2-ttf
- sbcl-alexandria
- sbcl-cffi
- sbcl-cl-autowrap
- sbcl-defpackage-plus
- sbcl-sdl2
- sbcl-trivial-garbage))
- (home-page "https://github.com/lispgames/cl-sdl2-ttf";)
- (synopsis "SDL2_ttf wrapper for Common Lisp")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-containers" ,sbcl-cl-containers)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("iterate" ,sbcl-iterate)))
+ (home-page "https://github.com/Ramarren/cl-parser-combinators";)
+ (synopsis "Parser combinators in Common Lisp")
(description
- "This is a wrapper for the SDL2_TTF library used for loading fonts and
-creating text assets. The library, in it's current state, can load TTF and
-OTF fonts and render fonts with the three different rendering modes provided
-by the C library (solid, shaded, and blended). While Latin text, UTF8,
-UNICODE, and Glyph text rendering is available only Latin text has been
-tested (as shown in the examples).")
- (license license:expat))))
+ "PARSER-COMBINATORS is a library implementing monadic parser
+combinators in Common Lisp, similar in concept to Haskell Parsec system.")
+ (license license:bsd-3))))
-(define-public ecl-sdl2-ttf
- (sbcl-package->ecl-package sbcl-sdl2-ttf))
+(define-public cl-parser-combinators
+ (sbcl-package->cl-source-package sbcl-parser-combinators))
-(define-public cl-sdl2-ttf
- (sbcl-package->cl-source-package sbcl-sdl2-ttf))
+(define-public ecl-parser-combinators
+ (sbcl-package->ecl-package sbcl-parser-combinators))
-(define-public sbcl-cl-gamepad
- (let ((commit "d5b99fbaa2e39294d23061699e8f1e761eda7205")
- (revision "3"))
+(define-public sbcl-path-parse
+ (let ((commit "86183f3752374435f8933394b4c5d8e75a37a113")
+ (revision "1"))
(package
- (name "sbcl-cl-gamepad")
- (version (git-version "3.0.0" revision commit))
+ (name "sbcl-path-parse")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-gamepad";)
+ (url "https://github.com/eudoxia0/path-parse";)
(commit commit)))
- (file-name (git-file-name "cl-gamepad" version))
+ (file-name (git-file-name "cl-path-parse" version))
(sha256
- (base32 "0y6kg9wq92p07i1chm1v7j7p77iqc5c985pdvmmivcip8zmd4hm4"))))
+ (base32 "10mxm6q62cfpv3hw2w8k968ba8a1xglqdkwlkqs4l4nby3b11aaq"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; No tests
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-evdev-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "evdev-cffi.lisp"
- (("libevdev.so")
- (search-input-file inputs "/lib/libevdev.so"))))))))
(inputs
- (list libevdev
- sbcl-cffi
- sbcl-documentation-utils
- sbcl-trivial-features))
- (home-page "https://shirakumo.github.io/cl-gamepad/";)
- (synopsis "Library for access to gamepads and joystick input devices")
+ (list sbcl-split-sequence))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/eudoxia0/path-parse";)
+ (synopsis "Parse the PATH environment variable in Common Lisp")
(description
- "This is a library to provide cross-platform access to gamepads,
-joysticks, and other such HID devices.")
- (license license:zlib))))
+ "This package provides a function to parse the @code{PATH} environment
+variable portably in Common Lisp.")
+ (license license:expat))))
-(define-public ecl-cl-gamepad
- (sbcl-package->ecl-package sbcl-cl-gamepad))
+(define-public cl-path-parse
+ (sbcl-package->cl-source-package sbcl-path-parse))
-(define-public cl-gamepad
- (sbcl-package->cl-source-package sbcl-cl-gamepad))
+(define-public ecl-path-parse
+ (sbcl-package->ecl-package sbcl-path-parse))
-(define-public sbcl-trial
- (let ((commit "db4e98ede16640238bd51bf5d63cda57c75a51ae")
- (revision "2"))
+(define-public sbcl-pathname-utils
+ (let ((commit "f28068a79825f37002e96d13dfd739172382bf94")
+ (revision "3"))
(package
- (name "sbcl-trial")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-pathname-utils")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/trial";)
+ (url "https://github.com/Shinmera/pathname-utils";)
(commit commit)))
- (file-name (git-file-name "cl-trial" version))
+ (file-name (git-file-name "cl-pathname-utils" version))
(sha256
- (base32 "0haslkzcgivz42k23n90w1dzw8zdgdrqcndadl33pqqlf0d20ilw"))))
+ (base32 "10xs0wnnkbdiirr1cb7q7hzi2zmksfsrj0p7yws0j1l215vz8qs8"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("trial"
- "trial-alloy"
- "trial-animation"
- "trial-assimp"
- ;; TODO: It requires a long packaging journey.
- ;; "trial-feedback"
- "trial-gif"
- "trial-glfw"
- ;; FIXME: Check why this system is failing:
- ;; WARNING: Invalid qualifiers for APPEND method
- ;; combination in method
- ;; ...
- ;; "trial-glop"
- "trial-gltf"
- "trial-harmony"
- "trial-jpeg"
- "trial-notify"
- "trial-png"
- ;; TODO: I'm not sure which QOI system to use here.
There are two:
- ;; - https://github.com/bpanthi977/qoi
- ;; - https://github.com/mfiano/qoi
- ;; "trial-qoi"
- ;; TODO: It requires a long packaging journey.
- ;; "trial-qt"
- "trial-sdl2"
- "trial-terragen"
- "trial-tga"
- "trial-tiff"
- "trial-workbench")))
(native-inputs
- (list sbcl-trivial-features))
+ (list sbcl-parachute))
(inputs
- (list sbcl-3d-matrices
- sbcl-3d-quaternions
- sbcl-3d-transforms
- sbcl-3d-vectors
- sbcl-alexandria
- sbcl-alloy
- sbcl-atomics
- sbcl-bordeaux-threads
- sbcl-cl-gamepad
- sbcl-cl-glfw3
- sbcl-cl-gltf
- sbcl-cl-jpeg
- sbcl-cl-opengl
- sbcl-cl-ppcre
- sbcl-cl-tga
- sbcl-classimp
- sbcl-closer-mop
- sbcl-deploy
- sbcl-dns-client
- sbcl-fast-io
- sbcl-file-notify
- sbcl-flare
- sbcl-float-features
- sbcl-flow
- sbcl-for
- sbcl-form-fiddle
- sbcl-glop
- sbcl-glsl-toolkit
- sbcl-harmony
- sbcl-ieee-floats
- sbcl-jzon
- sbcl-lambda-fiddle
- sbcl-language-codes
- sbcl-lquery
- sbcl-messagebox
- sbcl-mmap
- sbcl-pathname-utils
- sbcl-pngload
- sbcl-promise
- sbcl-retrospectiff
- sbcl-sdl2
- sbcl-simple-tasks
- sbcl-static-vectors
- sbcl-system-locale
- sbcl-terrable
- sbcl-trivial-extensible-sequences
- sbcl-trivial-garbage
- sbcl-trivial-indent
- sbcl-trivial-main-thread
- sbcl-verbose
- sbcl-zpng))
- (home-page "https://github.com/Shirakumo/trial";)
- (synopsis "Common Lisp game engine")
+ (list sbcl-trivial-features))
+ (home-page "https://shinmera.github.io/pathname-utils/";)
+ (synopsis "Collection of utilities to help with pathname operations")
(description
- "Trial is a game engine written in Common Lisp. Unlike many other
-engines, it is meant to be more of a loose connection of components that can be
-fit together as required by any particular game.")
+ "This package provides a Common Lisp system a with collection of common
+tests and operations to help handling pathnames. It does not actually deal in
+handling the accessing of files on the underlying system however.")
(license license:zlib))))
-;; TODO: Enable with new ECL when this issue is fixed:
-;; https://github.com/Shinmera/3d-quaternions/issues/2
-;; (define-public ecl-trial
-;; (sbcl-package->ecl-package sbcl-trial))
+(define-public cl-pathname-utils
+ (sbcl-package->cl-source-package sbcl-pathname-utils))
-(define-public cl-trial
- (sbcl-package->cl-source-package sbcl-trial))
+(define-public ecl-pathname-utils
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-pathname-utils))
+ (arguments
+ `(;; FIXME: It might be an issue in implementation of UIOP for ECL:
+ ;;
+ ;; Condition of type: TYPE-ERROR
+ ;; :HOME is not of type SEQUENCE.
+ ;; Available restarts:
+ ;; 1. (RESTART-TOPLEVEL) Go back to Top-Level REPL.
+ ;; Broken at SI:BYTECODES. [Evaluation of: (MAKE-PATHNAME :DIRECTORY
+ ;; '(:ABSOLUTE :HOME))] In: #<process TOP-LEVEL 0x7faa2f991f80>.
+ ;;
+ #:tests? #f))))
-(define-public sbcl-virality
- (let ((commit "cdc19cca9b028f0c30d14ed8b3e51359dd46069a")
+(define-public sbcl-percent-encoding
+ (let ((commit "c1224e22bc8048fbd3ebbc9329715a0c1b673170")
(revision "1"))
(package
- (name "sbcl-virality")
- (version (git-version "0.3.0" revision commit))
+ (name "sbcl-percent-encoding")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bufferswap/ViralityEngine";)
+ (url "https://github.com/llibra/percent-encoding";)
(commit commit)))
- (file-name (git-file-name "cl-virality" version))
+ (file-name (git-file-name "percent-encoding" version))
(sha256
- (base32 "1s25aapkqcr8fxi0i9wjw0n4jax7r4a9d9wflpr3sqz2vgrg2lz6"))))
+ (base32 "0q1lh3sa6mkjr5gcdkgimkpc29rgf9cjhv90f61h8ridj28grq0h"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("virality"
- "vorigin"
- "vorigin.test"
- "vshadow"
- "vumbra"
- "vutils")
- #:phases (modify-phases %standard-phases
- (add-after 'unpack 'delete-examples
- (lambda _
- ;; Don't install the big "examples" directory.
- (delete-file-recursively "examples")
- ;; Remove example asd files that cause issues during
- ;; the 'copy-source' phase because they have the same
- ;; names.
- (for-each
- delete-file
- (find-files "."
- "^xXx-SYSTEM-NAME-xXx\\.asd$")))))))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-3b-bmfont
- sbcl-babel
- sbcl-cl-cpus
- sbcl-cl-graph
- sbcl-cl-opengl
- sbcl-cl-ppcre
- sbcl-cl-slug
- sbcl-closer-mop
- sbcl-fast-io
- sbcl-global-vars
- sbcl-glsl-packing
- sbcl-jsown
- sbcl-lparallel
- sbcl-pngload
- sbcl-printv
- sbcl-queues
- sbcl-sdl2
- sbcl-serapeum
- sbcl-split-sequence
- sbcl-static-vectors
- sbcl-trivial-features
- sbcl-varjo))
- (home-page "https://github.com/bufferswap/ViralityEngine";)
- (synopsis "Component-based game engine written in Common Lisp")
+ (list sbcl-anaphora sbcl-babel))
+ (synopsis "RFC 3986 percent-encoding library")
(description
- "Virality Engine provides a system and workflow that helps describe the
-elements needed to write 2D or 3D games. It was designed with several domain
-specific languages that make it easier to describe, manipulate, and use assets
-commonly found in game making. Such assets include (but are not limited to)
-textures, materials, shader programs, and scene trees of actors that are
-available for instantiation. Virality Engine also knows how to accept input
-from keyboards and most joysticks and gamepads.
+ "This is a Common Lisp library providing RFC 3986 percent-encoding.")
+ (home-page "https://github.com/llibra/percent-encoding";)
+ (license license:expat))))
+
+(define-public ecl-percent-encoding
+ (sbcl-package->ecl-package sbcl-percent-encoding))
+
+(define-public cl-percent-encoding
+ (sbcl-package->cl-source-package sbcl-percent-encoding))
+
+(define-public sbcl-periodic-table
+ (package
+ (name "sbcl-periodic-table")
+ (version "1.0")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://common-lisp.net/project/chemboy/periodic-table-";
+ version ".tar.gz"))
+ (sha256
+ (base32 "1ircvqm3q93ma4rxbxprb1i9rcax10ld6xmdzdhfnigr27sh5jvg"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/chemboy/";)
+ (synopsis "Periodic table for Common Lisp")
+ (description
+ "This package defines a Common Lisp package, @code{:elements}, with an
+@code{ELEMENT} structure and a number of functions to search the periodic
+table.")
+ (license license:llgpl)))
-The component system is a hybrid model between an ECS and an object model. The
-components are defined similar to CLOS defclass, and regular generic methods
-can be used with them. Components are added to Actors which represent game
-concepts like players, scenery, effects, etc. We define a component protocol
-invoked by Virality Engine to move your components to the next state and
-render them each frame.")
- (license license:expat))))
+(define-public cl-periodic-table
+ (sbcl-package->cl-source-package sbcl-periodic-table))
-(define-public cl-virality
- (sbcl-package->cl-source-package sbcl-virality))
+(define-public ecl-periodic-table
+ (sbcl-package->ecl-package sbcl-periodic-table))
-(define-public sbcl-cl-liballegro
- (let ((commit "49f632ce97fc4f835bf5d450588793234b980a64")
- (revision "1"))
+(define-public sbcl-periods
+ (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949")
+ (revision "2"))
(package
- (name "sbcl-cl-liballegro")
- (version (git-version "0.2.15" revision commit))
+ (name "sbcl-periods")
+ (version (git-version "0.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/resttime/cl-liballegro";)
+ (url "https://github.com/jwiegley/periods";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0brbr7i342s0gadlnzd3a61w2b9ihhx60l19ararnc2asvyhmz7x"))))
+ (base32
+ "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'patch-allegro-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((allegro-lib-path (string-append
- (assoc-ref inputs "allegro") "/lib/")))
- (substitute* "src/library.lisp"
- (("lib \".so\"" all)
- (string-append "\"" allegro-lib-path "\"" " lib
\".so\"")))))))))
(inputs
- `(("allegro" ,allegro)
- ("cffi" ,sbcl-cffi)
- ("float-features" ,sbcl-float-features)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("trivial-main-thread" ,sbcl-trivial-main-thread)))
- (home-page "https://github.com/resttime/cl-liballegro";)
- (synopsis "Allegro 5 game programming library bindings for Common Lisp")
+ `(("local-time" ,sbcl-local-time)
+ ("series" ,sbcl-series)))
+ (arguments
+ '(#:asd-systems '("periods"
+ "periods-series")))
+ (synopsis "Common Lisp library for manipulating date/time objects")
(description
- "This package provides CFFI bindings and interface to Allegro 5 game
-developing library for Common Lisp.")
- (license license:zlib))))
+ "Periods is a Common Lisp library providing a set of utilities for
+manipulating times, distances between times, and both contiguous and
+discontiguous ranges of time.")
+ (home-page "https://github.com/jwiegley/periods";)
+ (license license:bsd-3))))
-(define-public ecl-cl-liballegro
- (sbcl-package->ecl-package sbcl-cl-liballegro))
+(define-public cl-periods
+ (sbcl-package->cl-source-package sbcl-periods))
-(define-public cl-liballegro
- (sbcl-package->cl-source-package sbcl-cl-liballegro))
+(define-public ecl-periods
+ (sbcl-package->ecl-package sbcl-periods))
-(define-public sbcl-font-discovery
- (let ((commit "5101ca79151055f3ec9839aae73b8af42b884528")
- (revision "1"))
+(define-public sbcl-phos
+ (let ((commit "6620b82b091cdfed655e1093ef045dbe518d5474"))
(package
- (name "sbcl-font-discovery")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-phos")
+ (version (git-version "0.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/font-discovery";)
+ (url "https://github.com/omar-polo/phos";)
(commit commit)))
- (file-name (git-file-name "font-discovery" version))
+ (file-name (git-file-name "phos" version))
(sha256
- (base32 "1p9wkwc23rnif8vcjaj5ih1fmr5g57sidqjlz08qw6k0z4f6bia1"))))
+ (base32
+ "1zwci86rkbaiix0w2gd5q6nr8v2vv945pkvwp0j240iyzd4hfxr3"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cffi sbcl-documentation-utils sbcl-trivial-indent))
- (home-page "https://shinmera.github.io/font-discovery/";)
- (synopsis "Find system font files matching a font spec")
- (description
- "This is a library to find system font files. It works on systems with
-FontConfig on Linux, BSD. It does not have any foreign dependencies that
-aren't already directly available on the system.")
- (license license:zlib))))
+ (list sbcl-quri sbcl-cl-ppcre sbcl-trivia sbcl-usocket sbcl-cl+ssl
+ ;; For the experimental GUI:
+ sbcl-nodgui))
+ (native-inputs
+ (list sbcl-clunit2))
+ (home-page "https://github.com/omar-polo/phos";)
+ (synopsis "Gemini client library and experimental GUI")
+ (description "This package contains a Gemini client library for Common
+Lisp. A subsystem offers an experimental GUI Gemini client.")
+ (license license:isc))))
-(define-public ecl-font-discovery
- (sbcl-package->ecl-package sbcl-font-discovery))
+(define-public cl-phos
+ (sbcl-package->cl-source-package sbcl-phos))
-(define-public cl-font-discovery
- (sbcl-package->cl-source-package sbcl-font-discovery))
+(define-public ecl-phos
+ (sbcl-package->ecl-package sbcl-phos))
-(define-public sbcl-alloy
- (let ((commit "628974de537affb5b44ad548347f67c16efffcfc")
- (revision "3"))
+(define-public sbcl-physical-quantities
+ (package
+ (name "sbcl-physical-quantities")
+ (version "0.2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/mrossini-ethz/physical-quantities";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-physical-quantities" version))
+ (sha256
+ (base32 "0mb2s94s6fhw5vfa89naalw7ld11sdsszlqpz0c65dvpfyfmmdmh"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-parseq))
+ (home-page "https://github.com/mrossini-ethz/physical-quantities";)
+ (synopsis "Numeric type with optional unit and/or uncertainty for physics")
+ (description
+ "This lisp library handles physical quantities which consist of
+
+@itemize
+@item value / magnitude
+@item uncertainty / error
+@item unit
+@end itemize
+
+where the type of the value can be any subtype of real. For the uncertainty,
+both absolute and relative values are possible. Combinations of lisp symbols
+or strings are used to describe units. User defined units including
+abbreviations and prefixes are supported. Error propagation and unit checking
+is performed for all defined operations.")
+ (license license:gpl2)))
+
+(define-public cl-physical-quantities
+ (sbcl-package->cl-source-package sbcl-physical-quantities))
+
+(define-public ecl-physical-quantities
+ (sbcl-package->ecl-package sbcl-physical-quantities))
+
+(define-public sbcl-pileup
+ (let ((commit "f269473a570a8e55881082545ee63cfe5c7d3e72")
+ (revision "1"))
(package
- (name "sbcl-alloy")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-pileup")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/alloy";)
+ (url "https://github.com/nikodemus/pileup";)
(commit commit)))
- (file-name (git-file-name "cl-alloy" version))
+ (file-name (git-file-name "cl-pileup" version))
(sha256
- (base32 "0fx294qwxshgijss000pbjbnbwxqvxyw6p3mva36qljhbbkw2fxy"))))
+ (base32 "01gvshpxil0ggjgfmgcymbgmpsfaxy6aggm0bywkn40rck3038vb"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria sbcl-parachute))
(inputs
- (list sbcl-array-utils sbcl-closer-mop sbcl-documentation-utils
- sbcl-float-features sbcl-colored sbcl-stealth-mixin
- sbcl-cl-opengl sbcl-font-discovery sbcl-uax-14 sbcl-sdf))
- (arguments
- ;; Dismiss alloy-svg, since it is not completed:
- ;; https://github.com/Shirakumo/alloy/issues/24
- '(#:asd-systems '("alloy"
- "alloy-animation"
- "alloy-opengl"
- "alloy-opengl-msdf"
- "alloy-opengl-png"
- "alloy-simple"
- "alloy-simple-presentations"
- "alloy-windowing")))
- (home-page "https://shirakumo.github.io/alloy/";)
- (synopsis
- "Common Lisp user interface protocol and toolkit implementation")
+ (list sbcl-alexandria sbcl-bordeaux-threads))
+ (native-inputs
+ (list sbcl-hu.dwim.stefil))
+ (home-page "https://github.com/nikodemus/pileup";)
+ (synopsis "Simple thread-safe binary heap implementation for Common
Lisp")
(description
- "Alloy is a user interface toolkit. It is defined through a set of
-protocols that allow for a clear interface, as well as a standardised way to
-integrate Alloy into a target backend.")
- (license license:zlib))))
+ "@code{Pileup} is a portable, performant, and thread-safe binary heap
+for Common Lisp.")
+ (license license:expat))))
-(define-public ecl-alloy
- (sbcl-package->ecl-package sbcl-alloy))
+(define-public cl-pileup
+ (sbcl-package->cl-source-package sbcl-pileup))
-(define-public cl-alloy
- (sbcl-package->cl-source-package sbcl-alloy))
+(define-public ecl-pileup
+ (sbcl-package->ecl-package sbcl-pileup))
-(define-public sbcl-org-sampler
- (let ((commit "ee135a417750e5b1d810bb9574eb85223cb3038a")
+(define-public sbcl-piping
+ (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656")
(revision "1"))
(package
- (name "sbcl-org-sampler")
- (version (git-version "0.2.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/jphmrst/cl-org-sampler";)
- (commit commit)))
- (file-name (git-file-name "cl-org-sampler" version))
- (sha256
- (base32 "1dg029in14928qfxvfshyxmdwhzskzhxx3na0zy98ybx69b21qla"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-iterate))
- (home-page "https://github.com/jphmrst/cl-org-sampler";)
- (synopsis "Extracting Common Lisp docstrings as Emacs Org-mode documents")
- (description
- "ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode
-text for inclusion into a larger document.")
- (license license:llgpl))))
+ (name "sbcl-piping")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/piping/";)
+ (commit commit)))
+ (file-name (git-file-name "piping" version))
+ (sha256
+ (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://shinmera.github.io/piping/";)
+ (synopsis "Library to enable simple message pipelines")
+ (description
+ "This is a Common Lisp library to enable simple message pipelines.")
+ (license license:zlib))))
-(define-public ecl-org-sampler
- (sbcl-package->ecl-package sbcl-org-sampler))
+(define-public cl-piping
+ (sbcl-package->cl-source-package sbcl-piping))
-(define-public cl-org-sampler
- (sbcl-package->cl-source-package sbcl-org-sampler))
+(define-public ecl-piping
+ (sbcl-package->ecl-package sbcl-piping))
-(define-public sbcl-acl-compat
- ;; There does not seem to be proper releases.
- (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5"))
+(define-public sbcl-plump
+ (let ((commit "0c3e0b57b43b6e0c5794b6a902f1cf5bee2a2927")
+ (revision "3"))
(package
- (name "sbcl-acl-compat")
- (version (git-version "0.1.1" "1" commit))
+ (name "sbcl-plump")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "git://git.code.sf.net/p/portableaserve/git")
- (commit commit)))
- (file-name (git-file-name "acl-compat" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/plump";)
+ (commit commit)))
+ (file-name (git-file-name "cl-plump" version))
(sha256
- (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))))
+ (base32 "1fyb66pqvr1iy31ah9638ihs8cax17zkxk0zq14jy7x5l9rq1qlf"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'cd-acl-compat
- (lambda _
- (chdir "acl-compat")
- #t)))))
(inputs
- `(("puri" ,sbcl-puri)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("ironclad" ,sbcl-ironclad)
- ("cl-fad" ,sbcl-cl-fad)))
- (home-page "https://sourceforge.net/projects/portableaserve/";)
- (synopsis "AllegroServe, a web server written in Common Lisp")
+ (list sbcl-array-utils sbcl-documentation-utils))
+ (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp")
(description
- "The server part of AllegroServe can be used either as a standalone web
-server or a module loaded into an application to provide a user interface to
-the application. AllegroServe's proxy ability allows it to run on the gateway
-machine between some internal network and the Internet. AllegroServe's client
-functions allow Lisp programs to explore the web.")
- (license license:llgpl))))
+ "Plump is a parser for HTML/XML-like documents, focusing on being
+lenient towards invalid markup. It can handle things like invalid attributes,
+bad closing tag order, unencoded entities, inexistent tag types, self-closing
+tags and so on. It parses documents to a class representation and offers a
+small set of DOM functions to manipulate it. It can be extended to parse to
+your own classes.")
+ (home-page "https://shinmera.github.io/plump/";)
+ (license license:zlib))))
-(define-public cl-acl-compat
- (sbcl-package->cl-source-package sbcl-acl-compat))
+(define-public cl-plump
+ (sbcl-package->cl-source-package sbcl-plump))
-(define-public sbcl-aserve
- ;; There does not seem to be proper releases.
- (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5")
- (revision "2"))
+(define-public ecl-plump
+ (sbcl-package->ecl-package sbcl-plump))
+
+(define-public sbcl-plump-sexp
+ (let ((commit "bbcf75e9ecda8fe7603098ab8c15828407bb4f08")
+ (revision "0"))
(package
- (name "sbcl-aserve")
- (version (git-version "1.2.50" revision commit))
+ (name "sbcl-plump-sexp")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- ;; https://github.com/franzinc/aserve/ seems to be incompatible
- ;; with SBCL, etc.
- (url "git://git.code.sf.net/p/portableaserve/git")
- (commit commit)))
- (file-name (git-file-name "aserve" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/plump-sexp";)
+ (commit commit)))
+ (file-name (git-file-name "cl-plump-sexp" version))
(sha256
- (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))
- (patches (search-patches
- ;; Add HTML5 elements to htmlgen.
- ;; Adapted from https://github.com/franzinc/aserve/ commits:
- ;; * e47bd763: "rfe12668: add HTML 5 elements to htmlgen"
- ;; * 7371ce59: "fix bugs in rfe12668 implementation"
- "sbcl-aserve-add-HTML-5-elements.patch"
- "sbcl-aserve-fix-rfe12668.patch"))))
+ (base32
+ "0zm9h0assjb8766z2v6l1k1s60y90y6f8smrl1dczwqlvc8xyln5"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'cd-aserve
- (lambda _
- (chdir "aserve")
- #t))
- (add-after 'cd-aserve 'fix-asd
- (lambda _
- (substitute* "aserve.asd"
- ((" :force t") ""))
- #t))
- (add-after 'cd-aserve 'fix-tests
- (lambda _
- (substitute* "test/t-aserve.cl"
- (("\\(asdf:oos 'asdf:load-op :ptester\\)") ""))
- #t)))))
(inputs
- `(("acl-compat" ,sbcl-acl-compat)))
- (home-page
-
"https://franz.com/support/documentation/current/doc/aserve/aserve.html";)
- (synopsis "AllegroServe, a web server written in Common Lisp")
+ (list sbcl-plump))
+ (synopsis "Convert S-expressions into a Plump DOM and back")
(description
- "The server part of AllegroServe can be used either as a standalone web
-server or a module loaded into an application to provide a user interface to
-the application. AllegroServe's proxy ability allows it to run on the gateway
-machine between some internal network and the Internet. AllegroServe's client
-functions allow Lisp programs to explore the web.")
- (license license:llgpl))))
+ "The Plump-SEXP library is a backend for Plump which can convert
+between S-expressions and the Plump DOM.")
+ (home-page "https://github.com/Shinmera/plump-sexp";)
+ (license license:zlib))))
-(define-public cl-aserve
- (sbcl-package->cl-source-package sbcl-aserve))
+(define-public cl-plump-sexp
+ (sbcl-package->cl-source-package sbcl-plump-sexp))
-(define-public sbcl-yxorp
- (let ((commit "c306898a467995e123a22316c9b79fcac442415b")
- (revision "4"))
+(define-public ecl-plump-sexp
+ (sbcl-package->ecl-package sbcl-plump-sexp))
+
+(define-public sbcl-png
+ (let ((commit "11b965fe378fd0561abe3616b18ff03af5179648")
+ (revision "1"))
(package
- (name "sbcl-yxorp")
- (version (git-version "0.4" revision commit))
+ (name "sbcl-png")
+ (version (git-version "0.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charJe/cl-yxorp";)
+ (url "https://github.com/ljosa/cl-png";)
(commit commit)))
- (file-name (git-file-name "cl-yxorp" version))
+ (file-name (git-file-name "cl-png" version))
(sha256
- (base32 "0ll1s9w29yhhgqssgiw58fcapw4n040gkvpz4sxwv3q2v60rbidj"))))
+ (base32 "173hqwpd0rwqf95mfx1h9l9c3i8bb0gvnpspzmmz3g5x3440czy4"))
+ ;; Patch to fix compiling with SBCL >= 2.1.6.
+ (patches (search-patches "sbcl-png-fix-sbcl-compatibility.patch"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-lib-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "libpng.lisp"
+ (("\"libpng\"")
+ (string-append "\""
+ (assoc-ref inputs "libpng")
+ "/lib/libpng\""))))))))
(inputs
- (list sbcl-chipz
- sbcl-chunga
- sbcl-cl+ssl
- sbcl-binding-arrows
- sbcl-cl-str
- sbcl-usocket
- sbcl-flexi-streams
- sbcl-rutils
- sbcl-salza2
- sbcl-trivial-garbage))
- (home-page "https://github.com/charje/cl-yxorp";)
- (synopsis
- "Reverse proxy server written in and configurable in Common Lisp")
+ `(("cffi" ,sbcl-cffi)
+ ("libpng" ,libpng)))
+ (home-page "https://github.com/ljosa/cl-png";)
+ (synopsis "Read and write PNG file format")
(description
- "This is a reverse proxy server written in and configurable in
-Common Lisp. It supports WebSocket, HTTP, HTTPS, HTTP to HTTPS
-redirecting, port and host forwarding configuration using a real programming
-language, HTTP header and body manipulation (also using a real programming
-language).")
- (license license:agpl3))))
-
-(define-public ecl-yxorp
- ;; Note that due to a bug in ECL this package does not build.
- ;; The bug has already been fixed on the development branch,
- ;; so this package will work work in the version after 21.2.1.
- (sbcl-package->ecl-package sbcl-yxorp))
+ "This package provides a @code{PNG} Common Lisp system to operate with
+Portable Network Graphics file format.")
+ (license license:lgpl2.1))))
-(define-public cl-yxorp
- (sbcl-package->cl-source-package sbcl-yxorp))
+(define-public ecl-png
+ (sbcl-package->ecl-package sbcl-png))
-(define-public cl-yxorp-cli
- (package
- (inherit sbcl-yxorp)
- (name "cl-yxorp-cli")
- (build-system gnu-build-system)
- (arguments
- '(#:tests? #f
- #:strip-binaries? #f
- #:phases
- (modify-phases %standard-phases
- (delete 'configure)
- (add-after 'unpack 'set-home
- (lambda _
- (setenv "HOME" "/tmp")))
- (replace 'build
- (lambda _
- (invoke
- "sbcl" "--noinform"
- "--non-interactive"
- "--no-userinit"
- "--eval" "(require :asdf)"
- "--eval" "(pushnew (uiop:getcwd) asdf:*central-registry*)"
- "--load" "build.lisp")))
- (replace 'install
- (lambda* (#:key outputs #:allow-other-keys)
- (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
- (mkdir-p bin)
- (install-file "cl-yxorp" bin)))))))
- (inputs (cons (list "sbcl" sbcl) (package-inputs sbcl-yxorp)))))
+(define-public cl-png
+ (sbcl-package->cl-source-package sbcl-png))
-(define-public sbcl-rss
- ;; No release.
- (let ((commit "51d0145e91b86327ae5c36364f9c3048052e7a58"))
+(define-public sbcl-png-read
+ (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
+ (revision "1"))
(package
- (name "sbcl-rss")
- (version (git-version "0.9.1.1" "2" commit))
+ (name "sbcl-png-read")
+ (version (git-version "0.3.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://git.kpe.io/cl-rss.git";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0wv3j13fj73gigriw5r9vi920hz05ld7zllsvbxdxvmyfy9k1kly"))
- (modules '((guix build utils)))
- (snippet
- ;; The useless bundled debian folder drags `make' into the closure.
- `(begin
- (delete-file-recursively "debian")
- #t))))
+ (url "https://github.com/Ramarren/png-read";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-aserve sbcl-kmrcl sbcl-xmls))
- (home-page "https://github.com/nsrahmad/cl-rss";)
- (synopsis "Common Lisp RSS processor")
- (description
- "This package provides a Common Lisp library for fetching and parsing
-RSS feeds data via HTTP. Currently, it supports RSS versions 0.90,
-0.91, and 0.92 as well as RSS version 2.")
+ (list sbcl-babel sbcl-chipz 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-rss
- (sbcl-package->cl-source-package sbcl-rss))
+(define-public cl-png-read
+ (sbcl-package->cl-source-package sbcl-png-read))
-(define-public sbcl-binascii
- (let ((commit "0fb0a9e5773148fd04d50efef08c1cc10f6fc487")
- (revision "1"))
+(define-public ecl-png-read
+ (sbcl-package->ecl-package sbcl-png-read))
+
+(define-public sbcl-pngload
+ (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f")
+ (revision "2"))
(package
- (name "sbcl-binascii")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-pngload")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/binascii";)
+ (url "https://git.mfiano.net/mfiano/pngload.git";)
(commit commit)))
- (file-name (git-file-name "cl-binascii" version))
+ (file-name (git-file-name "pngload" version))
(sha256
- (base32 "000rcdl8qshr7n48zq9bzrc4lkjx4ylb3r3w9x9syhiwfla9j4b7"))
- (modules '((guix build utils)))
- (snippet
- ;; Unbundle the RT test framework.
- '(begin
- (delete-file "tests/rt.lisp")
- (substitute* "binascii.asd"
- ((":depends-on \\(binascii\\)")
- ":depends-on (binascii rt)")
- (("\\(:file \"rt\"\\)")
- "")
- (("\\(:file \"tests\" :depends-on \\(\"rt\"\\)\\)")
- "(:file \"tests\")"))))))
+ (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-rt))
- (home-page "https://github.com/sharplispers/binascii";)
- (synopsis "Common Lisp library of ASCII encoding schemes for binary
data")
+ (inputs
+ `(("3bz" ,sbcl-3bz)
+ ("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("mmap" ,sbcl-mmap)
+ ("parse-float" ,sbcl-parse-float)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("swap-bytes" ,sbcl-swap-bytes)
+ ("zpb-exif" ,sbcl-zpb-exif)))
+ (arguments
+ ;; Test suite disabled because of a dependency cycle.
+ ;; pngload tests depend on opticl which depends on pngload.
+ '(#:tests? #f))
+ (home-page "https://git.mfiano.net/mfiano/pngload.git";)
+ (synopsis "PNG image decoder for Common Lisp")
(description
- "@code{binascii} is a Common Lisp library for converting binary data
-to ASCII text of some kind. Such conversions are common in email protocols
-(for encoding attachments to support old non-8-bit clean transports) or
-encoding binary data in HTTP and XML applications. @code{binascii} supports
-the encodings described in RFC 4648: base64, base32, base16, and variants.
-It also supports base85, used in Adobe's PostScript and PDF document formats,
-and a variant called ascii85, used by git for binary diff files.")
- (license license:bsd-3))))
+ "This is a Common Lisp library to load images in the PNG image format,
+both from files on disk, or streams in memory.")
+ (license license:expat))))
-(define-public cl-binascii
- (sbcl-package->cl-source-package sbcl-binascii))
+(define-public cl-pngload
+ (sbcl-package->cl-source-package sbcl-pngload))
-(define-public sbcl-trivial-with-current-source-form
- (let ((commit "9e343e043a77a5478c1f77bb626db22335fbbfb8")
- (revision "1"))
+(define-public ecl-pngload
+ (sbcl-package->ecl-package sbcl-pngload))
+
+(define-public sbcl-policy-cond
+ (let ((commit "eedb625520175bfdf44d385ff3b21039b7f75706")
+ (revision "0"))
(package
- (name "sbcl-trivial-with-current-source-form")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-policy-cond")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url
- "https://github.com/scymtym/trivial-with-current-source-form";)
+ (url "https://github.com/stylewarning/policy-cond";)
(commit commit)))
- (file-name (git-file-name "trivial-with-current-source-form" version))
+ (file-name (git-file-name "cl-policy-cond" version))
(sha256
- (base32 "15zs7mc422ycp1cvcxmirif1dq15mlmv8vzd6l6nzn4qgmph9wz0"))))
+ (base32 "0xj2a6lcg7i7g4038sc4f641din6m8vdiha8c5afz9fik80bshxk"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/scymtym/trivial-with-current-source-form";)
- (synopsis "Help producing better errors for macro users")
- (description
- "This library allows macro writers to provide better feedback to macro
-users when errors are signaled during macroexpansion. It uses the compiler's
-concept of a source-form to report where the error or warning is located.")
- (license license:lgpl3))))
+ (home-page "https://github.com/stylewarning/policy-cond";)
+ (synopsis "Insert code based on compiler policy")
+ (description "POLICY-COND provides tools to insert and execute code
+based on a compiler's OPTIMIZE policy. It also contains a contract-like notion
+of expectations, which allow dynamic checking or inclusion of various things
+that should happen depending on compiler policy.")
+ (license license:bsd-3))))
-(define-public ecl-trivial-with-current-source-form
- ;; Trivial-with-current-source-form does not give any benefits on ECL.
- ;; This package is so packages dependent on trivial-with-current-source-form
- ;; can be loaded on ECL.
- (sbcl-package->ecl-package sbcl-trivial-with-current-source-form))
+(define-public cl-policy-cond
+ (sbcl-package->cl-source-package sbcl-policy-cond))
-(define-public cl-trivial-with-current-source-form
- (sbcl-package->cl-source-package sbcl-trivial-with-current-source-form))
+(define-public ecl-policy-cond
+ (sbcl-package->ecl-package sbcl-policy-cond))
-(define-public sbcl-tailrec
- (let ((commit "6f882846d8f5bca9138df26510862e64bb15d92f")
- (revision "2"))
+(define-public sbcl-polymorphic-functions
+ (package
+ (name "sbcl-polymorphic-functions")
+ (version "0.2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/digikar99/polymorphic-functions/";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-polymorphic-functions" version))
+ (sha256
+ (base32 "161ylp3avmkylgfddp7i1kscv3bqx734jk1i97xhsbl7x83nin0h"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-compiler-macro-notes
+ sbcl-ctype
+ sbcl-fiveam
+ sbcl-cl-form-types
+ sbcl-introspect-environment
+ sbcl-slime-swank))
+ (arguments
+ ;; Tests fail: https://github.com/digikar99/polymorphic-functions/issues/8
+ '(#:tests? #f))
+ (home-page "https://github.com/digikar99/polymorphic-functions/";)
+ (synopsis "Function type to dispatch on types instead of classes")
+ (description
+ "This library provides all of
+
+@itemize
+@item ad hoc polymorphism and
+@item subtype polymorphism
+@item parametric polymorphism (in a very limited sense)
+@end itemize
+
+to dispatch on the basis of types rather than classes.")
+ (license license:expat)))
+
+(define-public cl-polymorphic-functions
+ (sbcl-package->cl-source-package sbcl-polymorphic-functions))
+
+(define-public ecl-polymorphic-functions
+ (sbcl-package->ecl-package sbcl-polymorphic-functions))
+
+(define-public sbcl-portable-condition-system
+ (let ((commit "1307ec146d227a9d8ea42312c1ba2a5206a9eb3c")
+ (revision "0"))
(package
- (name "sbcl-tailrec")
- (version (git-version "0" revision commit))
+ (name "sbcl-portable-condition-system")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charje/tailrec";)
+ (url "https://github.com/phoe/portable-condition-system";)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1h8m2npdzd2cpnl75pvv4yvvfwxa7kl6qvalc9s0y4yws0kaih3i"))))
+ (base32 "099lb9f4bavj95wik99wla5rf6fk1gdw9pvn0cqlaf0wf20csd3h"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("portable-condition-system")))
+ (native-inputs
+ (list sbcl-1am))
(inputs
- (list sbcl-alexandria sbcl-trivial-macroexpand-all
- sbcl-trivial-with-current-source-form))
- (home-page "https://github.com/charje/tailrec";)
- (synopsis "Macro to optimize a Common Lisp function for tail recursion")
- (description "Just wrap your Common Lisp function in this macro call and
-it will be optimized for tail recursion. You will be warned if the function
-is not tail recursive.")
- (license license:llgpl))))
+ (list sbcl-alexandria
+ sbcl-split-sequence))
+ (home-page "https://github.com/phoe/portable-condition-system";)
+ (synopsis "Portable condition system for Common Lisp")
+ (description
+ "This package provides an example implementation of the Common Lisp
+condition system and library, based on the original condition system
+implementation by Kent M. Pitman.")
+ (license license:cc0))))
-(define-public ecl-tailrec
- (sbcl-package->ecl-package sbcl-tailrec))
+(define-public cl-portable-condition-system
+ (sbcl-package->cl-source-package sbcl-portable-condition-system))
-(define-public cl-tailrec
- (sbcl-package->cl-source-package sbcl-tailrec))
+(define-public ecl-portable-condition-system
+ (sbcl-package->ecl-package sbcl-portable-condition-system))
-(define-public sbcl-issr-core
- (let ((commit "64e3b07a63a7ca3ad70ba42474f98ac4513580aa")
- (revision "1"))
+(define-public sbcl-portable-threads
+ (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df"))
(package
- (name "sbcl-issr-core")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-portable-threads")
+ (version (git-version "2.3" "2" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/interactive-ssr/core";)
+ (url "https://github.com/binghe/portable-threads/";)
(commit commit)))
- (file-name (git-file-name "issr-core" version))
+ (file-name (git-file-name "portable-threads" version))
(sha256
- (base32 "1bajb09crzadkirdpd6jrpcc55irjd4sxzavygr25l85pafyhniw"))))
+ (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-str sbcl-global-vars sbcl-plump sbcl-tailrec))
- (home-page
- "https://github.com/interactive-ssr/client/blob/master/main.org";)
- (synopsis "The core functionality for ISSR server modules")
+ (arguments
+ `(;; Tests seem broken.
+ #:tests? #f))
+ (home-page "https://github.com/binghe/portable-threads";)
+ (synopsis "Portable threads API for Common Lisp")
(description
- "ISSR core provides functions and variables for ISSR server modules so
-that different servers can behave similarly. The most important features are
-Document Object Model differencing to generate instructions to update a DOM,
-and DOM cleaning, to ensure that all remote DOMs are the same.")
- (license license:llgpl))))
-
-(define-public ecl-issr-core
- (sbcl-package->ecl-package sbcl-issr-core))
+ "Portable Threads (and Scheduled and Periodic Functions) API for Common
+Lisp (from GBBopen project).")
+ (license license:asl2.0))))
-(define-public cl-issr-core
- (sbcl-package->cl-source-package sbcl-issr-core))
+(define-public cl-portable-threads
+ (sbcl-package->cl-source-package sbcl-portable-threads))
+
+(define-public ecl-portable-threads
+ (sbcl-package->ecl-package sbcl-portable-threads))
(define-public sbcl-portal
(let ((commit "416589fa04cb239971422a1272acba236c8333be")
@@ -24250,6870 +23323,7795 @@ keywords for different websocket events. It has
useful restarts and
customizable errors.")
(license license:llgpl))))
+(define-public cl-portal
+ (sbcl-package->cl-source-package sbcl-portal))
+
(define-public ecl-portal
(sbcl-package->ecl-package sbcl-portal))
-(define-public cl-portal
- (sbcl-package->cl-source-package sbcl-portal))
+(define-public sbcl-positional-lambda
+ (let ((commit "a43a7bb4ef6faa277e6a7440ec9839711c4b9d28")
+ (revision "0"))
+ (package
+ (name "sbcl-positional-lambda")
+ (version (git-version "2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/positional-lambda";)
+ (commit commit)))
+ (file-name (git-file-name "cl-positional-lambda" version))
+ (sha256
+ (base32 "1l27mw5ciqz7rnjq1lwslgk220i8iqcr39rs8b7hxkp1yqmah5zq"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-map-bind))
+ (home-page "https://www.hexstreamsoft.com/libraries/positional-lambda/";)
+ (synopsis "Macro favouring positional references over naming")
+ (description
+ "This package provides a concise, intuitive and flexible macro for
+trivial lambdas that eschews explicit naming of parameter variables in favor
+of positional references, with support for a used or ignored &rest parameter
+and automatic declaration of ignored parameters when logical @code{gaps}
+are left in the positional references. Further convenience features
+are provided.")
+ (license license:unlicense))))
-(define-public sbcl-hunchenissr
- (let ((commit "7df702f2e110999a2f31c7ebad81bfc39ac06670")
- (revision "1"))
+(define-public cl-positional-lambda
+ (sbcl-package->cl-source-package sbcl-positional-lambda))
+
+(define-public ecl-cl-positional-lambda
+ (sbcl-package->ecl-package sbcl-positional-lambda))
+
+(define-public sbcl-postmodern
+ (package
+ (name "sbcl-postmodern")
+ (version "1.32.9")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/marijnh/Postmodern";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "137jci4hn4vlxf48y39k0di27kc89kvxy3brmn3vl9xq56sy6mhz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cl-base64" ,sbcl-cl-base64)
+ ("cl-unicode" ,sbcl-cl-unicode)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("global-vars" ,sbcl-global-vars)
+ ("ironclad" ,sbcl-ironclad)
+ ("local-time" ,sbcl-local-time)
+ ("md5" ,sbcl-md5)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("uax-15" ,sbcl-uax-15)
+ ("usocket" ,sbcl-usocket)))
+ (arguments
+ ;; TODO: (Sharlatan-20210114T171037+0000) tests still failing but on other
+ ;; step, some functionality in `local-time' prevents passing tests.
+ ;; Error:
+ ;;
+ ;; Can't create directory
+ ;; /gnu/store
+ ;; /4f47agf1kyiz057ppy6x5p98i7mcbfsv-sbcl-local-time-1.0.6-2.a177eb9
+ ;; /lib/common-lisp/sbcl/local-time/src/integration/
+ ;;
+ ;; NOTE: (Sharlatan-20210124T191940+0000): When set env HOME to /tmp above
+ ;; issue is resolved but it required live test database to connect to now.
+ ;; Keep tests switched off.
+ `(#:tests? #f
+ #:asd-systems '("cl-postgres"
+ "s-sql"
+ "postmodern"
+ "simple-date"
+ "simple-date/postgres-glue")))
+ (synopsis "Common Lisp library for interacting with PostgreSQL")
+ (description
+ "@code{postmodern} is a Common Lisp library for interacting with
+PostgreSQL databases. It provides the following features:
+
+@itemize
+@item Efficient communication with the database server without need for
+foreign libraries.
+@item Support for UTF-8 on Unicode-aware Lisp implementations.
+@item A syntax for mixing SQL and Lisp code.
+@item Convenient support for prepared statements and stored procedures.
+@item A metaclass for simple database-access objects.
+@end itemize\n
+
+This package produces 4 systems: postmodern, cl-postgres, s-sql, simple-date
+
+@code{SIMPLE-DATE} is a very basic implementation of date and time objects,
used
+to support storing and retrieving time-related SQL types. It is not loaded by
+default and you can use local-time (which has support for timezones) instead.
+
+@code{S-SQL} is used to compile s-expressions to strings of SQL code, escaping
+any Lisp values inside, and doing as much as possible of the work at compile
+time.
+
+@code{CL-POSTGRES} is the low-level library used for interfacing with a
PostgreSQL
+server over a socket.
+
+@code{POSTMODERN} itself is a wrapper around these packages and provides higher
+level functions, a very simple data access object that can be mapped directly
to
+database tables and some convient utilities. It then tries to put all these
+things together into a convenient programming interface")
+ (home-page "https://marijnhaverbeke.nl/postmodern/";)
+ (license license:zlib)))
+
+(define-public cl-postmodern
+ (sbcl-package->cl-source-package sbcl-postmodern))
+
+(define-public ecl-postmodern
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-postmodern))
+ (arguments
+ `(#:tests? #f
+ #:asd-systems '("cl-postgres"
+ "s-sql"
+ "postmodern"
+ "simple-date"
+ "simple-date/postgres-glue")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (substitute* "cl-postgres.asd"
+ ((":or :sbcl :allegro :ccl :clisp" all)
+ (string-append all " :ecl")))
+ #t)))))))
+
+(define-public sbcl-pp-toml
+ (let ((commit "54f7d08c939d18b24363342c98c19b6812d7afb9")
+ (revision "0"))
(package
- (name "sbcl-hunchenissr")
- (version (git-version "1" revision commit))
+ (name "sbcl-pp-toml")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/interactive-ssr/hunchenissr";)
+ (url "https://github.com/pnathan/pp-toml";)
(commit commit)))
- (file-name (git-file-name "hunchenissr" version))
+ (file-name (git-file-name "cl-pp-toml" version))
(sha256
- (base32 "0826qrvk64pjspdklns29dv3zhzfhd6k42fq030xajv8a7hkcxda"))))
+ (base32 "136d7jzz7l2ck9wwld0ac46jmpm94lvja6m50sy73s232slka2hg"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-cl-base64
- sbcl-cl-str
- sbcl-hunchentoot
- sbcl-issr-core
- sbcl-jonathan
- sbcl-plump
- sbcl-portal))
- (home-page "https://github.com/interactive-ssr/hunchenissr";)
- (synopsis "Interactive Server Side Rendering backend for Hunchentoot")
+ (list sbcl-alexandria
+ sbcl-cl-ppcre
+ sbcl-esrap
+ sbcl-generic-comparability
+ sbcl-local-time
+ sbcl-parse-number
+ sbcl-split-sequence))
+ (home-page "https://github.com/pnathan/pp-toml";)
+ (synopsis "TOML parser for Common Lisp")
(description
- "Hunchenissr works together with issr.js for the development of
-interactive (changing without page refreshes) websites making use of websocket
-and Common Lisp server HTML generation instead of mountains of convoluted
-Javascript.")
+ "PP-TOML is a Common Lisp library for parsing strings in the TOML
+configuration file format. It implements only the 0.1.0 specification of
+TOML.")
(license license:llgpl))))
-(define-public ecl-hunchenissr
- (sbcl-package->ecl-package sbcl-hunchenissr))
+(define-public cl-pp-toml
+ (sbcl-package->cl-source-package sbcl-pp-toml))
-(define-public cl-hunchenissr
- (sbcl-package->cl-source-package sbcl-hunchenissr))
+(define-public ecl-pp-toml
+ (sbcl-package->ecl-package sbcl-pp-toml))
-(define-public sbcl-hunchenissr-routes
- (let ((commit "2e831975dc2a6c030f1b518747cf429be8484b31")
- (revision "1"))
+(define-public sbcl-ppath
+ (let ((commit "eb1a8173b4d1d691ea9a7699412123462f58c3ce"))
(package
- (name "sbcl-hunchenissr-routes")
- (version (git-version "0" revision commit))
+ (name "sbcl-ppath")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/interactive-ssr/hunchenissr-routes";)
+ (url "https://github.com/fourier/ppath/";)
+ (commit commit)))
+ (file-name (git-file-name name commit))
+ (sha256
+ (base32 "1c46q9lmzqv14z80d3fwdawgn3pn4922x31fyqvsvbcjm4hd16fb"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-osicat
+ sbcl-cl-ppcre
+ sbcl-split-sequence
+ sbcl-trivial-features))
+ (native-inputs
+ (list sbcl-cl-fad sbcl-prove))
+ (home-page "https://github.com/fourier/ppath";)
+ (synopsis "Common Lisp's implementation of the Python's os.path module")
+ (description
+ "This library is a path strings manipulation library inspired by
+Python's @code{os.path}. All functionality from @code{os.path} is supported on
+major operation systems.
+
+The philosophy behind is to use simple strings and \"dumb\" string
+manipulation functions to handle paths and filenames. Where possible the
+corresponding OS system functions are called.")
+ (license license:bsd-2))))
+
+(define-public ecl-ppath
+ (sbcl-package->ecl-package sbcl-ppath))
+
+(define-public cl-ppath
+ (sbcl-package->cl-source-package sbcl-ppath))
+
+(define-public sbcl-printv
+ (let ((commit "e717a7fe076dae861a96117b2f9af29db8d2294d")
+ (revision "2"))
+ (package
+ (name "sbcl-printv")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/danlentz/printv";)
(commit commit)))
- (file-name (git-file-name "hunchenissr-routes" version))
+ (file-name (git-file-name "cl-printv" version))
(sha256
- (base32 "1xyqacihxwk4vnffqlg93czmalscglp6sh3bwy3qwb7hdxv6yxz6"))))
+ (base32 "07agyzkwp3w2r4d2anrmr8h00yngpr5dq9mjd3m4kzhn1jcmilfb"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-cl-ppcre sbcl-cl-unification
- sbcl-hunchenissr))
- (home-page "https://github.com/interactive-ssr/hunchenissr-routes";)
- (synopsis "Enable path variables when using Hunchenissr")
+ (list figlet))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-figlet-executable
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "printv.lisp"
+ (("\"figlet")
+ (string-append "\"" (search-input-file inputs
+ "/bin/figlet")))))))))
+ (home-page "https://github.com/danlentz/printv";)
+ (synopsis "Common Lisp tracing and debug-logging macro")
(description
- "This library enables path variables in networking routes when using
-Hunchenissr for Common Lisp. If a part of the path (between two slashes)
-starts with a question mark (?), that symbol (without question mark) will be
-bound to whatever value was in the same place in the URL (as a string).")
- (license license:llgpl))))
+ "@code{PRINTV} is a \"batteries-included\" tracing and debug-logging
+macro for Common Lisp.")
+ (license license:asl2.0))))
-(define-public ecl-hunchenissr-routes
- (sbcl-package->ecl-package sbcl-hunchenissr-routes))
+(define-public ecl-printv
+ (sbcl-package->ecl-package sbcl-printv))
-(define-public cl-hunchenissr-routes
- (sbcl-package->cl-source-package sbcl-hunchenissr-routes))
+(define-public cl-printv
+ (sbcl-package->cl-source-package sbcl-printv))
-(define-public sbcl-genhash
- (let ((commit "220ae1af8361dbd2005177f2ee11072b6a33934f")
- (revision "1"))
+(define-public sbcl-priority-queue
+ (let ((commit "011b8d52ef7ba7f8e6bc26608eedef222b38aaa8")
+ (revision "0"))
(package
- (name "sbcl-genhash")
- (version (git-version "1.7" revision commit))
+ (name "sbcl-priority-queue")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pnathan/genhash";)
+ (url "https://github.com/dsorokin/priority-queue";)
(commit commit)))
- (file-name (git-file-name "cl-genhash" version))
+ (file-name (git-file-name "cl-priority-queue" version))
(sha256
- (base32 "1jnk1fix1zydhy0kn3cvlp6dy0241x7v8ahq001nlr6v152z1cwk"))))
+ (base32 "0y5a1fid8xzzl58hfdj64n8mrzq0kr06a0lnmdjpgi0czc3x0jcy"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pnathan/genhash";)
- (synopsis "Generic hash tables for Common Lisp")
- (description
- "This an implementation of CDR 2: generic hash tables for Common Lisp")
- (license license:public-domain))))
+ (synopsis "Priority queue for Common Lisp")
+ (description "This package provides a priority queue implemented with
+an array-based heap.")
+ (home-page "https://github.com/dsorokin/priority-queue";)
+ (license license:expat))))
-(define-public cl-genhash
- (sbcl-package->cl-source-package sbcl-genhash))
+(define-public cl-priority-queue
+ (sbcl-package->cl-source-package sbcl-priority-queue))
-(define-public ecl-genhash
- (sbcl-package->ecl-package sbcl-genhash))
+(define-public ecl-priority-queue
+ (sbcl-package->ecl-package sbcl-priority-queue))
-(define-public sbcl-spinneret
- ;; No release since 2019, no tags.
- (let ((commit "d4398b5a344b5c59e497c9ee78fdbae7cc434f74"))
+(define-public sbcl-proc-parse
+ (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
(package
- (name "sbcl-spinneret")
- (version (git-version "3.0" "6" commit))
+ (name "sbcl-proc-parse")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/spinneret/";)
+ (url "https://github.com/fukamachi/proc-parse";)
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32 "1mdd92gfxfdsd81fcd8fgz8z7dwsb0kcv7zyzdgnw8lavkib5zly"))))
+ (base32
+ "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
+ (file-name (git-file-name "proc-parse" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-global-vars
- sbcl-parenscript
- sbcl-cl-markdown
- sbcl-cl-ppcre
- sbcl-serapeum
- sbcl-trivial-gray-streams))
+ `(("alexandria" ,sbcl-alexandria)
+ ("babel" ,sbcl-babel)))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/ruricolist/spinneret";)
- (synopsis "Common Lisp HTML5 generator")
+ (list sbcl-prove))
+ (arguments
+ '(#:asd-systems '("proc-parse-test"
+ "proc-parse")))
+ (synopsis "Procedural vector parser")
(description
- "In the crowded space of Common Lisp HTML generators, Spinneret
-occupies the following coordinates:
-
-@itemize
+ "This is a string/octets parser library for Common Lisp with speed and
+readability in mind. Unlike other libraries, the code is not a
+pattern-matching-like, but a char-by-char procedural parser.")
+ (home-page "https://github.com/fukamachi/proc-parse";)
+ (license license:bsd-2))))
-@item Modern. Targets HTML5. Does not treat XML and HTML as the same
-problem. Assumes you will be serving your documents as UTF-8.
+(define-public cl-proc-parse
+ (sbcl-package->cl-source-package sbcl-proc-parse))
-@item Composable. Makes it easy to refactor HTML generation into separate
-functions and macros.
+(define-public ecl-proc-parse
+ (sbcl-package->ecl-package sbcl-proc-parse))
-@item Pretty. Treats HTML as a document format, not a serialization. Output
-is idiomatic and readable, following the coding style of the HTML5
-specification.
+(define-public sbcl-prometheus
+ (package
+ (name "sbcl-prometheus")
+ (version "0.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/deadtrickster/prometheus.cl";)
+ (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-fad" ,sbcl-cl-fad)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("drakma" ,sbcl-drakma)
+ ("hunchentoot" ,sbcl-hunchentoot)
+ ("local-time" ,sbcl-local-time)
+ ("quantile-estimator" ,sbcl-quantile-estimator)
+ ("salza2" ,sbcl-salza2)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("trivial-utf-8" ,sbcl-trivial-utf-8)))
+ (arguments
+ '(#:asd-systems '("prometheus"
+ "prometheus.collectors.sbcl"
+ "prometheus.collectors.process"
+ "prometheus.formats.text"
+ "prometheus.exposers.hunchentoot"
+ "prometheus.pushgateway")))
+ (home-page "https://github.com/deadtrickster/prometheus.cl";)
+ (synopsis "Prometheus.io Common Lisp client")
+ (description "Prometheus.io Common Lisp client.")
+ (license license:expat)))
-@item Aggressive. If something can be interpreted as HTML, then it will be,
-meaning that some Lisp forms can't be mixed with HTML syntax. In the
-trade-off between 90% convenience and 10% correctness Spinneret is on the side
-of convenience.
+(define-public cl-prometheus
+ (sbcl-package->cl-source-package sbcl-prometheus))
-@item Bilingual. Spinneret (after loading @code{spinneret/ps}) has the same
-semantics in Lisp and Parenscript.
+(define-public ecl-prometheus
+ (sbcl-package->ecl-package sbcl-prometheus))
-@end itemize\n")
- (license license:expat))))
+(define-public sbcl-promise
+ (let ((commit "801db8f853da7935ae2e487fd7f8763acbc5ad2a")
+ (revision "0"))
+ (package
+ (name "sbcl-promise")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/promise";)
+ (commit commit)))
+ (file-name (git-file-name "cl-promise" version))
+ (sha256
+ (base32 "07cvz6vb5y1d9vndcwq7q1cp54aqvyqzv6wk8vmymbz3lawq2wsn"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/promise/";)
+ (synopsis "Promise mechanism for asynchronous operations")
+ (description
+ "This library implements a basic promise datastructure, which is useful
+for dealing with asynchronous behaviours. Importantly, this library does not
+use any other libraries or frameworks, and instead leaves the execution and
+state transition of promise objects in your control, making it easy to
+integrate.")
+ (license license:zlib))))
-(define-public ecl-spinneret
- (sbcl-package->ecl-package sbcl-spinneret))
+(define-public cl-promise
+ (sbcl-package->cl-source-package sbcl-promise))
-(define-public cl-spinneret
- (sbcl-package->cl-source-package sbcl-spinneret))
+(define-public ecl-promise
+ (sbcl-package->ecl-package sbcl-promise))
-(define-public sbcl-path-parse
- (let ((commit "86183f3752374435f8933394b4c5d8e75a37a113")
- (revision "1"))
+(define-public sbcl-prompter
+ (let ((commit "7890ed5d02e70aba01ceb964c6ee4f40776e7dc0")
+ (revision "0"))
(package
- (name "sbcl-path-parse")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-prompter")
+ (version (git-version "0.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/path-parse";)
+ (url "https://github.com/atlas-engineer/prompter";)
(commit commit)))
- (file-name (git-file-name "cl-path-parse" version))
+ (file-name (git-file-name "cl-prompter" version))
(sha256
- (base32 "10mxm6q62cfpv3hw2w8k968ba8a1xglqdkwlkqs4l4nby3b11aaq"))))
+ (base32
+ "0r15a6cagyp5x8aqx92ln2anni737h73bdshkvpzrac04ajss4md"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-split-sequence))
+ (list
+ sbcl-alexandria
+ sbcl-calispel
+ sbcl-cl-containers
+ sbcl-cl-str
+ sbcl-closer-mop
+ sbcl-lparallel
+ sbcl-moptilities
+ sbcl-nclasses
+ sbcl-serapeum
+ sbcl-trivial-package-local-nicknames))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/eudoxia0/path-parse";)
- (synopsis "Parse the PATH environment variable in Common Lisp")
+ (list sbcl-lisp-unit2))
+ (home-page "https://github.com/atlas-engineer/prompter";)
+ (synopsis "Live-narrowing, fuzzy-matching, extensible prompt framework")
(description
- "This package provides a function to parse the @code{PATH} environment
-variable portably in Common Lisp.")
- (license license:expat))))
+ "This prompter library is heavily inspired by Emacs' minibuffer and
+Helm (@url{https://emacs-helm.github.io/helm/}). It only deals with the
+backend side of things, it does not handle any display. Features include
+asynchronous suggestion computation, multiple sources, actions and resumable
+prompters.")
+ (license license:bsd-3))))
-(define-public cl-path-parse
- (sbcl-package->cl-source-package sbcl-path-parse))
+(define-public cl-prompter
+ (sbcl-package->cl-source-package sbcl-prompter))
-(define-public ecl-path-parse
- (sbcl-package->ecl-package sbcl-path-parse))
+(define-public ecl-prompter
+ (sbcl-package->ecl-package sbcl-prompter))
-(define-public sbcl-cl-libxml2
- (let ((commit "8d03110c532c1a3fe15503fdfefe82f60669e4bd"))
+(define-public sbcl-purgatory
+ (let ((commit "3afd8f6bb4093ffb2f39ffdedf11278b3617fff9")
+ (revision "1"))
(package
- (name "sbcl-cl-libxml2")
- (version (git-version "0.3.4" "1" commit))
+ (name "sbcl-purgatory")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/cl-libxml2";)
+ (url "https://notabug.org/cage/purgatory";)
(commit commit)))
- (file-name (git-file-name "cl-libxml2" version))
+ (file-name (git-file-name "cl-purgatory" version))
(sha256
- (base32 "09049c13cfp5sc6x9lrw762jd7a9qkfq5jgngqgrzn4kn9qscarw"))))
+ (base32 "0iy2jdgrwqrq9cph7bwf79d8l4zdsgcd9sfcn0lclzai2v0yizp9"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("flexi-streams" ,sbcl-flexi-streams)
- ("garbage-pools" ,sbcl-garbage-pools)
- ("iterate" ,sbcl-iterate)
- ("metabang-bind" ,sbcl-metabang-bind)
- ("puri" ,sbcl-puri)
- ;; Non-Lisp inputs:
- ("libxml2" ,libxml2)
- ("libxslt" ,libxslt)))
- (native-inputs
- (list sbcl-lift))
- (arguments
- `(#:tests? #f ; FIXME: Tests get stuck indefinitly
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (substitute* "tree/xtree.lisp"
- (("libxml2.so.2")
- (string-append (assoc-ref inputs "libxml2")
"/lib/libxml2.so")))
- (let ((libxslt (assoc-ref inputs "libxslt")))
- (substitute* "xslt/xslt.lisp"
- (("libxslt.so.1")
- (string-append libxslt "/lib/libxslt.so"))
- (("libexslt.so.0")
- (string-append libxslt "/lib/libexslt.so"))
- (("cllibxml2.so")
- (string-append (assoc-ref outputs "out")
"/lib/cllibxml2.so"))))
- #t))
- (add-before 'build 'build-helper-library
- (lambda* (#:key inputs outputs #:allow-other-keys)
- (let ((prefix-dir (string-append (assoc-ref outputs "out"))))
- (mkdir-p (string-append prefix-dir "/lib"))
- (invoke "make" "-C" "foreign" "install"
- "INSOPTS="
- (string-append "PREFIX=" prefix-dir))
- #t)))
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* '("cl-libxml2.asd" "cl-libxslt.asd" "xfactory.asd")
- ((" :force t") ""))
- #t)))))
- (home-page
"https://web.archive.org/web/20160121073421/http://cl-libxml2.googlecode.com/svn/doc/index.html";)
- (synopsis "High-level wrapper around libxml2 and libxslt libraries")
- (description
- "cl-libxml2 is high-level Common Lisp wrapper around the @code{libxml2}
-and @code{libxslt} libraries.
-
-@itemize
-@item Interfaces for tree manipulation (like @code{cxml-stp}).
-@item Interface for HTML 4.0 non-validating parsers.
-@item Specific APIs to process HTML trees, especially serialization.
-@item XPath API.
-@item XSLT API.
-@item Custom URL resolvers.
-@item XPath extension functions.
-@item XSLT extension elements.
-@item Translates @code{libxml2} and @code{libxslt} errors to Lisp conditions.
-@item Extends the Common Lisp @code{iterate} library with custom drivers for
-child nodes enumeration, etc.
-@item The @code{XFACTORY} system provides a simple and compact syntax for XML
generation.
-@end itemize\n")
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cl-ppcre-unicode
+ sbcl-usocket))
+ (synopsis "Common Lisp implementation of the 9p protocol")
+ (description "This is a Common Lisp library that implements
+the 9p network filesystem protocol.")
+ (home-page "https://notabug.org/cage/purgatory/";)
(license license:llgpl))))
-(define-public ecl-cl-libxml2
- (sbcl-package->ecl-package sbcl-cl-libxml2))
+(define-public cl-purgatory
+ (sbcl-package->cl-source-package sbcl-purgatory))
-(define-public cl-libxml2
- (sbcl-package->cl-source-package sbcl-cl-libxml2))
+(define-public ecl-purgatory
+ (sbcl-package->ecl-package sbcl-purgatory))
-(define-public sbcl-pileup
- (let ((commit "f269473a570a8e55881082545ee63cfe5c7d3e72")
- (revision "1"))
+(define-public sbcl-puri
+ (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b")
+ (revision "2"))
(package
- (name "sbcl-pileup")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-puri")
+ (version (git-version "1.5.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/nikodemus/pileup";)
+ (url "http://git.kpe.io/puri.git";)
(commit commit)))
- (file-name (git-file-name "cl-pileup" version))
+ (file-name (git-file-name "puri" version))
(sha256
- (base32 "01gvshpxil0ggjgfmgcymbgmpsfaxy6aggm0bywkn40rck3038vb"))))
+ (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The useless bundled debian folder drags `make' into the closure.
+ `(begin
+ (delete-file-recursively "debian")
+ #t))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-bordeaux-threads))
(native-inputs
- (list sbcl-hu.dwim.stefil))
- (home-page "https://github.com/nikodemus/pileup";)
- (synopsis "Simple thread-safe binary heap implementation for Common
Lisp")
+ (list sbcl-ptester))
+ (home-page "http://puri.kpe.io/";)
+ (synopsis "Portable URI Library")
(description
- "@code{Pileup} is a portable, performant, and thread-safe binary heap
-for Common Lisp.")
- (license license:expat))))
+ "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-pileup
- (sbcl-package->cl-source-package sbcl-pileup))
+(define-public cl-puri
+ (sbcl-package->cl-source-package sbcl-puri))
-(define-public ecl-pileup
- (sbcl-package->ecl-package sbcl-pileup))
+(define-public ecl-puri
+ (sbcl-package->ecl-package sbcl-puri))
-(define-public sbcl-feeder
- ;; No release.
- (let ((commit "b05f517d7729564575cc809e086c262646a94d34")
- (revision "1"))
+(define-public sbcl-py-configparser
+ ;; NOTE: (Sharlatan <2021-01-05 Tue> <19:52:19 UTC+0000>) Project updated
last
+ ;; time 8y ago, it looks like abandoned. VCS of the project:
+ ;; https://svn.common-lisp.net/py-configparser/trunk
+ (package
+ (name "sbcl-py-configparser")
+ (version "1.0.3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri (string-append
+ "https://common-lisp.net/project/py-configparser/releases/";
+ "py-configparser-" version ".tar.gz"))
+ (sha256
+ (base32 "0i4rqz5cv7d7c2w81x5lwy05s6fbi3zikf4k5kpi3bkx3cabwdxj"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-parse-number))
+ (home-page "https://common-lisp.net/project/py-configparser/";)
+ (synopsis "ConfigParser Python module functionality for Common Lisp")
+ (description "The py-configparser package implements the ConfigParser
+Python module functionality in Common Lisp. In short, it implements reading
+and writing of .INI-file style configuration files with sections containing
+key/value pairs of configuration options. In line with the functionalities in
+the python module, does this package implement basic interpolation of option
+values in other options.")
+ (license license:expat)))
+
+(define-public cl-py-configparser
+ (sbcl-package->cl-source-package sbcl-py-configparser))
+
+(define-public ecl-py-configparser
+ (sbcl-package->ecl-package sbcl-py-configparser))
+
+(define-public sbcl-py4cl
+ (let ((commit "2f2a008dd6162d4446803971292fe1b323fe0dd5")
+ (revision "2"))
(package
- (name "sbcl-feeder")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-py4cl")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/feeder";)
+ (url "https://github.com/bendudson/py4cl";)
(commit commit)))
- (file-name (git-file-name "feeder" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1dpbzhycg50snl3j01c8dh8gdvhfhz0hnfl54xy55a3wbr3m6rp7"))))
+ (base32
+ "1zx1kpfpd8mi1qaa7gr32mki6nvl6pqcs3437fvn4xa3yf7ybsha"))
+ (modules '((guix build utils)))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-clunit))
(inputs
- (list sbcl-documentation-utils sbcl-local-time sbcl-plump))
- (home-page "https://shinmera.github.io/feeder/";)
- (synopsis "RSS, Atom and general feed parsing and generating")
+ (list python sbcl-trivial-garbage))
+ (propagated-inputs
+ (list ;; For multi-dimensional array support
+ python-numpy))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-python3-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/python-process.lisp"
+ (("\\*python-command\\* \"python\"")
+ (string-append "*python-command* "
+ "\""
+ (search-input-file inputs "/bin/python3")
+ "\"")))))
+ (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/python-process.lisp"
+ (("py4cl/config:\\*base-directory\\*")
+ (string-append
+ "\""
+ (assoc-ref outputs "out")
+ "/share/common-lisp/"
+ (%lisp-type)
+ "/py4cl/"
+ "\""))))))))
+ (synopsis "Call python from Common Lisp")
(description
- "Feeder is a syndication feed library. It presents a general protocol
-for representation of feed items, as well as a framework to translate these
-objects from and to external formats. It also implements the RSS 2.0 and Atom
-formats within this framework.")
- (license license:zlib))))
-
-(define-public ecl-feeder
- (sbcl-package->ecl-package sbcl-feeder))
+ "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-feeder
- (sbcl-package->cl-source-package sbcl-feeder))
+(define-public cl-py4cl
+ (sbcl-package->cl-source-package sbcl-py4cl))
-(define-public sbcl-routes
- (let ((commit "1b79e85aa653e1ec87e21ca745abe51547866fa9")
- (revision "1"))
+(define-public ecl-py4cl
+ (sbcl-package->ecl-package sbcl-py4cl))
+
+(define-public sbcl-pythonic-string-reader
+ (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
(package
- (name "sbcl-routes")
- (version (git-version "0.2.5" revision commit))
+ (name "sbcl-pythonic-string-reader")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/cl-routes";)
+ (url "https://github.com/smithzvk/pythonic-string-reader/";)
(commit commit)))
- (file-name (git-file-name "cl-routes" version))
(sha256
- (base32 "1zpk3cp2v8hm50ppjl10yxr437vv4552r8hylvizglzrq2ibsbr1"))))
+ (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
+ (file-name (git-file-name "pythonic-string-reader" version))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda* (#:key inputs #:allow-other-keys)
- ;; Fix: :FORCE and :FORCE-NOT arguments not allowed in
- ;; a nested call to ASDF/OPERATE:OPERATE unless
- ;; identically to toplevel
- (substitute* "routes.asd"
- ((" :force t") "")))))))
(inputs
- `(("iterate" ,sbcl-iterate)
- ("puri" ,sbcl-puri)
- ("split-sequence" ,sbcl-split-sequence)))
- (native-inputs
- (list sbcl-lift))
- (home-page "https://github.com/archimag/cl-routes";)
- (synopsis "Rails routes system for Common Lisp")
- (description
- "This is a a Common Lisp re-implementation of the Rails routes system
-for mapping URLs.")
- (license license:llgpl))))
+ (list sbcl-named-readtables))
+ (home-page "https://github.com/smithzvk/pythonic-string-reader";)
+ (synopsis "Read table modification inspired by Python's three quote
strings")
+ (description "This piece of code sets up some reader macros that make it
+simpler to input string literals which contain backslashes and double quotes
+This is very useful for writing complicated docstrings and, as it turns out,
+writing code that contains string literals that contain code themselves.")
+ (license license:bsd-3))))
-(define-public cl-routes
- (sbcl-package->cl-source-package sbcl-routes))
+(define-public cl-pythonic-string-reader
+ (sbcl-package->cl-source-package sbcl-pythonic-string-reader))
-(define-public ecl-routes
- (sbcl-package->ecl-package sbcl-routes))
+(define-public ecl-pythonic-string-reader
+ (sbcl-package->ecl-package sbcl-pythonic-string-reader))
-(define-public sbcl-terminfo
- (let ((commit "b8b2e3ed786bfcf9f1aa4a264cee2e93135080f5")
- (revision "1"))
+(define-public sbcl-pzmq
+ (let ((commit "6f7b2ca02c23ea53510a9b0e0f181d5364ce9d32")
+ (revision "2"))
(package
- (name "sbcl-terminfo")
+ (name "sbcl-pzmq")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/npatrick04/terminfo";)
+ (url "https://github.com/orivej/pzmq";)
(commit commit)))
- (file-name (git-file-name "terminfo" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1nmin9rr6f75xdhxysba66xa1dh62fh27w9ad1cvmj0062armf6b"))))
+ (base32 "19mdhxhzzghlmff1fic4chg5iz0psglkim09z6dgpijm26biny05"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Terminfo database front end in Common Lisp")
- (home-page "https://github.com/npatrick04/terminfo";)
- (description
- "This is a terminfo database front end in Common Lisp. The package
-provides a method for determining which capabilities a terminal
-(e.g. \"xterm\") has and methods to compile or put commands to a stream.")
- (license license:expat))))
+ (native-inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("fiveam" ,sbcl-fiveam)
+ ("let-plus" ,sbcl-let-plus)))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("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-terminfo
- (sbcl-package->cl-source-package sbcl-terminfo))
+(define-public cl-pzmq
+ (sbcl-package->cl-source-package sbcl-pzmq))
-(define-public ecl-terminfo
- (sbcl-package->ecl-package sbcl-terminfo))
+(define-public ecl-pzmq
+ (sbcl-package->ecl-package sbcl-pzmq))
-(define-public sbcl-conium
- (let ((commit "089adfd8759ec7973bb6f67b98d7a246e67aeb05")
+(define-public sbcl-qbase64
+ (package
+ (name "sbcl-qbase64")
+ (version "0.3.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/chaitanyagupta/qbase64";)
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-metabang-bind sbcl-trivial-gray-streams))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/chaitanyagupta/qbase64";)
+ (synopsis "Base64 encoder and decoder for Common Lisp")
+ (description "@code{qbase64} provides a fast and flexible base64 encoder
+and decoder for Common Lisp.")
+ (license license:bsd-3)))
+
+(define-public cl-qbase64
+ (sbcl-package->cl-source-package sbcl-qbase64))
+
+(define-public ecl-qbase64
+ (sbcl-package->ecl-package sbcl-qbase64))
+
+(define-public sbcl-qmynd
+ (let ((commit "7e56daf73f0ed5f49a931c01af75fb874bcf3445")
(revision "1"))
(package
- (name "sbcl-conium")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-qmynd")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/conium";)
+ (url "https://github.com/qitab/qmynd";)
(commit commit)))
- (file-name (git-file-name "conium" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0y31za8xr8734p2pf8mrw1jd1fksh2d4y1p12wwjyn8hxxsvsx1w"))))
+ (base32
+ "06gw5wxcpdclb6a5i5k9lbmdlyqsp182czrm9bm1cpklzbj0ihrl"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-closer-mop))
- (home-page "https://github.com/sharplispers/conium";)
- (synopsis "Portability library for debugger- and compiler-related tasks")
- (description
- "Conium is a portability library for debugger- and compiler-related
-tasks in Common Lisp. It is fork of SWANK-BACKEND.")
- (license license:public-domain))))
+ (list sbcl-asdf-finalizers
+ sbcl-babel
+ sbcl-chipz
+ sbcl-cl+ssl
+ sbcl-flexi-streams
+ sbcl-ironclad
+ sbcl-salza2
+ sbcl-trivial-gray-streams
+ sbcl-usocket))
+ (home-page "https://github.com/qitab/qmynd";)
+ (synopsis "QITAB MySQL Native Driver for Common Lisp")
+ (description "QMyND, the QITAB MySQL Native Driver, is a MySQL client
+library that directly talks to a MySQL server in its native network protocol.
-(define-public cl-conium
- (sbcl-package->cl-source-package sbcl-conium))
+It's a part of QITAB umbrella project.")
+ (license license:expat))))
-(define-public ecl-conium
- (sbcl-package->ecl-package sbcl-conium))
+(define-public cl-qmynd
+ (sbcl-package->cl-source-package sbcl-qmynd))
-(define-public sbcl-terminal-size
- (let ((commit "e0b3d56a9dd3366baf2a05d84381da5747a2ef4a")
- (revision "1"))
+(define-public ecl-qmynd
+ (sbcl-package->ecl-package sbcl-qmynd))
+
+(define-public sbcl-quantile-estimator
+ (package
+ (name "sbcl-quantile-estimator")
+ (version "0.0.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/deadtrickster/quantile-estimator.cl";)
+ (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-test-systems '("quantile-estimator.test")))
+ (inputs
+ (list sbcl-alexandria))
+ (native-inputs
+ (list sbcl-mw-equiv sbcl-prove sbcl-log4cl))
+ (home-page "https://github.com/deadtrickster/quantile-estimator.cl";)
+ (synopsis
+ "Effective computation of biased quantiles over data streams")
+ (description
+ "Common Lisp implementation of Graham Cormode and S.
+Muthukrishnan's Effective Computation of Biased Quantiles over Data
+Streams in ICDE’05.")
+ (license license:expat)))
+
+(define-public cl-quantile-estimator
+ (sbcl-package->cl-source-package sbcl-quantile-estimator))
+
+(define-public ecl-quantile-estimator
+ (sbcl-package->ecl-package sbcl-quantile-estimator))
+
+(define-public sbcl-queues
+ (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
(package
- (name "sbcl-terminal-size")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-queues")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/terminal-size";)
+ (url "https://github.com/oconnore/queues";)
(commit commit)))
- (file-name (git-file-name "cl-terminal-size" version))
+ (file-name (git-file-name "queues" version))
(sha256
- (base32 "1212wbadms9jzrqgarpj3d9xh9w4dab8jhx4k2aryqgf116zs42h"))))
+ (base32
+ "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cffi sbcl-osicat))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/eudoxia0/terminal-size";)
- (synopsis "Get the size of the terminal from Common Lisp")
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ '(#:asd-systems '("queues"
+ "queues.simple-queue"
+ "queues.simple-cqueue"
+ "queues.priority-queue"
+ "queues.priority-cqueue")))
+ (home-page "https://github.com/oconnore/queues";)
+ (synopsis "Common Lisp queue library")
(description
- "This package provides the @code{terminal-size:size} function to get the
-size of the terminal from Common Lisp.")
+ "This is a simple queue library for Common Lisp with features such as
+non-consing thread safe queues and fibonacci priority queues.")
(license license:expat))))
-(define-public cl-terminal-size
- (sbcl-package->cl-source-package sbcl-terminal-size))
+(define-public cl-queues
+ (sbcl-package->cl-source-package sbcl-queues))
-(define-public ecl-terminal-size
- (sbcl-package->ecl-package sbcl-terminal-size))
+(define-public ecl-queues
+ (sbcl-package->ecl-package sbcl-queues))
-(define-public sbcl-cl-readline
- (let ((commit "8438c9ebd92ccc95ebab9cc9cbe6c72d44fccc58")
- (revision "1"))
+(define-public sbcl-quicklisp-stats
+ (let ((commit "953b45c2212ae513d48a611d3dd09c846a6102cd")
+ (revision "0"))
(package
- (name "sbcl-cl-readline")
- (version (git-version "0.1.2" revision commit))
+ (name "sbcl-quicklisp-stats")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vindarel/cl-readline";)
+ (url "https://github.com/phoe/quicklisp-stats";)
(commit commit)))
- (file-name (git-file-name "cl-readline" version))
+ (file-name (git-file-name "cl-quicklisp-stats" version))
(sha256
- (base32 "14iskvqfw71ssaav483vmqw62lrpznysjs800gjjppxs785p1fa0"))))
+ (base32 "0v8dgmlgd283n1g486q4sj2mghgdvgywg2nqp43nnrfc04mkvgc0"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("readline" ,readline)))
+ (list sbcl-alexandria
+ sbcl-drakma
+ sbcl-split-sequence))
(arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "cl-readline.lisp"
- (("libreadline.so")
- (string-append (assoc-ref inputs "readline")
- "/lib/libreadline.so"))))))))
- (home-page "https://github.com/vindarel/cl-readline";)
- (synopsis "Common Lisp bindings to the GNU Readline library")
+ `(#:tests? #f)) ; There are no tests.
+ (synopsis "Fetches and operates on Quicklisp download statistics")
(description
- "The Readline library provides a set of functions for use by
-applications that allow users to edit command lines as they are typed in.
-Both Emacs and vi editing modes are available. The Readline library includes
-additional functions to maintain a list of previously-entered command lines, to
-recall and perhaps reedit those lines, and perform csh-like history expansion
on
-previous commands.")
- (license license:gpl3+))))
+ "@code{cl-quicklisp-stats} is a system that fetches and performs basic
+operations on the Quicklisp download statistics.")
+ (home-page "https://github.com/phoe/quicklisp-stats/";)
+ (license license:expat))))
-(define-public cl-readline
- (sbcl-package->cl-source-package sbcl-cl-readline))
+(define-public cl-quicklisp-stats
+ (sbcl-package->cl-source-package sbcl-quicklisp-stats))
-(define-public ecl-cl-readline
- (sbcl-package->ecl-package sbcl-cl-readline))
+(define-public ecl-quicklisp-stats
+ (sbcl-package->ecl-package sbcl-quicklisp-stats))
-(define-public sbcl-generic-comparability
- (let ((commit "53fc2846319a6eb46b36581e203e1f1542a8acff")
- (revision "1"))
+(define-public sbcl-quickproject
+ (package
+ (name "sbcl-quickproject")
+ (version "1.4.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/quickproject";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1szs8p2wr1yr9mjmj3h3557l6wxzzga0iszimb68z0hb1jj3lva6"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("cl-fad" ,sbcl-cl-fad)
+ ("html-template" ,sbcl-html-template)))
+ (home-page "https://xach.com/lisp/quickproject/";)
+ (synopsis "Create Common Lisp project skeletons")
+ (description
+ "Quickproject provides a quick way to make a Common Lisp project. After
+creating a project, it extends the ASDF registry so the project may be
+immediately loaded.")
+ (license license:expat)))
+
+(define-public cl-quickproject
+ (sbcl-package->cl-source-package sbcl-quickproject))
+
+(define-public ecl-quickproject
+ (sbcl-package->ecl-package sbcl-quickproject))
+
+(define-public sbcl-quicksearch
+ (let ((commit "fb02ecf7c876ec580ab18c7d2c8c7814c06af599"))
(package
- (name "sbcl-generic-comparability")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-quicksearch")
+ (version (git-version "0.01.04" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pnathan/generic-comparability";)
+ (url "https://github.com/tkych/quicksearch/";)
(commit commit)))
- (file-name (git-file-name "generic-comparability" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "01ma0cwirxarwwmdwflnh8kmysmr2smh5kyvzhb2074ljxg8yq2p"))))
+ (base32 "16k19zjkhh7r64vjq371k5jwjs7cdfjz83flh561n4h4v1z89fps"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/pnathan/generic-comparability";)
- (synopsis "Implementation of cdr-8")
- (description
- "GENERIC-COMPARABILITY is an implementation of CDR-8 (Generic Equality
-and Comparison for Common Lisp). CDR-8 provides an interface for the EQUALS
-function, which is defined as a general equality predicate, as well as a set of
-ordering (COMPARE) functions for comparison. The semantics are described in
-the CDR-8 standard.")
- (license license:llgpl))))
+ (list sbcl-bordeaux-threads
+ sbcl-iterate
+ sbcl-alexandria
+ sbcl-anaphora
+ sbcl-cl-ppcre
+ sbcl-drakma
+ sbcl-html-entities
+ sbcl-yason
+ sbcl-flexi-streams
+ sbcl-do-urlencode))
+ (home-page "https://github.com/tkych/quicksearch/";)
+ (synopsis "Search Engine Interface for Common Lisp packages")
+ (description "Quicksearch is a search-engine-interface for Common Lisp.
+The goal of Quicksearch is to find the Common Lisp library quickly. For
+example, if you will find the library about json, just type @code{(qs:?
+'json)} at REPL.
-(define-public cl-generic-comparability
- (sbcl-package->cl-source-package sbcl-generic-comparability))
+The function @code{quicksearch} searches for Common Lisp projects in
+Quicklisp, Cliki, GitHub and BitBucket, then outputs results in REPL. The
+function @code{?} is abbreviation wrapper for @code{quicksearch}.")
+ (license license:expat))))
-(define-public ecl-generic-comparability
- (sbcl-package->ecl-package sbcl-generic-comparability))
+(define-public cl-quicksearch
+ (sbcl-package->cl-source-package sbcl-quicksearch))
-(define-public sbcl-cl-libyaml
- (let ((commit "a7fe9f68bddfd00b7ca467b65b3b41b276336843")
- (revision "1"))
+(define-public ecl-quicksearch
+ (sbcl-package->ecl-package sbcl-quicksearch))
+
+(define-public sbcl-quri
+ (package
+ (name "sbcl-quri")
+ (version "0.7.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/quri";)
+ (commit version)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0l1jnvvkyaxbf08lnqfdbv6lrkq02iqr3y3rwvqxm4fvnzp7mnpz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-prove))
+ (inputs (list sbcl-babel sbcl-split-sequence sbcl-cl-utilities
+ sbcl-alexandria))
+ (home-page "https://github.com/fukamachi/quri";)
+ (synopsis "Yet another URI library for Common Lisp")
+ (description
+ "QURI (pronounced \"Q-ree\") is yet another URI library for Common
+Lisp. It is intended to be a replacement of PURI.")
+ (license license:bsd-3)))
+
+(define-public cl-quri
+ (sbcl-package->cl-source-package sbcl-quri))
+
+(define-public ecl-quri
+ (sbcl-package->ecl-package sbcl-quri))
+
+(define-public sbcl-radiance
+ (let ((commit "8d826c7fe1935338565580931db43f46181e0e85")
+ (revision "3"))
(package
- (name "sbcl-cl-libyaml")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-radiance")
+ (version (git-version "2.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/cl-libyaml";)
+ (url "https://github.com/Shirakumo/radiance";)
(commit commit)))
- (file-name (git-file-name "cl-libyaml" version))
+ (file-name (git-file-name "radiance" version))
(sha256
- (base32
- "06pvmackyhq03rjmihpx6w63m6cy8wx78ll5xpwwvd85bgrqq817"))))
+ (base32 "1j823dgp87www0sjbcbv9j025bfxlkwhjd7kz6635mrqwmmlki4l"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- `(("cffi" ,sbcl-cffi)
- ("libyaml" ,libyaml)))
(arguments
- '(#:phases
+ `(#:tests? #f ; TODO: The tests require some configuration.
+ #:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/library.lisp"
- (("libyaml.so")
- (string-append (assoc-ref inputs "libyaml")
- "/lib/libyaml.so"))))))))
- (home-page "https://github.com/eudoxia0/cl-libyaml";)
- (synopsis "Libyaml bindings for Common Lisp")
+ (add-after 'unpack 'disable-quicklisp
+ (lambda _
+ ;; Disable the automatic installation of systems by Quicklisp.
+ ;; (Maybe there would be a way to package Quicklisp and make it
+ ;; install things in the user's directory instead of
+ ;; /gnu/store/...).
+ (substitute* "interfaces.lisp"
+ (("\\(unless \\(asdf:find-system configured-implementation
NIL\\)"
+ all)
+ (string-append "#+quicklisp " all))))))))
+ (native-inputs
+ (list sbcl-alexandria
+ sbcl-dexador
+ sbcl-parachute
+ sbcl-verbose))
+ (inputs
+ (list sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cl-ppcre
+ sbcl-closer-mop
+ sbcl-documentation-utils
+ sbcl-deploy
+ sbcl-form-fiddle
+ sbcl-lambda-fiddle
+ sbcl-local-time
+ sbcl-modularize-hooks
+ sbcl-modularize-interfaces
+ sbcl-puri
+ sbcl-trivial-indent
+ sbcl-trivial-mimes
+ sbcl-ubiquitous))
+ (home-page "https://shirakumo.github.io/radiance/";)
+ (synopsis "Common Lisp web application environment")
(description
- "This is a binding to the libyaml library. It's not meant as
-a full library for YAML, just a bare binding with a couple of utility macros.
-For a YAML parser and emitter using this, check out cl-yaml.")
- (license license:expat))))
+ "Radiance is a web application environment, which is sort of like a web
+framework, but more general, more flexible. It should let you write personal
+websites and generally deployable applications easily and in such a way that
+they can be used on practically any setup without having to undergo special
+adaptations.")
+ (license license:zlib))))
-(define-public cl-libyaml
- (sbcl-package->cl-source-package sbcl-cl-libyaml))
+(define-public cl-radiance
+ (sbcl-package->cl-source-package sbcl-radiance))
-(define-public ecl-cl-libyaml
- (sbcl-package->ecl-package sbcl-cl-libyaml))
+(define-public ecl-radiance
+ (sbcl-package->ecl-package sbcl-radiance))
-(define-public sbcl-cl-yaml
- (let ((commit "c3202be9a753c51f3bc79538a5a498a8865192aa")
+(define-public sbcl-radiance-contribs
+ (let ((commit "710b3e1f9971e48368d52eea0b407f2e8f510981")
(revision "1"))
(package
- (name "sbcl-cl-yaml")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-radiance-contribs")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/cl-yaml";)
+ (url "https://github.com/Shirakumo/radiance-contribs";)
(commit commit)))
- (file-name (git-file-name "cl-yaml" version))
+ (file-name (git-file-name "radiance-contribs" version))
(sha256
- (base32 "1izjg0v6rf7dh069bbnnr67l30lsqj86wdk7y9ggbgiwh6v9j185"))))
+ (base32 "08ivnd7a6vfciqna680qpx6zj6vw9xcbrzq29iz3x7x9sp1pqgq3"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; TODO: Include more contribs.
+ `(#:asd-systems '("r-clip"
+ "i-log4cl"
+ "i-sqlite"
+ "r-data-model"
+ "r-simple-rate"
+ "r-welcome")))
(inputs
- (list sbcl-alexandria sbcl-cl-libyaml sbcl-cl-ppcre
- sbcl-parse-number))
- (native-inputs
- (list sbcl-cl-fad sbcl-fiveam sbcl-generic-comparability
- sbcl-trivial-benchmark sbcl-yason))
- (home-page "https://github.com/eudoxia0/cl-yaml";)
- (synopsis "YAML parser for Common Lisp")
+ (list sbcl-radiance
+ sbcl-cffi
+ sbcl-clip
+ sbcl-cl-sqlite
+ sbcl-log4cl))
+ (home-page "https://shirakumo.github.io/radiance/";)
+ (synopsis "Standard implementations and drivers for the radiance
interfaces")
(description
- "This is a YAML parser and emitter for Common Lisp built on top of
-libyaml.")
- (license license:expat))))
+ "This is a collection of useful helper modules and standard
+implementations for Radiance interfaces.")
+ (license license:zlib))))
-(define-public cl-yaml
- (sbcl-package->cl-source-package sbcl-cl-yaml))
+(define-public cl-radiance-contribs
+ (sbcl-package->cl-source-package sbcl-radiance-contribs))
-(define-public ecl-cl-yaml
- (sbcl-package->ecl-package sbcl-cl-yaml))
+(define-public ecl-radiance-contribs
+ (sbcl-package->ecl-package sbcl-radiance-contribs))
-(define-public sbcl-clop
- (let ((commit "c0c3fe7efa5ac95ba1644febfb2c2acab757fcda")
+(define-public sbcl-random-sample
+ (let ((commit "46b70374ed796b84ea003e83c1db97b0caf97e22")
(revision "0"))
(package
- (name "sbcl-clop")
- ;; ASD file indicates 0.1.0, but changelog 1.0.1.
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-random-sample")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sheepduke/clop";)
+ (url "https://github.com/ruricolist/random-sample";)
(commit commit)))
- (file-name (git-file-name "cl-clop" version))
+ (file-name (git-file-name "cl-random-sample" version))
(sha256
- (base32 "1q7rlizr8gcbfz4a9660gdbw7d2zbld18akjpibg54j7jh5kb8gc"))))
+ (base32 "0nhgca6wf754wbg91h40gx7xq22rawg2pn6l7h02wv1jxac4q6nh"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
(inputs
(list sbcl-alexandria
- sbcl-cl-str
- sbcl-esrap
- sbcl-local-time
- sbcl-parse-number))
- (home-page "https://github.com/sheepduke/clop";)
- (synopsis "TOML parser for Common Lisp")
+ sbcl-infix-math
+ sbcl-named-readtables
+ sbcl-serapeum))
+ (home-page "https://github.com/ruricolist/random-sample";)
+ (synopsis "Take a random sample from a sequence")
(description
- "Clop is a Common Lisp library for parsing strings in the TOML
-configuration file format.")
+ "Random-Sample is a library for reliably taking a random sample from a
+sequence.")
(license license:expat))))
-(define-public cl-clop
- (sbcl-package->cl-source-package sbcl-clop))
+(define-public cl-random-sample
+ (sbcl-package->cl-source-package sbcl-random-sample))
-(define-public ecl-clop
- (sbcl-package->ecl-package sbcl-clop))
+(define-public ecl-random-sample
+ (sbcl-package->ecl-package sbcl-random-sample))
-(define-public sbcl-pp-toml
- (let ((commit "54f7d08c939d18b24363342c98c19b6812d7afb9")
- (revision "0"))
+(define-public sbcl-random-state
+ (let ((commit "c270d4f15e0b66ba9680ca8734a5de56959cb118")
+ (revision "1"))
(package
- (name "sbcl-pp-toml")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-random-state")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pnathan/pp-toml";)
+ (url "https://github.com/Shinmera/random-state";)
(commit commit)))
- (file-name (git-file-name "cl-pp-toml" version))
+ (file-name (git-file-name "cl-random-state" version))
(sha256
- (base32 "136d7jzz7l2ck9wwld0ac46jmpm94lvja6m50sy73s232slka2hg"))))
+ (base32 "0r3bk6hqpr0qmpza93pknl8wpsd6y0yy9qg7vz751a7gzzww9vj6"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
(inputs
- (list sbcl-alexandria
- sbcl-cl-ppcre
- sbcl-esrap
- sbcl-generic-comparability
- sbcl-local-time
- sbcl-parse-number
- sbcl-split-sequence))
- (home-page "https://github.com/pnathan/pp-toml";)
- (synopsis "TOML parser for Common Lisp")
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/random-state/";)
+ (synopsis "Portable random number generation")
(description
- "PP-TOML is a Common Lisp library for parsing strings in the TOML
-configuration file format. It implements only the 0.1.0 specification of
-TOML.")
- (license license:llgpl))))
+ "This library is a collection of @dfn{pseudo random number generators}.
-(define-public cl-pp-toml
- (sbcl-package->cl-source-package sbcl-pp-toml))
+While Common Lisp does provide a @code{RANDOM} function, it does not allow the
+user to pass an explicit @code{SEED}, nor to portably exchange the random
+state between implementations. This can be a headache in cases like games,
+where a controlled seeding process can be very useful.
-(define-public ecl-pp-toml
- (sbcl-package->ecl-package sbcl-pp-toml))
+For both curiosity and convenience, this library offers multiple algorithms to
+generate random numbers, as well as a bunch of generally useful methods to
+produce desired ranges.")
+ (license license:zlib))))
-(define-public sbcl-linedit
- (let ((commit "0561c97dfca2f5854fcc66558a567a9875ddcb8f")
+(define-public cl-random-state
+ (sbcl-package->cl-source-package sbcl-random-state))
+
+(define-public ecl-random-state
+ (sbcl-package->ecl-package sbcl-random-state))
+
+(define-public sbcl-re
+ (let ((commit "cfbc1f482970221e80d445080a188fd5c755cd2c")
(revision "1"))
(package
- (name "sbcl-linedit")
- (version (git-version "0.17.6" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/sharplispers/linedit";)
- (commit commit)))
- (file-name (git-file-name "cl-linedit" version))
- (sha256
- (base32 "0hhh7xn6q12rviayfihg1ym6x6csa0pdjgb88ykqbrz2rs3pgpz5"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria sbcl-cffi sbcl-osicat sbcl-terminfo))
- (home-page "https://github.com/sharplispers/linedit";)
- (synopsis "Readline-style line-editor for Common Lisp")
- (description
- "Linedit is a readline-style library written in Common Lisp that
-provides customizable line-editing for Common Lisp programs.")
- (license license:expat))))
+ (name "sbcl-re")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/massung/re";)
+ (commit commit)))
+ (file-name (git-file-name "re" version))
+ (sha256
+ (base32 "1y2gq2sckspnq8118bix55p2j43dk9qn3p8a2rplp1ip2qxqbb1i"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-parse))
+ (home-page "https://github.com/massung/re";)
+ (synopsis "Lua-style Pattern Matching for Common Lisp")
+ (description
+ "RE is a small, portable, lightweight, and quick, regular
+expression library for Common Lisp. It is a non-recursive, backtracing VM.")
+ (license license:asl2.0))))
-(define-public cl-linedit
- (sbcl-package->cl-source-package sbcl-linedit))
+(define-public cl-re
+ (sbcl-package->cl-source-package sbcl-re))
-(define-public ecl-linedit
- (sbcl-package->ecl-package sbcl-linedit))
+(define-public ecl-re
+ (sbcl-package->ecl-package sbcl-re))
-(define-public sbcl-diff
- (let ((commit "9c84befa598d4e07c3d223242b5b3f83cd94f301")
- (revision "1"))
+(define-public sbcl-reader
+ (package
+ (name "sbcl-reader")
+ (version "0.10.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/digikar99/reader";)
+ (commit (string-append "v" version))))
+ (sha256
+ (base32 "0pbv6w0d8d4qmfkdsz2rk21bp1las9r7pyvpmd95qjz7kpxrirl7"))
+ (file-name (git-file-name "cl-reader" version))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "reader.lisp"
+ (("echo")
+ (search-input-file inputs "/bin/echo"))))))))
+ (inputs
+ (list coreutils ; Needed for call to echo.
+ sbcl-alexandria
+ sbcl-fiveam ; Tests are written directly in the source files.
+ sbcl-hash-set
+ sbcl-iterate
+ sbcl-split-sequence
+ sbcl-trivial-types))
+ (synopsis "Reader macros for common objects and data structures")
+ (description "This package provides a utility library intended
+at providing configurable reader macros for common tasks such as
+accessors, hash-tables, sets, uiop:run-program, arrays and a few others.")
+ (home-page "https://github.com/digikar99/reader/";)
+ (license license:expat)))
+
+(define-public cl-reader
+ (sbcl-package->cl-source-package sbcl-reader))
+
+(define-public ecl-reader
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-reader))
+ (arguments
+ ;; TODO: Tests fail on call to coreutils echo for ecl.
+ `(#:tests? #f))))
+
+(define-public sbcl-regex
+ (let ((commit "fbc9a9f313b9edc1788f33d4b23a29151635ae22"))
(package
- (name "sbcl-diff")
- (version (git-version "0.4" revision commit))
+ (name "sbcl-regex")
+ (version (git-version "1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/froydnj/diff";)
+ (url "https://github.com/michaelw/regex/";)
(commit commit)))
- (file-name (git-file-name "cl-diff" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1giafck8qfvb688kx5bn9g32rfc12jjywg8vdav36aqbd6lxf5z5"))))
+ (base32 "0wq5wlafrxv13wg28hg5b10sc48b88swsvznpy2zg7x37m4nmm6a"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-ppcre sbcl-trivial-gray-streams))
- (home-page "https://github.com/froydnj/diff";)
- (synopsis "Common Lisp library for computing differences between files")
+ (home-page "https://github.com/michaelw/regex/";)
+ (synopsis "Regular expression engine for Common Lisp")
(description
- "DIFF is a package for computing various forms of differences between
-blobs of data and then doing neat things with those differences. Currently
diff
-knows how to compute three common forms of differences: \"unified\" format
-diffs, \"context\" format diffs, and \"vdelta\" format binary diffs.")
- (license license:bsd-3))))
+ "This Common Lisp package provides a regular expression engine.")
+ (license license:bsd-2))))
-(define-public cl-diff
- (sbcl-package->cl-source-package sbcl-diff))
+(define-public cl-regex
+ (sbcl-package->cl-source-package sbcl-regex))
-(define-public ecl-diff
- (sbcl-package->ecl-package sbcl-diff))
+(define-public ecl-regex
+ (sbcl-package->ecl-package sbcl-regex))
-(define-public sbcl-montezuma
- (let ((commit "ee2129eece7065760de4ebbaeffaadcb27644738")
- (revision "1"))
+(define-public sbcl-repl-utilities
+ (let ((commit "7e300df663177ea4581f4e7e9c601377881dd986"))
(package
- (name "sbcl-montezuma")
- (version (git-version "0.1.3" revision commit))
+ (name "sbcl-repl-utilities")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/montezuma";)
+ (url "https://github.com/m-n/repl-utilities/";)
(commit commit)))
- (file-name (git-file-name "cl-montezuma" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0svmvsbsirydk3c1spzfvj8qmkzcs9i69anpfvk1843i62wb7x2c"))))
+ (base32 "1hh56pq5nw3l4b83dzlyss69f06r038byj2cnjwvci4hfjhdfcc3"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- ;; The _darcs directory contains a second copy of
- ;; montezuma-indexfiles.asd. Remove the directory to
- ;; prevent build failure caused by .asd files that have
- ;; the same filename.
- (add-after 'unpack 'remove-darcs-directory
- (lambda _
- (delete-file-recursively
- "contrib/montezuma-indexfiles/_darcs")))
- ;; Tests fail with: :FORCE and :FORCE-NOT arguments not
- ;; allowed in a nested call to ASDF/OPERATE:OPERATE unless
- ;; identically to toplevel.
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "montezuma.asd"
- ((":force t") "")))))))
- (inputs
- `(("babel" ,sbcl-babel)
- ("cl-fad" ,sbcl-cl-fad)
- ("cl-ppcre" ,sbcl-cl-ppcre)))
- (native-inputs
- (list sbcl-trivial-timeout))
- (home-page "https://github.com/sharplispers/montezuma";)
- (synopsis "Full-text indexing and search for Common Lisp")
+ (home-page "https://github.com/m-n/repl-utilities";)
+ (synopsis "Ease common tasks at the Common Lisp REPL")
(description
- "Montezuma is a text search engine library for Lisp based on the Ferret
-library for Ruby, which is itself based on the Lucene library for Java.")
- (license (list license:expat ; montezuma
- license:gpl3+))))) ; contrib/montezuma-indexfiles
+ "@code{repl-utilities} is a set of utilities which ease life at the
+REPL. It includes three sorts of features: introspective procedures,
+miscellaneous utility functions, and, pulling them together, methods to
+conveniently keep these symbols and optionally additional symbols available in
+whichever package you switch to.")
+ (license license:bsd-2))))
-(define-public cl-montezuma
- (sbcl-package->cl-source-package sbcl-montezuma))
+(define-public cl-repl-utilities
+ (sbcl-package->cl-source-package sbcl-repl-utilities))
-(define-public ecl-montezuma
- (let ((pkg (sbcl-package->ecl-package sbcl-montezuma)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; Tests fail with "Pathname without a physical namestring" error
- ;; on ECL.
- ((#:tests? _ #f) #f))))))
+(define-public ecl-repl-utilities
+ (sbcl-package->ecl-package sbcl-repl-utilities))
-(define-public sbcl-cl-charms
- (let ((commit "64aba59d89f85bc5c9402e445873965338a66a02")
+(define-public sbcl-restas
+ (let ((commit "81bbbab6b36f81f846f78e71232e9d3d15f6d952")
(revision "1"))
(package
- (name "sbcl-cl-charms")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-restas")
+ (version (git-version "0.1.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/HiTECNOLOGYs/cl-charms";)
+ (url "https://github.com/archimag/restas";)
(commit commit)))
- (file-name (git-file-name "cl-charms" version))
+ (file-name (git-file-name "cl-restas" version))
(sha256
- (base32 "1jczaypa9dhxr34yyhsxb6lrdnircjx8am4iqkc3shfpjn32q323"))))
+ (base32 "00ng6jik1lwjw3bbxhijy8s0ml24lgm73liwrr01gcsb0r6wrjjn"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("ncurses" ,ncurses)))
(arguments
'(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/low-level/curses-bindings.lisp"
- (("libncursesw.so")
- (string-append (assoc-ref inputs "ncurses")
- "/lib/libncursesw.so"))))))))
- (home-page "https://github.com/HiTECNOLOGYs/cl-charms";)
- (synopsis "Interface to libcurses in Common Lisp")
- (description
- "@code{cl-charms} is an interface to libcurses in Common Lisp. It
-provides both a raw, low-level interface to libcurses via CFFI, and a more
-higher-level lispier interface.")
- (license license:expat))))
+ (substitute* "contrib/restas-daemon.lisp"
+ (("/lib64/") "")
+ (("/lib/") "")
+ (("libcap.so")
+ (string-append (assoc-ref inputs "libcap")
+ "/lib/libcap.so"))))))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("data-sift" ,sbcl-data-sift)
+ ("hunchentoot" ,sbcl-hunchentoot)
+ ("libcap" ,libcap)
+ ("routes" ,sbcl-routes)))
+ (home-page "https://github.com/archimag/restas";)
+ (synopsis "Common Lisp web framework")
+ (description "@code{RESTAS} is a Common Lisp web application framework.")
+ (license license:llgpl))))
-(define-public cl-charms
- (sbcl-package->cl-source-package sbcl-cl-charms))
+(define-public cl-restas
+ (sbcl-package->cl-source-package sbcl-restas))
-(define-public ecl-cl-charms
- (sbcl-package->ecl-package sbcl-cl-charms))
+(define-public ecl-restas
+ (sbcl-package->ecl-package sbcl-restas))
-(define-public sbcl-trivial-open-browser
- (let ((commit "7ab4743dea9d592639f15c565bfa0756e828c427")
+(define-public sbcl-retrospectiff
+ (let ((commit "2fbf8c687799487654d988c7036d19d75a7fc67d")
(revision "1"))
(package
- (name "sbcl-trivial-open-browser")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-retrospectiff")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/trivial-open-browser";)
+ (url "https://github.com/slyrus/retrospectiff";)
(commit commit)))
- (file-name (git-file-name "cl-trivial-open-browser" version))
+ (file-name (git-file-name "cl-retrospectiff" version))
(sha256
- (base32 "0ixay1piq420i6adx642qhw45l6ik7rvgk52lyz27dvx5f8yqsdb"))))
+ (base32 "1vfcbfzhkm2wkxnjg7y6gg93wlib9cqpbdbhyqcm5kc7170ci3vz"))))
(build-system asdf-build-system/sbcl)
- (inputs (list xdg-utils))
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/trivial-open-browser.lisp"
- (("xdg-open")
- (search-input-file inputs "/bin/xdg-open"))))))))
- (home-page "https://github.com/eudoxia0/trivial-open-browser";)
- (synopsis "Open a browser window from Common Lisp")
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-cl-jpeg
+ sbcl-com.gigamonkeys.binary-data
+ sbcl-deflate
+ sbcl-flexi-streams
+ sbcl-ieee-floats
+ sbcl-opticl-core))
+ (home-page "https://github.com/slyrus/retrospectiff";)
+ (synopsis "Common Lisp library for TIFF images")
(description
- "This package provides a library to open a web browser to a URL.")
- (license license:expat))))
+ "Retrospectiff is a common lisp library for reading and writing images
+in the TIFF (Tagged Image File Format) format.")
+ (license license:bsd-2))))
-(define-public cl-trivial-open-browser
- (sbcl-package->cl-source-package sbcl-trivial-open-browser))
+(define-public cl-retrospectif
+ (sbcl-package->cl-source-package sbcl-retrospectiff))
-(define-public ecl-trivial-open-browser
- (sbcl-package->ecl-package sbcl-trivial-open-browser))
+(define-public ecl-retrospectiff
+ (sbcl-package->ecl-package sbcl-retrospectiff))
-(define-public sbcl-clinenoise
- (let ((commit "46e21f99d06a55d93eaa382cf652d55d457032ef")
+(define-public sbcl-rfc2388
+ (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
(revision "1"))
(package
- (name "sbcl-clinenoise")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-rfc2388")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/jdz/rfc2388";)
+ (commit commit)))
+ (file-name (git-file-name "rfc2388" version))
+ (sha256
+ (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/jdz/rfc2388/";)
+ (synopsis "Implementation of RFC 2388 in Common Lisp")
+ (description
+ "This package contains an implementation of RFC 2388, which is used to
+process form data posted with HTTP POST method using enctype
+\"multipart/form-data\".")
+ (license license:bsd-2))))
+
+(define-public cl-rfc2388
+ (sbcl-package->cl-source-package sbcl-rfc2388))
+
+(define-public ecl-rfc2388
+ (sbcl-package->ecl-package sbcl-rfc2388))
+
+(define-public sbcl-routes
+ (let ((commit "1b79e85aa653e1ec87e21ca745abe51547866fa9")
+ (revision "1"))
+ (package
+ (name "sbcl-routes")
+ (version (git-version "0.2.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jasom/clinenoise";)
+ (url "https://github.com/archimag/cl-routes";)
(commit commit)))
- (file-name (git-file-name "clinenoise" version))
+ (file-name (git-file-name "cl-routes" version))
(sha256
- (base32 "0ydlirfk4dbpqqjwwph99v5swcrhd8v9g8q24fvs35wn2vm08lh1"))))
+ (base32 "1zpk3cp2v8hm50ppjl10yxr437vv4552r8hylvizglzrq2ibsbr1"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda* (#:key inputs #:allow-other-keys)
+ ;; Fix: :FORCE and :FORCE-NOT arguments not allowed in
+ ;; a nested call to ASDF/OPERATE:OPERATE unless
+ ;; identically to toplevel
+ (substitute* "routes.asd"
+ ((" :force t") "")))))))
(inputs
- (list sbcl-alexandria sbcl-cffi sbcl-split-sequence))
- (home-page "https://github.com/jasom/clinenoise";)
- (synopsis "Port of linenoise to Common Lisp")
+ `(("iterate" ,sbcl-iterate)
+ ("puri" ,sbcl-puri)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (native-inputs
+ (list sbcl-lift))
+ (home-page "https://github.com/archimag/cl-routes";)
+ (synopsis "Rails routes system for Common Lisp")
(description
- "This package provides a trivial line-input library for VT-like
-terminals.")
- (license license:bsd-2))))
+ "This is a a Common Lisp re-implementation of the Rails routes system
+for mapping URLs.")
+ (license license:llgpl))))
-(define-public cl-clinenoise
- (sbcl-package->cl-source-package sbcl-clinenoise))
+(define-public cl-routes
+ (sbcl-package->cl-source-package sbcl-routes))
-(define-public ecl-clinenoise
- (sbcl-package->ecl-package sbcl-clinenoise))
+(define-public ecl-routes
+ (sbcl-package->ecl-package sbcl-routes))
-(define-public sbcl-trivial-raw-io
- (let ((commit "b1a3c876305baa0dead419841de7b3e433a75867")
- (revision "1"))
+(define-public sbcl-rss
+ ;; No release.
+ (let ((commit "51d0145e91b86327ae5c36364f9c3048052e7a58"))
(package
- (name "sbcl-trivial-raw-io")
- (version (git-version "0.0.2" revision commit))
+ (name "sbcl-rss")
+ (version (git-version "0.9.1.1" "2" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/kingcons/trivial-raw-io";)
+ (url "http://git.kpe.io/cl-rss.git";)
(commit commit)))
- (file-name (git-file-name "trivial-raw-io" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "19290zw2b64k78wr62gv30pp7cmqg07q85vfwjknaffjdd73xwi1"))))
+ (base32 "0wv3j13fj73gigriw5r9vi920hz05ld7zllsvbxdxvmyfy9k1kly"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The useless bundled debian folder drags `make' into the closure.
+ `(begin
+ (delete-file-recursively "debian")
+ #t))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/kingcons/trivial-raw-io";)
- (synopsis "Trivial portability for raw *nix IO in Common Lisp")
+ (list sbcl-aserve sbcl-kmrcl sbcl-xmls))
+ (home-page "https://github.com/nsrahmad/cl-rss";)
+ (synopsis "Common Lisp RSS processor")
(description
- "This library exports three symbols: @code{with-raw-io},
-@code{read-char}, and @code{read-line}, to provide raw POSIX I/O in Common
-Lisp.")
- (license license:bsd-2))))
-
-(define-public cl-trivial-raw-io
- (sbcl-package->cl-source-package sbcl-trivial-raw-io))
+ "This package provides a Common Lisp library for fetching and parsing
+RSS feeds data via HTTP. Currently, it supports RSS versions 0.90,
+0.91, and 0.92 as well as RSS version 2.")
+ (license license:bsd-3))))
-(define-public ecl-trivial-raw-io
- (sbcl-package->ecl-package sbcl-trivial-raw-io))
+(define-public cl-rss
+ (sbcl-package->cl-source-package sbcl-rss))
-(define-public sbcl-terminal-keypress
- (let ((commit "2ef48c045aa627229764b2aa393a83d392d93d08")
+(define-public sbcl-rtg-math
+ (let ((commit "29fc5b3d0028a4a11a82355ecc8cca62662c69e0")
(revision "1"))
(package
- (name "sbcl-terminal-keypress")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-rtg-math")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/terminal-keypress";)
+ (url "https://github.com/cbaggers/rtg-math";)
(commit commit)))
- (file-name (git-file-name "cl-terminal-keypress" version))
+ (file-name (git-file-name "rtg-math" version))
(sha256
- (base32 "11c4krpq5x55qkchx6ykcnb455ssb4r3jjywx3c3irfrkj733ybp"))))
+ (base32 "0bhxxnv7ldkkb18zdxyz2rj2a3iawzq2kcp7cn5i91iby7n0082x"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-trivial-raw-io))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/eudoxia0/terminal-keypress";)
- (synopsis "Read keyboard events in the terminal from Common Lisp")
+ (list sbcl-alexandria sbcl-documentation-utils sbcl-glsl-spec))
+ (home-page "https://github.com/cbaggers/rtg-math";)
+ (synopsis "Common Lisp library of game-related math functions")
(description
- "This is a library for reading semi-raw user input from terminals.
-Semi-raw as in, we can't detect if the user pressed the @code{Control} key
-alone, and the function keys are a mystery. What is supported, however, is:
-
-@itemize
-@item Regular characters
-@item Control+[key]
-@item Alt+[key]
-@item Control+Alt+[key]
-@end itemize")
- (license license:expat))))
-
-(define-public cl-terminal-keypress
- (sbcl-package->cl-source-package sbcl-terminal-keypress))
-
-(define-public ecl-terminal-keypress
- (sbcl-package->ecl-package sbcl-terminal-keypress))
-
-(define-public sbcl-periodic-table
- (package
- (name "sbcl-periodic-table")
- (version "1.0")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://common-lisp.net/project/chemboy/periodic-table-";
- version ".tar.gz"))
- (sha256
- (base32 "1ircvqm3q93ma4rxbxprb1i9rcax10ld6xmdzdhfnigr27sh5jvg"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://common-lisp.net/project/chemboy/";)
- (synopsis "Periodic table for Common Lisp")
- (description
- "This package defines a Common Lisp package, @code{:elements}, with an
-@code{ELEMENT} structure and a number of functions to search the periodic
-table.")
- (license license:llgpl)))
-
-(define-public cl-periodic-table
- (sbcl-package->cl-source-package sbcl-periodic-table))
-
-(define-public ecl-periodic-table
- (sbcl-package->ecl-package sbcl-periodic-table))
-
-(define-public sbcl-chemical-compounds
- (package
- (name "sbcl-chemical-compounds")
- (version "1.0.2")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://common-lisp.net/project/chemboy/chemical-compounds-";
- version ".tar.gz"))
- (sha256
- (base32 "12fd8a6ay5qlsq4givzgh9d55mbg4ci2vvmymig6pjl2ms64v0pf"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("periodic-table" ,sbcl-periodic-table)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-files
- (lambda _
- ;; Fix incorrect version number.
- (substitute* "chemical-compounds.asd"
- ((":version \"1.0.1\"")
- (string-append ":version \"" ,version "\"")))
- ;; Remove incorrect declaration of string type.
- (substitute* "parsing.lisp"
- (("\\(declare \\(simple-base-string string\\)")
- "(declare")))))))
- (home-page "https://common-lisp.net/project/chemboy/";)
- (synopsis "Chemical formula parser and pretty-printer for Common Lisp")
- (description
- "It can sometimes be useful to be able to parse chemical compounds in a
-user-friendly syntax into easy-to-manipulate s-expressions. You also want to
-be able to go in reverse. You could probably write your own parser — or you
-could just install the chemical-compounds package.")
- (license license:llgpl)))
-
-(define-public cl-chemical-compounds
- (sbcl-package->cl-source-package sbcl-chemical-compounds))
-
-(define-public ecl-chemical-compounds
- (sbcl-package->ecl-package sbcl-chemical-compounds))
-
-(define-public sbcl-chemboy
- (package
- (name "sbcl-chemboy")
- (version "0.3")
- (source
- (origin
- (method url-fetch)
- (uri (string-append
- "https://common-lisp.net/project/chemboy/chemboy-";
- version ".tar.gz"))
- (sha256
- (base32 "0lr134l16mjcgdj3fm2yff4chlfbihn1sji7q80y7lnr176zgs7d"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("chemical-compounds" ,sbcl-chemical-compounds)
- ("periodic-table" ,sbcl-periodic-table)))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-files
- (lambda _
- ;; Fix incorrect version number.
- (substitute* "chemboy.asd"
- ((":version \"0.2\"")
- (string-append ":version \"" ,version "\"")))
- ;; Remove incorrect declaration of string type.
- (substitute* "query-parsing.lisp"
- (("\\(declare \\(simple-base-string string\\)")
- "(declare"))
- ;; Fix incorrect function calls.
- (substitute* "conversions.lisp"
- (("\\(pprint-compound element s\\)")
- "(pprint-compound element :stream s)")
- (("\\(pprint-compound parsed-compound s\\)")
- "(pprint-compound parsed-compound :stream s)")))))))
- (home-page "https://common-lisp.net/project/chemboy/";)
- (synopsis "Common Lisp program for doing basic chemistry calculations")
- (description
- "Chemboy is a Common Lisp program for doing basic chemistry calculations.
-This package provides the text-based interface for Chemboy.")
- (license license:llgpl)))
+ "RTG-MATH provides a selection of the math routines most commonly needed
+for making realtime graphics in Lisp.")
+ (license license:bsd-2))))
-(define-public cl-chemboy
- (sbcl-package->cl-source-package sbcl-chemboy))
+(define-public cl-rtg-math
+ (sbcl-package->cl-source-package sbcl-rtg-math))
-(define-public ecl-chemboy
- (sbcl-package->ecl-package sbcl-chemboy))
+(define-public ecl-rtg-math
+ (sbcl-package->ecl-package sbcl-rtg-math))
-(define-public sbcl-chlorophyll
- (let ((commit "f2a50ad36d2fb11823c0e5a8da08a0de89c5c35f")
- (revision "1"))
+(define-public sbcl-rucksack
+ (let ((commit "89278f88513ef328d290aa8b2baa06d63b44a9b1")
+ (revision "0"))
(package
- (name "sbcl-chlorophyll")
- (version (git-version "0.0.1" revision commit))
- (source
+ (name "sbcl-rucksack")
+ (version (git-version "0.1.20" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/gorozhin/chlorophyll";)
+ (url "https://github.com/arieltan/rucksack";)
(commit commit)))
- (file-name (git-file-name "cl-chlorophyll" version))
+ (file-name (git-file-name "cl-rucksack" version))
(sha256
- (base32 "1hgl8sjsmyqx4gs77q4p94b63zgpxk1wi9w9niki8j0213dr1s3y"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (inputs (list sbcl-alexandria))
- (home-page "https://github.com/gorozhin/chlorophyll";)
- (synopsis "ANSI escape code library for Common Lisp")
- (description
- "This package provides a Common Lisp system CHLOROPHYLL which
-implements an ANSI escape code functionality.")
- (license license:expat))))
-
-(define-public cl-chlorophyll
- (sbcl-package->cl-source-package sbcl-chlorophyll))
+ (base32 "0acpsxaxpp90km7gdbn9sysilycp3yg1g040fg1vqakpj2yb8vad"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Flexible, light weight, persistence library")
+ (description
+ "@code{cl-rucksack} is a persistence library based on Arthur Lemmens'
+Rucksack with some enhancements.")
+ (home-page "https://github.com/arieltan/rucksack/";)
+ (license license:expat))))
-(define-public ecl-chlorophyll
- (sbcl-package->ecl-package sbcl-chlorophyll))
+(define-public cl-rucksack
+ (sbcl-package->cl-source-package sbcl-rucksack))
-(define-public sbcl-cl-pass
- (let ((commit "e58e97c0c0588dc742c061208afb9bc31e4dbd34")
- (revision "1"))
+(define-public sbcl-rutils
+ (let ((commit "db3c3f4ae897025b5f0cd81042ca147da60ca0c5")
+ (revision "0"))
(package
- (name "sbcl-cl-pass")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-rutils")
+ (version (git-version "5.2.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/cl-pass";)
+ (url "https://github.com/vseloved/rutils";)
(commit commit)))
- (file-name (git-file-name "cl-pass" version))
+ (file-name (git-file-name "rutils" version))
(sha256
- (base32 "05qx4jrkxqbqi72cxgswbpnifbdvp9mh7apc7566v522899bh0hb"))))
+ (base32 "1d2whscknh1zga2vdqvfqri8wx0gnml3sfqz62igq0ppap6q07y3"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("rutils" "rutilsx")
+ ;; Tests disabled because of a circular dependency with should-test.
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ ;; File faild to load, and we don't use it as tests are
+ ;; disabled, so let's delete it.
+ (delete-file "rutilsx-test.asd"))))))
(inputs
- (list sbcl-ironclad sbcl-trivial-utf-8 sbcl-split-sequence))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/eudoxia0/cl-pass";)
- (synopsis "Password hashing and verification library")
- (description
- "@code{cl-pass} is a password hashing and verification library.")
- (license license:expat))))
+ `(("closer-mop" ,sbcl-closer-mop)
+ ("named-readtables" ,sbcl-named-readtables)))
+ (home-page "https://github.com/vseloved/rutils";)
+ (synopsis "Radical Utilities for Common Lisp")
+ (description "RUTILS is a syntactic utilities package for Common Lisp.")
+ (license license:bsd-3))))
-(define-public cl-pass
- (sbcl-package->cl-source-package sbcl-cl-pass))
+(define-public cl-rutils
+ (sbcl-package->cl-source-package sbcl-rutils))
-(define-public ecl-cl-pass
- (sbcl-package->ecl-package sbcl-cl-pass))
+(define-public ecl-rutils
+ (sbcl-package->ecl-package sbcl-rutils))
-(define-public sbcl-which
- (let ((commit "b2333e4fcacab6e5d85eecd28b5ef4944bda1448")
- (revision "1"))
+(define-public sbcl-s-sysdeps
+ ;; No release since 2013.
+ (let ((commit "7f8de283b7fbd8b038fdf08493063a736db36ce7")
+ (revision "3"))
(package
- (name "sbcl-which")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-s-sysdeps")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "1" revision commit))
+ (home-page "https://github.com/svenvc/s-sysdeps";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/which";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-which" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "127pm9h4rm4w9aadw5yvamnfzhk2rr69kchx10rf9k7sk7izqqfk"))))
- (build-system asdf-build-system/sbcl)
+ (base32
+ "0rp81iq0rgl48qdwbmfy89glga81hmry2lp8adjbr5h5ybr92b4n"))))
(inputs
- (list sbcl-cl-fad sbcl-path-parse))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/eudoxia0/which";)
- (synopsis "The which command in Common Lisp")
- (description
- "This package provides an implementation of the @code{which} UNIX
-command in Common Lisp.")
- (license license:expat))))
+ (list sbcl-bordeaux-threads sbcl-usocket))
+ (synopsis "Common Lisp abstraction layer over platform dependent
functionality")
+ (description "@code{s-sysdeps} is an abstraction layer over platform
+dependent functionality. This simple package is used as a building block in a
+number of other projects.
-(define-public cl-which
- (sbcl-package->cl-source-package sbcl-which))
+@code{s-sysdeps} abstracts:
-(define-public ecl-which
- (sbcl-package->ecl-package sbcl-which))
+@itemize
+@item managing processes,
+@item implementing a standard TCP/IP server,
+@item opening a client TCP/IP socket stream,
+@item working with process locks.
+@end itemize\n")
+ (license license:llgpl))))
-(define-public sbcl-wu-decimal
- (let ((commit "5b348bdb32a0f83e80e17aa68cd51787ae8c8a45")
+(define-public cl-s-sysdeps
+ (sbcl-package->cl-source-package sbcl-s-sysdeps))
+
+(define-public ecl-s-sysdeps
+ (sbcl-package->ecl-package sbcl-s-sysdeps))
+
+(define-public sbcl-s-xml
+ (package
+ (name "sbcl-s-xml")
+ (version "3")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml/s-xml.tgz";)
+ (sha256
+ (base32
+ "061qcr0dzshsa38s5ma4ay924cwak2nq9gy59dw6v9p0qb58nzjf"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://common-lisp.net/project/s-xml/";)
+ (synopsis "Simple XML parser implemented in Common Lisp")
+ (description
+ "S-XML is a simple XML parser implemented in Common Lisp. This XML
+parser implementation has the following features:
+
+@itemize
+@item It works (handling many common XML usages).
+@item It is very small (the core is about 700 lines of code, including
+comments and whitespace).
+@item It has a core API that is simple, efficient and pure functional, much
+like that from SSAX (see also http://ssax.sourceforge.net).
+@item It supports different DOM models: an XSML-based one, an LXML-based one
+and a classic xml-element struct based one.
+@item It is reasonably time and space efficient (internally avoiding garbage
+generatation as much as possible).
+@item It does support CDATA.
+@item It should support the same character sets as your Common Lisp
+implementation.
+@item It does support XML name spaces.
+@end itemize
+
+This XML parser implementation has the following limitations:
+
+@itemize
+@item It does not support any special tags (like processing instructions).
+@item It is not validating, even skips DTD's all together.
+@end itemize\n")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml
+ (sbcl-package->cl-source-package sbcl-s-xml))
+
+(define-public ecl-s-xml
+ (sbcl-package->ecl-package sbcl-s-xml))
+
+(define-public sbcl-s-xml-rpc
+ (package
+ (name "sbcl-s-xml-rpc")
+ (version "7")
+ (source
+ (origin
+ (method url-fetch)
+ (uri "https://common-lisp.net/project/s-xml-rpc/s-xml-rpc.tgz";)
+ (sha256
+ (base32
+ "02z7k163d51v0pzk8mn1xb6h5s6x64gjqkslhwm3a5x26k2gfs11"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-s-xml))
+ (home-page "https://common-lisp.net/project/s-xml-rpc/";)
+ (synopsis "Implementation of XML-RPC in Common Lisp for both client and
server")
+ (description
+ "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both
+client and server.")
+ (license license:lgpl3+)))
+
+(define-public cl-s-xml-rpc
+ (sbcl-package->cl-source-package sbcl-s-xml-rpc))
+
+(define-public ecl-s-xml-rpc
+ (sbcl-package->ecl-package sbcl-s-xml-rpc))
+
+(define-public sbcl-safe-read
+ (let ((commit "d25f08597b34d7aaeb86b045d57f7b020a5bb5f0")
(revision "0"))
(package
- (name "sbcl-wu-decimal")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-safe-read")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Wukix/wu-decimal";)
+ (url "https://github.com/phoe/safe-read";)
(commit commit)))
- (file-name (git-file-name "cl-wu-decimal" version))
+ (file-name (git-file-name "cl-safe-read" version))
(sha256
- (base32 "1p7na4hic7297amwm4idfwkyx664ny8cdssncyra37pmv4wzp8dm"))))
+ (base32 "1r9k8danfnqgpbn2vb90n6wdc6jd92h1ig565yplrbh6232lhi26"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/Wukix/wu-decimal";)
- (synopsis "Arbitrary-precision decimal arithmetic")
+ (inputs
+ (list sbcl-local-time sbcl-trivial-garbage))
+ (home-page "https://github.com/phoe/safe-read/";)
+ (synopsis "Safer variant of READ")
(description
- "Wu-Decimal enables convenient, arbitrary-precision decimal arithmetic
-through a reader macro, @code{#$}, and an update to the @code{pprint} dispatch
-table. Wu-Decimal uses the CL rational type to store decimals, which enables
-numeric functions such as @code{+}, @code{-}, etc., to operate on decimal
-numbers in a natural way.")
+ "This package provides a safer variant of @code{READ} secure against
+internbombing, excessive input and macro characters.")
(license license:bsd-2))))
-(define-public cl-wu-decimal
- (sbcl-package->cl-source-package sbcl-wu-decimal))
+(define-public cl-safe-read
+ (sbcl-package->cl-source-package sbcl-safe-read))
-(define-public ecl-wu-decimal
- (sbcl-package->ecl-package sbcl-wu-decimal))
+(define-public ecl-safe-read
+ (sbcl-package->ecl-package sbcl-safe-read))
-(define-public sbcl-infix-math
- (let ((commit "f5155ae9709e518061ace79887d78f8e79c61cac")
- (revision "0"))
+(define-public sbcl-salza2
+ (package
+ (name "sbcl-salza2")
+ (version "2.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/salza2";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1p48lxdibnps5rpyh5cmnk0vc77bmmxb32qdzfz93zadr8wwas10"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-chipz sbcl-flexi-streams sbcl-parachute))
+ (inputs
+ (list sbcl-trivial-gray-streams))
+ (synopsis "Common Lisp library for zlib, deflate and gzip compression")
+ (description
+ "Salza2 is a Common Lisp library for creating compressed data in the zlib,
+deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952,
+respectively.")
+ (home-page "https://www.xach.com/lisp/salza2/";)
+ (license license:bsd-2)))
+
+(define-public cl-salza2
+ (sbcl-package->cl-source-package sbcl-salza2))
+
+(define-public ecl-salza2
+ (sbcl-package->ecl-package sbcl-salza2))
+
+(define-public sbcl-sb-cga
+ (let ((commit "9a554ea1c01cac998ff7eaa5f767bc5bcdc4c094"))
(package
- (name "sbcl-infix-math")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-sb-cga")
+ (version (git-version "1.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/infix-math";)
+ (url "https://github.com/nikodemus/sb-cga/";)
(commit commit)))
- (file-name (git-file-name "cl-infix-math" version))
+ (file-name (git-file-name "cl-sb-cga" version))
(sha256
- (base32 "1h6p254xl793wfq3qla5y95k6zimy477f8brblx6ran3rg3bydbg"))))
+ (base32 "1y54qlwfrhch9aghk7nsbdx7x2qsvgsws1g2k631l9dsgdakw4w8"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-parse-number sbcl-serapeum sbcl-wu-decimal))
- (home-page "https://github.com/ruricolist/infix-math";)
- (synopsis "Extensible infix syntax for math in Common Lisp")
+ (list sbcl-alexandria))
+ (home-page "https://github.com/nikodemus/sb-cga/";)
+ (synopsis "Computer graphic algebra for Common Lisp")
(description
- "Infix-Math is a library that provides a special-purpose syntax for
-transcribing mathematical formulas into Lisp.")
+ "SB-CGA is a computer graphics algebra library for Common Lisp.
+
+Despite the prefix it is actually portable - but optimizations that make it
+fast (using SIMD instructions) are currently implemented for SBCL/x86-64
+only.")
(license license:expat))))
-(define-public cl-infix-math
- (sbcl-package->cl-source-package sbcl-infix-math))
+(define-public cl-sb-cga
+ (sbcl-package->cl-source-package sbcl-sb-cga))
-(define-public ecl-infix-math
- (sbcl-package->ecl-package sbcl-infix-math))
+(define-public ecl-sb-cga
+ (sbcl-package->ecl-package sbcl-sb-cga))
-(define-public sbcl-cl-num-utils
- (let ((commit "97a88cd34540acf52e872a82ebfef3da0a34fa12")
+(define-public sbcl-schemeish
+ (let ((commit "dff57bafae5d0cffa104c8fdc4146502f32d7f85")
(revision "1"))
(package
- (name "sbcl-cl-num-utils")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-schemeish")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tpapp/cl-num-utils";)
+ (url "https://github.com/chebert/schemeish";)
(commit commit)))
- (file-name (git-file-name "cl-num-utils" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "15ihsxxs76xnldmqfsbxybckqjwrxwcpphgghiwzr2mnbqjpdqkh"))))
+ (base32 "0q9b07spmhg1b576cnnacvkf7zr3mab2rdydfylbn92y9mms9vyj"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-anaphora sbcl-alexandria sbcl-array-operations
- sbcl-cl-slice sbcl-let-plus))
- (native-inputs
- (list sbcl-clunit))
- (home-page "https://github.com/tpapp/cl-num-utils";)
- (synopsis "Numerical utilities for Common Lisp")
+ (list sbcl-trivial-arguments))
+ (synopsis "Scheme style syntax/macros/functions for Common Lisp")
(description
- "@code{cl-num-utils} implements simple numerical functions for Common
-Lisp, including:
-@itemize
-@item @code{num=}, a comparison operator for floats
-@item simple arithmeric functions, like @code{sum} and @code{l2norm}
-@item elementwise operations for arrays
-@item intervals
-@item special matrices and shorthand for their input
-@item sample statistics
-@item Chebyshev polynomials
-@item univariate rootfinding
-@end itemize")
- (license license:boost1.0))))
+ "Schemeish implements several useful Scheme constructs for Common Lisp.
+These include named-let, define, scheme argument lists, and a shortcut to
+FUNCALL with [] instead of ().")
+ (home-page "https://github.com/chebert/schemeish";)
+ ;; MIT License
+ (license license:expat))))
-(define-public cl-num-utils
- (sbcl-package->cl-source-package sbcl-cl-num-utils))
+(define-public cl-schemeish
+ (sbcl-package->cl-source-package sbcl-schemeish))
-(define-public ecl-cl-num-utils
- (sbcl-package->ecl-package sbcl-cl-num-utils))
+(define-public ecl-schemeish
+ (sbcl-package->ecl-package sbcl-schemeish))
-(define-public sbcl-lla
- (let ((commit "ded805d1e9b1493e17b601116ba9bd8a3de3024f")
- (revision "1"))
+(define-public sbcl-screamer
+ (let ((commit "ce50614024de090b376107668da5e53232540ec7"))
(package
- (name "sbcl-lla")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-screamer")
+ (version (git-version "0.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tpapp/lla";)
+ (url "https://github.com/nikodemus/screamer/";)
(commit commit)))
- (file-name (git-file-name "cl-lla" version))
+ (file-name (git-file-name "cl-screamer" version))
(sha256
- (base32 "0n9vc7dnyjbbsv1n7rd8sylwda5fsdf8f890g4nachanyx0xps9k"))))
+ (base32 "1jl42pl6kwkiq71d0naf3r1mn1qy89ndimfgiz58c4g66xbjb7kx"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/configuration.lisp"
- (("\"libblas.so.3gf\"")
- (string-append "\"" (assoc-ref inputs "lapack")
- "/lib/libopenblas.so\""))
- (("\"liblapack.so.3gf\"")
- (string-append "\"" (assoc-ref inputs "lapack")
- "/lib/libopenblas.so\""))))))))
- (inputs
- `(("anaphora" ,sbcl-anaphora)
- ("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-num-utils" ,sbcl-cl-num-utils)
- ("cl-slice" ,sbcl-cl-slice)
- ("lapack" ,openblas)
- ("let-plus" ,sbcl-let-plus)))
(native-inputs
- (list sbcl-clunit))
- (home-page "https://github.com/tpapp/lla";)
- (synopsis "Linear algebra library for Common Lisp")
+ (list sbcl-iterate
+ sbcl-hu.dwim.stefil))
+ (home-page "https://nikodemus.github.io/screamer/";)
+ (synopsis "Nondeterministic programming and constraint propagation")
(description
- "LLA is a high-level Common Lisp library built on BLAS and LAPACK, but
-providing a much more abstract interface with the purpose of freeing the user
-from low-level concerns and reducing the number of bugs in numerical code.")
- (license license:boost1.0))))
+ "Screamer is an extension of Common Lisp that adds support for
+nondeterministic programming. Screamer consists of two levels. The basic
+nondeterministic level adds support for backtracking and undoable side
+effects. On top of this nondeterministic substrate, Screamer provides a
+comprehensive constraint programming language in which one can formulate and
+solve mixed systems of numeric and symbolic constraints. Together, these two
+levels augment Common Lisp with practically all of the functionality of both
+Prolog and constraint logic programming languages such as CHiP and CLP(R).
+Furthermore, Screamer is fully integrated with Common Lisp. Screamer programs
+can coexist and interoperate with other extensions to as CLIM and Iterate.")
+ (license license:expat))))
-(define-public cl-lla
- (sbcl-package->cl-source-package sbcl-lla))
+(define-public cl-screamer
+ (sbcl-package->cl-source-package sbcl-screamer))
-(define-public ecl-lla
- (sbcl-package->ecl-package sbcl-lla))
+(define-public ecl-screamer
+ (sbcl-package->ecl-package sbcl-screamer))
-(define-public sbcl-cl-rmath
- (let ((commit "f6add1edda31547691d08e36ccf6c17305161aca")
+(define-public sbcl-sdf
+ ;; Shinmera's fork required for Alloy.
+ (let ((commit "e1ab3ac4ea52c0e0119b832f428c71f580b4d83b")
(revision "1"))
(package
- (name "sbcl-cl-rmath")
+ (name "sbcl-sdf")
(version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tpapp/cl-rmath";)
+ (url "https://github.com/Shinmera/sdf";)
(commit commit)))
- (file-name (git-file-name "cl-rmath" version))
+ (file-name (git-file-name "sdf" version))
(sha256
- (base32 "1ld8vbpy10paymx2hn0mcgd21i7cjhdrayln1jx0kayqxm12mmk4"))))
+ (base32 "1cyq4hkgiw9mnb87ah6xw19cybfs9hfbjvg1ch2mf4cr0ism0nvn"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "cl-rmath.lisp"
- (("\\(cffi:define-foreign-library librmath" all)
- (string-append all "\n"
- " (:unix \""
- (assoc-ref inputs "librmath")
- "/lib/libRmath.so\")"))))))))
(inputs
- `(("cffi" ,sbcl-cffi)
- ("librmath" ,rmath-standalone)))
- (home-page "https://github.com/tpapp/cl-rmath";)
- (synopsis "Common Lisp wrapper for libRmath")
+ (list sbcl-zpb-ttf
+ sbcl-cl-vectors
+ sbcl-opticl
+ sbcl-binpack
+ sbcl-3b-bmfont/shinmera
+ sbcl-pathname-utils))
+ (arguments
+ `(#:asd-systems '("sdf" "sdf/bmfont")))
+ (home-page "https://github.com/Shinmera/sdf";)
+ (synopsis "Signed distance font atlas generator")
(description
- "@code{cl-rmath} is a simple, autogenerated foreign interface for the
-standalone R API @code{libRmath}. There has been no effort to provide a
-high-level interface for the original library, instead, this library is meant
-to serve as a building block for such an interface.")
- (license license:boost1.0))))
+ "This library generates
+sdf
(@url{https://steamcdn-a.akamaihd.net/apps/valve/2007/SIGGRAPH2007_AlphaTestedMagnification.pdf}),
+psdf and
+msdf (@url{https://github.com/Chlumsky/msdfgen/files/3050967/thesis.pdf})
+atlases.")
+ (license license:expat))))
-(define-public cl-rmath
- (sbcl-package->cl-source-package sbcl-cl-rmath))
+(define-public cl-sdf
+ (sbcl-package->cl-source-package sbcl-sdf))
-(define-public ecl-cl-rmath
- (sbcl-package->ecl-package sbcl-cl-rmath))
+(define-public ecl-sdf
+ (sbcl-package->ecl-package sbcl-sdf))
-(define-public sbcl-cl-random
- (let ((commit "5bb65911037f95a4260bd29a594a09df3849f4ea")
- (revision "1"))
+(define-public sbcl-sdl2
+ (let ((commit "80410b514570ca06894675d4a2a5fc93287ea7b6")
+ (revision "2"))
(package
- (name "sbcl-cl-random")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-sdl2")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tpapp/cl-random";)
+ (url "https://github.com/lispgames/cl-sdl2";)
(commit commit)))
- (file-name (git-file-name "cl-random" version))
+ (file-name (git-file-name "cl-sdl2" version))
(sha256
- (base32 "0jn80xphyvyp2v72acr6b8a2f6dw06myr5vrjfl14brsvks7wr89"))))
+ (base32 "0sjy4k04k0hdhwpr57ns16ag3za0kz4laclbk17i91ql7qdjw9z2"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("sdl2" "sdl2/examples")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libSDL2-2.0.so.0")
+ (search-input-file inputs "/lib/libSDL2-2.0.so.0"))))))))
(inputs
(list sbcl-alexandria
- sbcl-anaphora
- sbcl-array-operations
- sbcl-cl-num-utils
- sbcl-cl-rmath
- sbcl-cl-slice
- sbcl-gsll
- sbcl-let-plus
- sbcl-lla))
- (native-inputs
- (list sbcl-clunit))
- (home-page "https://github.com/tpapp/cl-random";)
- (synopsis "Random variates for Common Lisp")
+ sbcl-cl-autowrap
+ sbcl-cl-opengl
+ sbcl-cl-ppcre
+ sbcl-trivial-channels
+ sbcl-trivial-features
+ sdl2))
+ (home-page "https://github.com/lispgames/cl-sdl2";)
+ (synopsis "Common Lisp bindings for SDL2 using C2FFI")
(description
- "@code{cl-random} is a library for generating random draws from various
-commonly used distributions, and for calculating statistical functions, such as
-density, distribution and quantiles for these distributions.")
+ "This package provides a Common Lisp wrapper system for the SDL 2.0
+C Library.")
(license license:expat))))
-(define-public cl-random
- (sbcl-package->cl-source-package sbcl-cl-random))
+(define-public cl-sdl2
+ (sbcl-package->cl-source-package sbcl-sdl2))
-(define-public ecl-cl-random
- (sbcl-package->ecl-package sbcl-cl-random))
+(define-public ecl-sdl2
+ (sbcl-package->ecl-package sbcl-sdl2))
-(define-public sbcl-random-sample
- (let ((commit "46b70374ed796b84ea003e83c1db97b0caf97e22")
- (revision "0"))
+(define-public sbcl-sdl2-image
+ (let ((commit "9c05c806286b66a5d9861ef829cfe68c4f3da077")
+ (revision "1"))
(package
- (name "sbcl-random-sample")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-sdl2-image")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/random-sample";)
+ (url "https://github.com/lispgames/cl-sdl2-image";)
(commit commit)))
- (file-name (git-file-name "cl-random-sample" version))
+ (file-name (git-file-name "cl-sdl2-image" version))
(sha256
- (base32 "0nhgca6wf754wbg91h40gx7xq22rawg2pn6l7h02wv1jxac4q6nh"))))
+ (base32 "1nr7mdl125q32m15m8rdlza5kwi7m0birh1cq846pyy6zl1sjms7"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libSDL2_image-2.0.so.0")
+ (search-input-file inputs
"/lib/libSDL2_image-2.0.so.0"))))))))
(inputs
- (list sbcl-alexandria
- sbcl-infix-math
- sbcl-named-readtables
- sbcl-serapeum))
- (home-page "https://github.com/ruricolist/random-sample";)
- (synopsis "Take a random sample from a sequence")
+ (list sdl2-image
+ sbcl-alexandria
+ sbcl-cl-autowrap
+ sbcl-defpackage-plus
+ sbcl-sdl2))
+ (home-page "https://github.com/lispgames/cl-sdl2-image";)
+ (synopsis "SDL2_image wrapper for Common Lisp")
(description
- "Random-Sample is a library for reliably taking a random sample from a
-sequence.")
+ "This is a (currently) brief but usable wrap for SDL2_image.")
(license license:expat))))
-(define-public cl-random-sample
- (sbcl-package->cl-source-package sbcl-random-sample))
+(define-public cl-sdl2-image
+ (sbcl-package->cl-source-package sbcl-sdl2-image))
-(define-public ecl-random-sample
- (sbcl-package->ecl-package sbcl-random-sample))
+(define-public ecl-sdl2-image
+ (sbcl-package->ecl-package sbcl-sdl2-image))
-(define-public sbcl-hypergeometrica
- (let ((commit "db723ceb343d89a1c8d7f9174cf3a76fa91522b5")
- (revision "0"))
+(define-public sbcl-sdl2kit
+ (let ((commit "aae663224a10ece2b0c374aa5942a3f0bc1b3c2f"))
(package
- (name "sbcl-hypergeometrica")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-sdl2kit")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/stylewarning/hypergeometrica";)
+ (url "https://github.com/lispgames/sdl2kit/";)
(commit commit)))
- (file-name (git-file-name "cl-hypergeometrica" version))
+ (file-name (git-file-name "cl-sdl2kit" version))
(sha256
- (base32 "1dfd6w9djgfh7f4z79d8qsyggrwkjlqhs9rxpzpzv092nlwg3l35"))))
+ (base32 "10ymmxqsvdn7ndda9k2qcixj75l7namgqdxc5y2w3v5r1313fy2d"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiasco))
(inputs
(list sbcl-alexandria
- sbcl-cffi
- sbcl-global-vars
- sbcl-lparallel
- sbcl-mmap
- sbcl-napa-fft3
- sbcl-trivial-garbage))
- (home-page "https://github.com/stylewarning/hypergeometrica";)
- (synopsis "High-precision arithmetic")
+ sbcl-cl-opengl
+ sbcl-defpackage-plus
+ sbcl-sdl2))
+ (home-page "https://github.com/lispgames/sdl2kit/";)
+ (synopsis "Utility kit for CL-SDL2")
(description
- "Hypergeometrica is a Common Lisp library for performing high-precision
-arithmetic, with a focus on performance. At the heart of it all are routines
-for multiplication. Hypergeometrica aims to support:
-
-@itemize
-@item In-core multiplication using various algorithms, from schoolbook to
-floating-point FFTs.
-@item In-core multiplication for large numbers using exact convolutions via
-number-theoretic transforms, which is enabled by 64-bit modular arithmetic.
-@item Out-of-core multiplication using derivatives of the original
-Cooley–Tukey algorithm.
-@end itemize
+ "This is a utility kit for @code{cl-sdl2} that provides something
similar to
+GLUT. However, it's also geared at being useful for \"real\" applications or
+games.")
+ (license license:expat))))
-On top of multiplication, one can build checkpointed algorithms for computing
-various classical constants, like @math{\\pi}.")
- (license license:bsd-3))))
+(define-public cl-sdl2kit
+ (sbcl-package->cl-source-package sbcl-sdl2kit))
-(define-public cl-hypergeometrica
- (sbcl-package->cl-source-package sbcl-hypergeometrica))
+(define-public ecl-sdl2kit
+ (sbcl-package->ecl-package sbcl-sdl2kit))
-(define-public sbcl-mgl-gpr
- (let ((commit "cb6ce51e2f87bf1d589f3703c13eea6e25780afe")
+(define-public sbcl-sdl2-mixer
+ (let ((commit "fdcc7ee7935dd01fd338e22690451db2cf126156")
(revision "1"))
(package
- (name "sbcl-mgl-gpr")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-sdl2-mixer")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/melisgl/mgl-gpr";)
+ (url "https://github.com/lispgames/cl-sdl2-mixer";)
(commit commit)))
- (file-name (git-file-name "cl-mgl-gpr" version))
+ (file-name (git-file-name "cl-sdl2-mixer" version))
(sha256
- (base32 "0w51dqixh277k6sl8bqvvp1400y6kd1l5h3d9q2f40l9bpxy8gjx"))))
+ (base32 "0g6ywb3gqr0rif4z6kkz6m8vyv8nrr5wr1w9sc6d3zypbbnqgbp6"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libSDL2_mixer-2.0.so.0")
+ (search-input-file inputs
"/lib/libSDL2_mixer-2.0.so.0"))))))))
(inputs
- (list sbcl-cl-random sbcl-mgl-pax))
- (home-page "https://melisgl.github.io/mgl-gpr/";)
- (synopsis "Common Lisp library of evolutionary algorithms")
+ (list sbcl-alexandria
+ sbcl-cl-autowrap
+ sbcl-sdl2
+ sbcl-trivial-garbage
+ sdl2-mixer))
+ (home-page "https://github.com/lispgames/cl-sdl2-mixer";)
+ (synopsis "Bindings for sdl2_mixer using autowrap for Common Lisp")
(description
- "@code{MGL-GPR} is a library of evolutionary algorithms such as
-Genetic Programming (evolving typed expressions from a set of operators and
-constants) and Differential Evolution.")
+ "This package provides a Common Lisp wrapper system for the SDL 2.0
Mixer C
+Library.")
(license license:expat))))
-(define-public cl-mgl-gpr
- (sbcl-package->cl-source-package sbcl-mgl-gpr))
+(define-public cl-sdl2-mixer
+ (sbcl-package->cl-source-package sbcl-sdl2-mixer))
-(define-public ecl-mgl-gpr
- (sbcl-package->ecl-package sbcl-mgl-gpr))
+(define-public ecl-sdl2-mixer
+ (sbcl-package->ecl-package sbcl-sdl2-mixer))
-(define-public sbcl-cl-tld
- ;; No release.
- (let ((commit "f5014da8d831fa9481d4181d4450f10a52850c75"))
+(define-public sbcl-sdl2-ttf
+ (let ((commit "6dd2df2fb3a79ec4f835e3bc882e60e8da039878")
+ (revision "1"))
(package
- (name "sbcl-cl-tld")
- (version (git-version "0.1" "2" commit))
+ (name "sbcl-sdl2-ttf")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lu4nx/cl-tld";)
+ (url "https://github.com/lispgames/cl-sdl2-ttf";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-sdl2-ttf" version))
(sha256
- (base32 "0sxnn35gzdby1ixil6zbjg72vli9fcspwzsqimqk455310syx9iv"))))
+ (base32 "07c1bl66dix6ccnyl9mqd6lbk10f9s25985zmv6lss95491ng7my"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/lu4nx/cl-tld/";)
- (synopsis "Extract the Top Level Domain from domains, in Common Lisp")
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libSDL2_ttf-2.0.so.0")
+ (search-input-file inputs
"/lib/libSDL2_ttf-2.0.so.0")))))
+ (add-after 'unpack 'fix-critical-warning
+ (lambda _
+ (substitute* "src/helpers.lisp"
+ (("nreverse") "reverse")))))))
+ (inputs
+ (list sdl2-ttf
+ sbcl-alexandria
+ sbcl-cffi
+ sbcl-cl-autowrap
+ sbcl-defpackage-plus
+ sbcl-sdl2
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/lispgames/cl-sdl2-ttf";)
+ (synopsis "SDL2_ttf wrapper for Common Lisp")
(description
- "This library extracts the TLD (Top Level Domain) from domains. The
-information is taken from @url{https://publicsuffix.org}.";)
- (license license:public-domain))))
+ "This is a wrapper for the SDL2_TTF library used for loading fonts and
+creating text assets. The library, in it's current state, can load TTF and
+OTF fonts and render fonts with the three different rendering modes provided
+by the C library (solid, shaded, and blended). While Latin text, UTF8,
+UNICODE, and Glyph text rendering is available only Latin text has been
+tested (as shown in the examples).")
+ (license license:expat))))
-(define-public cl-tld
- (sbcl-package->cl-source-package sbcl-cl-tld))
+(define-public cl-sdl2-ttf
+ (sbcl-package->cl-source-package sbcl-sdl2-ttf))
-(define-public ecl-cl-tld
- (sbcl-package->ecl-package sbcl-cl-tld))
+(define-public ecl-sdl2-ttf
+ (sbcl-package->ecl-package sbcl-sdl2-ttf))
-(define-public sbcl-cl-strftime
- ;; No release.
- (let ((commit "21cb57f2595faa26d687893963f24ec41822b63c"))
+(define-public sbcl-sealable-metaobjects
+ (let ((commit "e09ec97252e0844528f61abdc0c7ee256875f8ee"))
(package
- (name "sbcl-cl-strftime")
+ (name "sbcl-sealable-metaobjects")
(version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/cl-strftime/";)
+ (url "https://github.com/marcoheisig/sealable-metaobjects/";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-sealable-metaobjects" version))
(sha256
- (base32 "00c8hq7vzgb89ab3q7mrp60x743kiqmsk1g51ynhxlqhph2bnslf"))))
+ (base32 "0hz1ivlpfhnk1w2cw4q2i000j2dc7maay06ndzziyywg7li6zf2p"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-local-time sbcl-cl-ppcre sbcl-serapeum))
- (native-inputs
- (list sbcl-fiveam sbcl-cffi))
- (home-page "https://github.com/ruricolist/cl-strftime";)
- (synopsis "Common Lisp compiler for the strftime language")
+ (list sbcl-closer-mop))
+ (home-page "https://github.com/marcoheisig/sealable-metaobjects/";)
+ (synopsis "CLOSsy way to trade genericity for performance")
(description
- "CL-STRFTIME is a Common Lisp compiler for the strftime “language.”")
+ "This library is an extension of the Common Lisp Object System (CLOS)
+that allows a compiler to inline a generic function under certain
+conditions.")
(license license:expat))))
-(define-public cl-strftime
- (sbcl-package->cl-source-package sbcl-cl-strftime))
+(define-public cl-sealable-metaobjects
+ (sbcl-package->cl-source-package sbcl-sealable-metaobjects))
-(define-public ecl-cl-strftime
- (sbcl-package->ecl-package sbcl-cl-strftime))
+(define-public ecl-sealable-metaobjects
+ (sbcl-package->ecl-package sbcl-sealable-metaobjects))
-(define-public sbcl-exit-hooks
- ;; No release.
- (let ((commit "78050f4f55c138fcea86a9d720928782021b6012"))
+(define-public sbcl-seedable-rng
+ (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15")
+ (revision "1"))
(package
- (name "sbcl-exit-hooks")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-seedable-rng")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ailisp/exit-hooks/";)
+ (url "https://git.mfiano.net/mfiano/seedable-rng";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "seedable-rng" version))
(sha256
- (base32 "00rk0pr2cy3hy6giblh166b7yrg06d5lanipjcqv508gkfb0vi47"))))
+ (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/ailisp/exit-hooks";)
- (synopsis "Call functions automatically when Common Lisp exits")
+ (inputs
+ (list sbcl-cl-pcg sbcl-golden-utils sbcl-ironclad))
+ (home-page "https://git.mfiano.net/mfiano/seedable-rng";)
+ (synopsis "Common Lisp random number generator")
(description
- "@code{exit-hooks} provides a portable way to automatically call some
-user-defined function when exiting Common Lisp (both @code{quit} from the REPL
-or a kill in a shell). Like @code{atexit} in C and Python or Java’s
-@code{Runtime.addShutdownHook()}. It currently supports SBCL, CCL, ECL, ABCL,
-Allegro CL, clisp and CMUCL. Before exit-hooks, there was no portable way of
-doing so and no staightforward way to use an exit hook on ABCL. It can be used
-for tasks like parmenantly save something when exiting Lisp.")
- (license license:bsd-2))))
+ "SEEDABLE-RNG provides a convenient means of generating random numbers
+that are seedable with deterministic results across hardware and Common Lisp
+implementations.")
+ (license license:expat))))
-(define-public cl-exit-hooks
- (sbcl-package->cl-source-package sbcl-exit-hooks))
+(define-public cl-seedable-rng
+ (sbcl-package->cl-source-package sbcl-seedable-rng))
-(define-public ecl-exit-hooks
- (sbcl-package->ecl-package sbcl-exit-hooks))
+(define-public ecl-seedable-rng
+ (sbcl-package->ecl-package sbcl-seedable-rng))
-(define-public sbcl-cl-base58
- (let ((commit "f446835b4104896e0eed6a61d2ceb4ad22f589d8")
- (revision "1"))
+(define-public sbcl-select
+ (let ((commit "df7920fc451b6d15345040ce4a3ee1ea2818ab1a")
+ (revision "0"))
(package
- (name "sbcl-cl-base58")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-select")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eudoxia0/cl-base58/";)
+ (url "https://github.com/Lisp-Stat/select";)
(commit commit)))
- (file-name (git-file-name "cl-base58" version))
+ (file-name (git-file-name "cl-select" version))
(sha256
- (base32 "01wiiyz1jzxx3zhxi2hpq5n8hv28g1mn0adk793vwjzh4v5bi5zz"))))
+ (base32 "0bhpvfqp7n33pia4y62qi31bx86gjl2nxjy529rfawac57c9rxv3"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-base58-test" "cl-base58")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "cl-base58-test.asd"
- (("cl-test-more")
- "prove"))
- #t)))))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-let-plus))
(native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/eudoxia0/cl-base58";)
- (synopsis "Implementation of base58 for Common Lisp")
+ (list sbcl-fiveam))
+ (home-page "https://lisp-stat.github.io/select/";)
+ (synopsis "Library for taking slices from array-like objects")
(description
- "This library implements the @code{base58} encoding algorithm. It's
-basically @code{base64} but with a smaller alphabet (58, as in the name) that
-doesn't include similar looking characters, among other things. See
-@url{https://github.com/bitcoin/bitcoin/blob/master/src/base58.h} for a full
-reference.")
- (license license:expat))))
+ "This is a library for selecting portions of sequences, arrays or
+data-frames.")
+ (license license:ms-pl))))
-(define-public cl-base58
- (sbcl-package->cl-source-package sbcl-cl-base58))
+(define-public cl-select
+ (sbcl-package->cl-source-package sbcl-select))
-(define-public ecl-cl-base58
- (sbcl-package->ecl-package sbcl-cl-base58))
+(define-public ecl-select
+ (sbcl-package->ecl-package sbcl-select))
-(define-public sbcl-bit-smasher
- ;; No release.
- (let ((commit "c2dcb3b5ec0e485484be681fe17c4e81e58790d9"))
+(define-public sbcl-serapeum
+ (let ((commit "c08442a9757b7fa30ac345cb040e1642f97f6b78")
+ (revision "12"))
(package
- (name "sbcl-bit-smasher")
- (version (git-version "1.0.2" "1" commit))
+ (name "sbcl-serapeum")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/serapeum";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/thephoeron/bit-smasher/";)
+ (url home-page)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0wjmwn06fjpw0rlpaksf3ab727p8fnzj58z7jajl3m0wqd4ii74w"))))
+ (base32 "1sabd048agvgv7bhbw126rci9hf45fk08zhghcv6an2h6xwmc3qv"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("cl-base64" ,sbcl-cl-base64)
- ("cl-base58" ,sbcl-cl-base58)))
- (home-page "https://github.com/thephoeron/bit-smasher/";)
- (synopsis "Handle bit vectors, bit vector arithmetic, and type
conversions")
+ (list sbcl-alexandria
+ sbcl-trivia
+ sbcl-split-sequence
+ sbcl-string-case
+ sbcl-parse-number
+ sbcl-trivial-garbage
+ sbcl-bordeaux-threads
+ sbcl-parse-declarations
+ sbcl-introspect-environment
+ sbcl-trivial-cltl2
+ sbcl-global-vars
+ sbcl-trivial-file-size
+ sbcl-trivial-macroexpand-all))
+ (native-inputs
+ (list sbcl-atomics
+ sbcl-fiveam
+ sbcl-local-time))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'disable-failing-tests
+ (lambda _
+ (substitute* "serapeum.asd"
+ ;; Guix does not have Quicklisp, and probably never
will.
+ (("\\(:file \"quicklisp\"\\)") "")))))))
+ (synopsis "Common Lisp utility library beyond Alexandria")
(description
- "Utility library for handling bit vectors, bit vector arithmetic, and
-universal integer type conversions between bit-vectors, byte-vectors, octals,
-decimals, and hexadecimal notation.")
+ "Serapeum is a conservative library of Common Lisp utilities. It is a
+supplement, not a competitor, to Alexandria.")
(license license:expat))))
-(define-public cl-bit-smasher
- (sbcl-package->cl-source-package sbcl-bit-smasher))
+(define-public cl-serapeum
+ (sbcl-package->cl-source-package sbcl-serapeum))
-(define-public ecl-bit-smasher
- (sbcl-package->ecl-package sbcl-bit-smasher))
+(define-public ecl-serapeum
+ (sbcl-package->ecl-package sbcl-serapeum))
-(define-public sbcl-overlord
- ;; No release.
- (let ((commit "a8f37b321a8aae1652fc50b78e74e57c771cc763"))
+(define-public sbcl-series
+ (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
+ (revision "1"))
(package
- (name "sbcl-overlord")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-series")
+ (version (git-version "2.2.11" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/overlord/";)
+ (url "git://git.code.sf.net/p/series/series")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1maqm53yhlhaa3cka8xcc4sq24ifrr4y3y0s5dyyn682xsh14hb4"))))
+ (base32
+ "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("babel" ,sbcl-babel)
- ("bit-smasher" ,sbcl-bit-smasher)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cl-strftime" ,sbcl-cl-strftime)
- ("cmd" ,sbcl-cmd)
- ("drakma" ,sbcl-drakma)
- ("exit-hooks" ,sbcl-exit-hooks)
- ("fset" ,sbcl-fset)
- ("local-time" ,sbcl-local-time)
- ("lparallel" ,sbcl-lparallel)
- ("md5" ,sbcl-md5)
- ("murmurhash" ,sbcl-cl-murmurhash)
- ("named-readtables" ,sbcl-named-readtables)
- ("ppcre" ,sbcl-cl-ppcre)
- ("serapeum" ,sbcl-serapeum)
- ("trivia" ,sbcl-trivia)
- ("trivial-file-size" ,sbcl-trivial-file-size)))
- (propagated-inputs
- `(("quickproject" ,sbcl-quickproject)))
- (native-inputs
- (list sbcl-fiveam))
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'include-overlord/net
- (lambda _
- (substitute* "all.lisp"
- (("\\(:import-from :overlord/kernel :nproc\\)")
- (string-append
- "(:import-from :overlord/kernel :nproc)"
- "\n"
- "(:import-from :overlord/net)")))
- #t)))))
- (home-page "https://github.com/ruricolist/overlord";)
- (synopsis "Build system in Common Lisp")
+ ;; Disable the tests, they are apparently buggy and I didn't find
+ ;; a simple way to make them run and pass.
+ '(#:tests? #f))
+ (synopsis "Series data structure for Common Lisp")
(description
- "Overlord is a build system in Common Lisp. It is a real build system,
-with all the modern features: rules with multiple outputs, parallel builds,
-immunity to clock issues, and dynamic dependencies.
+ "This Common Lisp library provides a series data structure much like
+a sequence, with similar kinds of operations. The difference is that in many
+situations, operations on series may be composed functionally and yet execute
+iteratively, without the need to construct intermediate series values
+explicitly. In this manner, series provide both the clarity of a functional
+programming style and the efficiency of an iterative programming style.")
+ (home-page "https://series.sourceforge.net/";)
+ (license license:expat))))
-But Overlord is more than another build system. Overlord is a uniform
-approach to dependencies inside or outside of a Lisp image. Overlord is to
-Make what Lisp macros are to C macros.
+(define-public cl-series
+ (sbcl-package->cl-source-package sbcl-series))
-Overlord is designed to be used from the Lisp REPL. A command line interface
-is available in a separate repository. See
-@url{https://github.com/ruricolist/overlord-cli}.";)
- (license license:expat))))
+(define-public ecl-series
+ (sbcl-package->ecl-package sbcl-series))
-(define-public cl-overlord
- (sbcl-package->cl-source-package sbcl-overlord))
+(define-public sbcl-sha1
+ (let ((commit "be8b1b155c3a6ad3eb9b200212af6ff52f5611de")
+ (revision "0"))
+ (package
+ (name "sbcl-sha1")
+ (version (git-version "1.0" revision commit))
+ (home-page "https://github.com/massung/sha1";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/massung/sha1";)
+ (commit commit)))
+ (file-name (git-file-name "cl-sha1" version))
+ (sha256
+ (base32 "1cfn0j5yfwqkwr2dm73wr9hz8dmws3ngxlbk9886ahxkg544qx4z"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "SHA1 Digest and HMAC for Common Lisp")
+ (description
+ "This is a very simple implementation of SHA1 and HMAC-SHA1 for
+Common Lisp. The code is intended to be easy to follow and is therefore a
+little slower than it could be.")
+ (license license:asl2.0))))
-;; FIXME: Broken on ECL? https://github.com/ruricolist/overlord/issues/25
-;; (define-public ecl-overlord
-;; (sbcl-package->ecl-package sbcl-overlord))
+(define-public cl-sha1
+ (sbcl-package->cl-source-package sbcl-sha1))
-(define-public sbcl-xpath
- ;; No release.
- (let ((commit "d364da693a534e23bd5eb3a85420e9c25e6c75b3"))
+(define-public ecl-sha1
+ (sbcl-package->ecl-package sbcl-sha1))
+
+(define-public sbcl-shadow
+ (let ((commit "b2031adbfba3579b48c9d39ad997e19b79b6852f")
+ (revision "1"))
(package
- (name "sbcl-xpath")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-shadow")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/xpath/";)
+ (url "https://git.mfiano.net/mfiano/shadow";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "shadow" version))
(sha256
- (base32 "1fb03fgnzrvh22lw1jdg04pmyja5fib5n42rzwp5mhr829yvxkvp"))))
+ (base32 "0w1i734gkdkziin74ql2nhx7jdjxx02ylssaa6qdrvnj4br1124a"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cxml sbcl-parse-number sbcl-cl-ppcre sbcl-cl-yacc))
- (home-page "https://github.com/sharplispers/xpath/";)
- (synopsis "Implementation of the XML Path Language (XPath) Version 1.0")
+ (list sbcl-cffi
+ sbcl-cl-opengl
+ sbcl-glsl-packing
+ sbcl-golden-utils
+ sbcl-static-vectors
+ sbcl-varjo))
+ (home-page "https://git.mfiano.net/mfiano/shadow";)
+ (synopsis "Management system for OpenGL shader programs")
(description
- "This library is an implementation of the XML Path Language (XPath)
-Version 1.0.")
- (license license:bsd-2))))
+ "This package provides a Common Lisp library for defining OpenGL shader
+programs. There are also functions for referencing shader programs by name,
+querying for basic information about them, modifying uniform variables
+throughout the lifecycle of an OpenGL application, and managing certain OpenGL
+buffer object types (UBO, SSBO currently).")
+ (license license:expat))))
-;; According to
-;; https://github.com/sharplispers/xpath/blob/master/doc/index.xml ECL is not
-;; supported.
-(define-public cl-xpath
- (sbcl-package->cl-source-package sbcl-xpath))
+(define-public cl-shadow
+ (sbcl-package->cl-source-package sbcl-shadow))
-(define-public sbcl-fxml
- ;; No release.
- (let ((commit "a0e73bb48ef03adea94a55986cc27f522074c8e1"))
+(define-public ecl-shadow
+ (sbcl-package->ecl-package sbcl-shadow))
+
+(define-public sbcl-shared-preferences
+ (package
+ (name "sbcl-shared-preferences")
+ (version "1.1.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/shared-preferences";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-shared-preferences" version))
+ (sha256
+ (base32 "12m4kaba2lxndkjw30a6y2rq16fflh5016lp74l7pf3v0y3j1ydf"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-inheriting-readers
+ sbcl-trivial-garbage))
+ (home-page "https://www.hexstreamsoft.com/libraries/shared-preferences/";)
+ (synopsis "Flexible specification of package-local preferences")
+ (description
+ "This package allows flexible specification of package-local
preferences.")
+ (license license:unlicense)))
+
+(define-public cl-shared-preferences
+ (sbcl-package->cl-source-package sbcl-shared-preferences))
+
+(define-public ecl-shared-preferences
+ (sbcl-package->ecl-package sbcl-shared-preferences))
+
+(define-public sbcl-shasht
+ (let ((commit "27ba0a8842e103f2d575b3c8bbcfc19bd172d9ea")
+ (revision "2"))
(package
- (name "sbcl-fxml")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-shasht")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/fxml/";)
+ (url "https://github.com/yitzchak/shasht";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-shasht" version))
(sha256
- (base32 "1vxdb1cjjqi986f72bggnw1s4yzv12g4li7vn4y49b6lphshr8lm"))))
+ (base32 "1y7qh8kdhk06243vkmxzdk0y9rax4g8pv28bd01j48ix777mpcdc"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-babel
- sbcl-named-readtables
- sbcl-serapeum
- sbcl-quri
- sbcl-flexi-streams
- sbcl-split-sequence
- sbcl-alexandria
- sbcl-trivial-gray-streams))
(native-inputs
- (list sbcl-fiveam sbcl-cxml sbcl-cxml-rng sbcl-xpath))
- (home-page "https://github.com/ruricolist/fxml";)
- (synopsis "XML parser and serializer in Common Lisp")
+ (list sbcl-alexandria sbcl-parachute))
+ (inputs
+ (list sbcl-closer-mop sbcl-trivial-do))
+ (home-page "https://yitzchak.github.io/shasht/";)
+ (synopsis "Common Lisp JSON reading and writing library")
(description
- "FXML is a secure-by-default, error-recovering XML parser and
serializer.
-It is a fork of CXML.
-
-You should use FXML instead of CXML if:
-@itemize
-@item You are parsing potentially ill-formed XML.
-@item You are parsing potentially malicious XML.
-@item You need to use Klacks with namespaces.
-@end itemize
+ "This package provides a Common Lisp library to work with the JSON file
+format.")
+ (license license:expat))))
-FXML’s API is very close to CXML's, and for the most part you can refer to the
-CXML documentation for usage.")
- (license license:llgpl))))
+(define-public cl-shasht
+ (sbcl-package->cl-source-package sbcl-shasht))
-(define-public cl-fxml
- (sbcl-package->cl-source-package sbcl-fxml))
+(define-public ecl-shasht
+ (sbcl-package->ecl-package sbcl-shasht))
-(define-public sbcl-vernacular
- ;; No release.
- (let ((commit "79be179e9ada423b3ec41d2a1ea6f6e0266ed21f"))
+(define-public sbcl-shlex
+ (let ((commit "3dee1cb7c0140fa7660ca7a3b2ac5e75d1218e5c")
+ (revision "2"))
(package
- (name "sbcl-vernacular")
- (version (git-version "0.8.0" "1" commit))
+ (name "sbcl-shlex")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/vernacular/";)
+ (url "https://github.com/ruricolist/cl-shlex";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-shlex" version))
(sha256
- (base32 "19vzn28hw4is4sgmvzqin18ds89s0pai21vcm0ky10vmfv6wg745"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; The demo depends on cl-js, which we don't have at this point.
- (delete-file-recursively "demo")
- #t))))
+ (base32 "16ag48sswgimr1fzr582vhym4s03idpd4lkydw5s58lv80ibpim8"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("overlord" ,sbcl-overlord)
- ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)
- ("local-time" ,sbcl-local-time)
- ("parse-js" ,sbcl-parse-js)
- ("trivia" ,sbcl-trivia)
- ("trivial-garbage" ,sbcl-trivial-garbage)
- ("named-readtables" ,sbcl-named-readtables)
- ("alexandria" ,sbcl-alexandria)
- ("serapeum" ,sbcl-serapeum)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
- (arguments
- ;; Circular dependency: Tests depend on core-lisp
- ;; (http://github.com/ruricolist/core-lisp) which depends on
- ;; Vernacular.
- '(#:tests? #f))
- (home-page "https://github.com/ruricolist/vernacular";)
- (synopsis "Module system for languages that compile to Common Lisp")
+ (list sbcl-alexandria sbcl-serapeum sbcl-cl-ppcre sbcl-cl-unicode))
+ (home-page "https://github.com/ruricolist/cl-shlex";)
+ (synopsis "Common Lisp lexical analyzer for shell-like syntaxes")
(description
- "Vernacular is a build and module system for languages that compile to
-Common Lisp. It allows languages to compile to Lisp while remaining part of
-the Common Lisp ecosystem. Vernacular languages interoperate with Common Lisp
-and one another.
-
-Vernacular handles locating files, compiling files into FASLs, tracking
-dependencies and rebuilding, and export and import between your new language,
-Lisp, and any other language Vernacular supports.
-
-Vernacular builds on Overlord and is inspired by Racket.")
+ "This library contains a lexer for syntaxes that use shell-like rules
+for quoting and commenting. It is a port of the @code{shlex} module from
Python’s
+standard library.")
(license license:expat))))
-(define-public cl-vernacular
- (sbcl-package->cl-source-package sbcl-vernacular))
+(define-public ecl-shlex
+ (sbcl-package->ecl-package sbcl-shlex))
-(define-public sbcl-cl-collider
- (let ((commit "a46908896982868955b29bfb3a5337a0af489b0b")
- (revision "0"))
+(define-public cl-shlex
+ (sbcl-package->cl-source-package sbcl-shlex))
+
+(define-public sbcl-simple-date-time
+ (let ((commit "d6992afddedf67a8172a0120a1deac32afcaa2e8")
+ (revision "1"))
(package
- (name "sbcl-cl-collider")
- (version (git-version "2018.7.15" revision commit))
- (source
+ (name "sbcl-simple-date-time")
+ (version (git-version "0.1.0" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/byulparan/cl-collider";)
+ (url "https://github.com/quek/simple-date-time";)
(commit commit)))
- (file-name (git-file-name "cl-collider" version))
+ (file-name (git-file-name "cl-simple-date-time" version))
(sha256
- (base32 "10wvjbwvbgr0b57hpfxycg90yjmb29pirygr1sxrdaqxll328sz1"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'patch-executables-and-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "server.lisp"
- (("/usr/local/lib/SuperCollider/plugins")
- (search-input-directory
- inputs "/lib/SuperCollider/plugins"))
- (("/usr/local/share/SuperCollider/Extensions")
- (search-input-directory
- inputs "/share/SuperCollider/Extensions"))
- (("which scsynth")
- (string-append
- "which "
- (search-input-file inputs "/bin/scsynth")))
- (("jack_connect")
- (search-input-file inputs "/bin/jack_connect"))))))))
- (inputs
- (list jack-1
- supercollider
- sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-cl-ppcre
- sbcl-flexi-streams
- sbcl-ieee-floats ; sc-osc dependencies.
- sbcl-named-readtables
- sbcl-osc
- sbcl-pileup
- sbcl-simple-inferiors ; For ecl.
- sbcl-split-sequence
- sbcl-usocket))
- (synopsis "SuperCollider client for CommonLisp")
- (description "This package provides a SuperCollider client for
-Common Lisp.")
- (home-page "https://github.com/byulparan/cl-collider/";)
- (license license:public-domain))))
+ (base32 "06iwf13gcdyqhkzfkcsfdl8iqbdl44cx01c3fjsmhl0v1pp8h2m4"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cl-ppcre))
+ (home-page "https://github.com/quek/simple-date-time";)
+ (synopsis "Date and time library for Common Lisp")
+ (description "This package is a simple date and time library.")
+ (license license:bsd-4))))
-(define-public cl-collider
- (sbcl-package->cl-source-package sbcl-cl-collider))
+(define-public cl-simple-date-time
+ (sbcl-package->cl-source-package sbcl-simple-date-time))
-(define-public ecl-cl-collider
- (sbcl-package->ecl-package sbcl-cl-collider))
+(define-public ecl-simple-date-time
+ (sbcl-package->ecl-package sbcl-simple-date-time))
-(define-public sbcl-osc
- (let ((commit "f647738ccc22925ed740a8ca9132fda76a05baeb")
+(define-public sbcl-simple-guess
+ (let ((commit "34744e3200a96e6aba285d70f91cdbd6c25508a6")
(revision "0"))
(package
- (name "sbcl-osc")
- (version (git-version "0.9" revision commit))
- (source
+ (name "sbcl-simple-guess")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/simple-guess";)
+ (commit commit)))
+ (file-name (git-file-name "cl-simple-guess" version))
+ (sha256
+ (base32 "0404vj7ln97x7rn9ypbw4rshs56nnpyjnh1z9k03s039s5q3kpv0"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fakenil sbcl-parachute))
+ (inputs
+ (list sbcl-cesdi
+ sbcl-closer-mop
+ sbcl-compatible-metaclasses
+ sbcl-evaled-when))
+ (home-page "https://www.hexstreamsoft.com/libraries/simple-guess/";)
+ (synopsis "Extensible protocol for computing a guess using advisors")
+ (description
+ "This package defines a simple extensible protocol for computing a guess
+using advisors.")
+ (license license:unlicense))))
+
+(define-public cl-simple-guess
+ (sbcl-package->cl-source-package sbcl-simple-guess))
+
+(define-public ecl-simple-guess
+ (sbcl-package->ecl-package sbcl-simple-guess))
+
+(define-public sbcl-simple-inferiors
+ (let ((commit "deac886354e03f8a9502ce96f12a0459ce3be671"))
+ (package
+ (name "sbcl-simple-inferiors")
+ (version (git-version "1.1.0" "1" commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/zzkt/osc";)
+ (url "https://github.com/Shinmera/simple-inferiors";)
(commit commit)))
- (file-name (git-file-name "cl-osc" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1x4cavspaxcr604g0hwak1ncy4m9cqq03ji4v56g2h1443n7h48a"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (inputs (list sbcl-ieee-floats))
- (synopsis "Implementation of the Open Sound Control protocol")
- (description "This is a lisp implementation of the Open Sound Control
-protocol (or more accurately “data transport specification” or
-“encoding”). The code should be close to ANSI standard common lisp and
-provides self contained code for encoding and decoding of OSC data, messages,
-and bundles.")
- (home-page "https://github.com/zzkt/osc/";)
- (license license:gpl3+))))
+ (base32 "08vsvqv3768bwb2y8mwxbw5wyqzzwqr7rd004r6gafdgf9p9mcx3"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-bordeaux-threads sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/simple-inferiors/";)
+ (synopsis "Common Lisp library to use inferior processes")
+ (description
+ "This is a library to allow easy handling of external processes, and
+primarily to get their output. It handles proper copying of the standard and
+error outputs of the process simultaneously, both in a sequential and parallel
+fashion. It also features a lazy directory switching mechanism, to avoid
+running into parallelism problems when having to change directory.")
+ (license license:zlib))))
-(define-public cl-osc
- (sbcl-package->cl-source-package sbcl-osc))
+(define-public cl-simple-inferiors
+ (sbcl-package->cl-source-package sbcl-simple-inferiors))
-(define-public ecl-osc
- (sbcl-package->ecl-package sbcl-osc))
+(define-public ecl-simple-inferiors
+ (sbcl-package->ecl-package sbcl-simple-inferiors))
-(define-public sbcl-cmn
+(define-public sbcl-simple-neural-network
(package
- (name "sbcl-cmn")
- (version "2021.11.22")
+ (name "sbcl-simple-neural-network")
+ (version "3.1")
(source
(origin
- (method url-fetch)
- (uri "https://ccrma.stanford.edu/software/cmn/cmn.tar.gz";)
- (file-name (string-append "cmn-" version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://codeberg.org/glv/simple-neural-network";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "simple-neural-network" version))
(sha256
- (base32 "04j1l57cdyfi2zzxqwmvmf1hl899ffgs3bl4r42ba47zsw45kq14"))))
+ (base32 "1jj1c90fr5clwka0jv32hv6xp1bkdlpa6x5jh19an13rhx8ll4zr"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://ccrma.stanford.edu/software/cmn/";)
- (synopsis "Western music notation package written in Common Lisp")
+ (native-inputs
+ `(("chipz" ,sbcl-chipz)
+ ("fiveam" ,sbcl-fiveam)))
+ (inputs
+ `(("cl-store" ,sbcl-cl-store)
+ ("lparallel" ,sbcl-lparallel)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'check 'remove-test-data
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((out (assoc-ref outputs "out")))
+ (for-each delete-file (find-files out "\\.gz$"))))))))
+ (synopsis "Simple neural network in Common Lisp")
(description
- "CMN provides a package of functions to hierarchically describe a musical
-score. When evaluated, the musical score is rendered to an image.")
- (license license:expat)))
+ "@code{simple-neural-network} is a Common Lisp library for creating,
+training and using basic neural networks. The networks created by this
+library are feedforward neural networks trained using backpropagation.")
+ (home-page "https://codeberg.org/glv/simple-neural-network";)
+ (license license:gpl3+)))
-(define-public cl-cmn
- (sbcl-package->cl-source-package sbcl-cmn))
+(define-public cl-simple-neural-network
+ (sbcl-package->cl-source-package sbcl-simple-neural-network))
-(define-public ecl-cmn
- (sbcl-package->ecl-package sbcl-cmn))
+(define-public ecl-simple-neural-network
+ (sbcl-package->ecl-package sbcl-simple-neural-network))
-(define-public sbcl-core-gp
- (let ((commit "90ec1c4599a19c5a911be1f703f78d5108aee160")
+(define-public sbcl-simple-parallel-tasks
+ (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6")
(revision "1"))
(package
- (name "sbcl-core-gp")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-simple-parallel-tasks")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jorgetavares/core-gp";)
+ (url "https://codeberg.org/glv/simple-parallel-tasks";)
(commit commit)))
- (file-name (git-file-name "cl-core-gp" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0nzlb2gwqisa1amlpl4zc5xxph2g3qwhfyaxchci67d31rzws6l3"))))
+ (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/jorgetavares/core-gp";)
- (synopsis "Common Lisp library for genetic programming")
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-chanl))
+ (synopsis "Common Lisp library to evaluate some forms in parallel")
+ (description "This is a simple Common Lisp library to evaluate some
+forms in parallel.")
+ (home-page "https://codeberg.org/glv/simple-parallel-tasks";)
+ (license license:gpl3))))
+
+(define-public cl-simple-parallel-tasks
+ (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
+
+(define-public ecl-simple-parallel-tasks
+ (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
+
+(define-public sbcl-simple-rgb
+ (let ((commit "ba9b0689362c28aa6a91c0636796c6c372657293")
+ (revision "1"))
+ (package
+ (name "sbcl-simple-rgb")
+ (version (git-version "0.01" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/wmannis/simple-rgb/";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0ggv0h2n4mvwnggjr1b40gw667gnyykzki2zadaczi38ydzyzlp1"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/wmannis/simple-rgb";)
+ (synopsis "Manipulate colors in RGB format")
(description
- "@code{core-gp} is a Common Lisp library for genetic programming (GP)
-algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as
-well as standard genetic algorithms.")
- (license license:expat))))
+ "This Common Lisp library focuses on the small set of basic color
+manipulations (lightening, compliments, etc.) you might use to generate a
+color palette for a GUI or web page.")
+ (license license:bsd-2))))
-(define-public cl-core-gp
- (sbcl-package->cl-source-package sbcl-core-gp))
+(define-public ecl-simple-rgb
+ (sbcl-package->ecl-package sbcl-simple-rgb))
-(define-public ecl-core-gp
- (sbcl-package->ecl-package sbcl-core-gp))
+(define-public cl-simple-rgb
+ (sbcl-package->cl-source-package sbcl-simple-rgb))
-(define-public sbcl-data-sift
- (let ((commit "fd617d8200cdcc1b87ecf45ab59bb38e8b16ef7e")
+(define-public sbcl-simple-routes
+ (let ((commit "6f88c38945a4de73e85786d3499c39cacb400598")
(revision "1"))
(package
- (name "sbcl-data-sift")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-simple-routes")
+ (version (git-version "0.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/data-sift";)
+ (url "https://gitlab.com/vancan1ty/simple-routes";)
(commit commit)))
- (file-name (git-file-name "cl-data-sift" version))
+ (file-name (git-file-name "cl-simple-routes" version))
(sha256
- (base32 "1v7gf0x4ibjzp0c56n9m77hxdgwcm9356zlk5n4l3fx4i0hj6146"))))
+ (base32 "0zkjl69zf1ynmqmvwccdbip3wxfyi7xplivv70qwxzd27mc0kh3k"))))
(build-system asdf-build-system/sbcl)
- (arguments
- ;; All test cases test a function that has been removed.
- `(#:tests? #f))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("parse-number" ,sbcl-parse-number)
- ("puri" ,sbcl-puri)))
- (native-inputs
- (list sbcl-lift))
- (home-page "https://github.com/archimag/data-sift";)
- (synopsis
- "Common Lisp library for validation and transformation of string data")
+ (list sbcl-cl-ppcre
+ sbcl-hunchentoot))
+ (home-page "https://gitlab.com/vancan1ty/simple-routes";)
+ (synopsis "URL routing library for Hunchentoot")
(description
- "@code{DATA-SIFT} is a Common Lisp data validation and transformation
-library inspired by @code{cl-data-format-validation} and WTForms validators.")
- (license license:llgpl))))
+ "@code{simple-routes} is a simple Common Lisp RESTful routing facility
+on top of Hunchentoot.")
+ (license license:bsd-2))))
-(define-public cl-data-sift
- (sbcl-package->cl-source-package sbcl-data-sift))
+(define-public cl-simple-routes
+ (sbcl-package->cl-source-package sbcl-simple-routes))
-(define-public ecl-data-sift
- (sbcl-package->ecl-package sbcl-data-sift))
+(define-public ecl-simple-routes
+ (sbcl-package->ecl-package sbcl-simple-routes))
-(define-public sbcl-restas
- (let ((commit "81bbbab6b36f81f846f78e71232e9d3d15f6d952")
+(define-public sbcl-simple-tasks
+ (let ((commit "745d4b54eac9bf5d6909792e63ecd2ef8d303cf2")
(revision "1"))
(package
- (name "sbcl-restas")
- (version (git-version "0.1.4" revision commit))
+ (name "sbcl-simple-tasks")
+ (version (git-version "1.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/restas";)
+ (url "https://github.com/Shinmera/simple-tasks";)
(commit commit)))
- (file-name (git-file-name "cl-restas" version))
+ (file-name (git-file-name "simple-tasks" version))
(sha256
- (base32 "00ng6jik1lwjw3bbxhijy8s0ml24lgm73liwrr01gcsb0r6wrjjn"))))
+ (base32 "1ls1pij7dvb65g4nam7nvik1218jvfk5iplr48vy290fw3lq7v98"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "contrib/restas-daemon.lisp"
- (("/lib64/") "")
- (("/lib/") "")
- (("libcap.so")
- (string-append (assoc-ref inputs "libcap")
- "/lib/libcap.so"))))))))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("data-sift" ,sbcl-data-sift)
- ("hunchentoot" ,sbcl-hunchentoot)
- ("libcap" ,libcap)
- ("routes" ,sbcl-routes)))
- (home-page "https://github.com/archimag/restas";)
- (synopsis "Common Lisp web framework")
- (description "@code{RESTAS} is a Common Lisp web application framework.")
- (license license:llgpl))))
+ (list sbcl-array-utils sbcl-bordeaux-threads sbcl-dissect))
+ (home-page "https://shinmera.github.io/simple-tasks/";)
+ (synopsis "Simple task scheduling framework")
+ (description "This is a task scheduling framework for Common Lisp.")
+ (license license:zlib))))
-(define-public cl-restas
- (sbcl-package->cl-source-package sbcl-restas))
+(define-public cl-simple-tasks
+ (sbcl-package->cl-source-package sbcl-simple-tasks))
-(define-public ecl-restas
- (sbcl-package->ecl-package sbcl-restas))
+(define-public ecl-simple-tasks
+ (sbcl-package->ecl-package sbcl-simple-tasks))
-(define-public sbcl-zsort
- (let ((commit "f6724a6fff7662a942195cedb0d7f00da59c74ed")
- (revision "1"))
+(define-public sbcl-simplified-types
+ (let ((commit "8fd0727a70a9de76289ac62c1567b8d278e7434e")
+ (revision "0"))
(package
- (name "sbcl-zsort")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-simplified-types")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jorgetavares/zsort";)
+ (url "https://github.com/marcoheisig/simplified-types";)
(commit commit)))
- (file-name (git-file-name "cl-zsort" version))
+ (file-name (git-file-name "cl-simplified-types" version))
(sha256
- (base32 "1vyklyh99712zsll4qi0m4mm8yb1nz04403vl8i57bjv5p5max49"))))
+ (base32 "1hdwmn5lz717aj6qdqmfmr3cbjl8l3giwn0fb5ca9pj83cx7fg8y"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/jorgetavares/zsort";)
- (synopsis "Collection of portable sorting algorithms in Common Lisp")
+ (list sbcl-alexandria
+ sbcl-introspect-environment
+ sbcl-trivia))
+ (home-page "https://github.com/marcoheisig/simplified-types";)
+ (synopsis "Simplify Common Lisp type specifiers")
(description
- "@code{zsort} is a collection of portable sorting algorithms. Common
-Lisp provides the @code{sort} and @code{stable-sort} functions but these can
-have different algorithms implemented according to each implementation. Also,
-the standard sorting functions might not be the best for a certain situations.
-This library aims to provide developers with more options.")
+ "Simplified-Types is a library that provides functions for simplifying
+Common Lisp type specifiers. The API consists of two functions:
+
+@itemize
+@item @code{simplify-type} takes a type specifier and, optionally, an
+environment, and returns the corresponding simplified type.
+@item @code{simplified-type-of} takes an object and returns the simplified
+type of that object.
+@end itemize")
(license license:expat))))
-(define-public cl-zsort
- (sbcl-package->cl-source-package sbcl-zsort))
+(define-public cl-simplified-types
+ (sbcl-package->cl-source-package sbcl-simplified-types))
-(define-public ecl-zsort
- (sbcl-package->ecl-package sbcl-zsort))
+(define-public ecl-simplified-types
+ (sbcl-package->ecl-package sbcl-simplified-types))
-(define-public sbcl-cl-https-everywhere
- ;; No release.
- ;; Don't forget to update the https-everywhere input.
- (let ((commit "cbcc73b985a5b1c0ce0d4ec38bc982a0538d4bd8"))
+(define-public sbcl-sketch
+ ;; No release in years.
+ (let ((commit "4cc00b08e202c7adda41391463096cf9df1705c3"))
(package
- (name "sbcl-cl-https-everywhere")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-sketch")
+ (version (git-version "2017-11" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ruricolist/cl-https-everywhere/";)
+ (url "https://github.com/vydd/sketch";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-sketch" version))
(sha256
- (base32 "1wcvx1icwym1ncd6wl1wxzkyyndrm796caalbklvjd4a2cbl3xxi"))))
+ (base32 "1qrnma8yvmxps9rz3pvlzsir37namppsldijdlr4110pcwi9j9h6"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("global-vars" ,sbcl-global-vars)
- ("parenscript" ,sbcl-parenscript)
- ("cl-markdown" ,sbcl-cl-markdown)
- ("cl-tld" ,sbcl-cl-tld)
- ("fxml" ,sbcl-fxml)
- ("overlord" ,sbcl-overlord)
- ("ppcre" ,sbcl-cl-ppcre)
- ("serapeum" ,sbcl-serapeum)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("vernacular" ,sbcl-vernacular)))
- (native-inputs
- `(("fiveam" ,sbcl-fiveam)
- ("https-everywhere"
- ,(let ((version "2021.7.13"))
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/EFForg/https-everywhere";)
- (commit version)))
- (file-name (git-file-name "https-everywhere" version))
- (sha256
- (base32
- "1k5gj29imhxf47sv3d8rxyrgr6k65scp2fm040va3nfshayslzia")))))))
+ (list sbcl-alexandria
+ sbcl-cl-geometry
+ sbcl-glkit
+ sbcl-mathkit
+ sbcl-md5
+ sbcl-sdl2
+ sbcl-sdl2-image
+ sbcl-sdl2-ttf
+ sbcl-sdl2kit
+ sbcl-split-sequence
+ sbcl-static-vectors))
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'link-https-everywhere-repo
- (lambda* (#:key inputs #:allow-other-keys)
- (let ((https-everywhere (assoc-ref inputs "https-everywhere")))
- (symlink https-everywhere "https-everywhere"))))
- (add-after 'unpack 'fix-overlord-build
- ;; Upstream bugs? See
- ;; https://github.com/ruricolist/cl-https-everywhere/issues/1.
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (rulesets.xml (string-append out "/share/common-lisp/"
(%lisp-type)
-
"/cl-https-everywhere/rulesets.xml")))
- (substitute* "build.lisp"
- (("\\(depends-on https-everywhere-version\\)") "")
- ;; Don't rebuild the rulesets just because the timestamp is
epoch.
- (("\\(vernacular:require-default
:cl-https-everywhere/rulesets-file \"rulesets.xml\"\\)")
- (format #f "(if (uiop:file-exists-p ~s)
- (compile-rulesets ~s)
- (vernacular:require-default :cl-https-everywhere/rulesets-file
\"rulesets.xml\"))"
- rulesets.xml
- rulesets.xml))
- (("\\(uiop:parse-unix-namestring
\"https-everywhere/src/chrome/content/rules/\\*\\.xml\")")
- "\"https-everywhere/src/chrome/content/rules/*.xml\"")
- (("\\(out temp :external-format :utf-8\\)")
- "(out temp :external-format :utf-8 :if-exists
:supersede)")))
- #t)))))
- (home-page "https://github.com/ruricolist/cl-https-everywhere/";)
- (synopsis "Use HTTPS Everywhere rules from Lisp")
+ '(#:asd-systems '("sketch" "sketch-examples")))
+ (home-page "https://github.com/vydd/sketch";)
+ (synopsis "Creative framework for electronic art, visual design and
more")
(description
- "CL-HTTPS-EVERYWHERE parses HTTPS Everywhere rulesets and makes them
-available for use in Lisp programs.")
- (license (list license:expat
- ;; For the ruleset
- license:gpl2+)))))
+ "Sketch is a Common Lisp environment for the creation of electronic
+art, visual design, game prototyping, game making, computer graphics,
+exploration of human-computer interaction and more. It is inspired by
+the Processing language and shares some of the API.")
+ (license license:expat))))
-(define-public cl-https-everywhere
- (sbcl-package->cl-source-package sbcl-cl-https-everywhere))
+(define-public cl-sketch
+ (sbcl-package->cl-source-package sbcl-sketch))
-(define-public sbcl-magic-ed
- (let ((commit "30bb27832d4e3e362578e7320934638f9889a8c4")
- (revision "1"))
+(define-public ecl-sketch
+ (sbcl-package->ecl-package sbcl-sketch))
+
+(define-public sbcl-skippy
+ (let ((commit "e456210202ca702c792292c5060a264d45e47090")
+ (revision "0"))
(package
- (name "sbcl-magic-ed")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-skippy")
+ (version (git-version "1.3.12" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sanel/magic-ed";)
+ (url "https://github.com/xach/skippy";)
(commit commit)))
- (file-name (git-file-name "cl-magic-ed" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1j6il4lif0dy6hqiz6n91yl8dvii9pk1i9vz0faq5mnr42mr7i5f"))))
+ (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/sanel/magic-ed";)
- (synopsis "Editing facility for Common Lisp REPL")
+ (home-page "https://xach.com/lisp/skippy/";)
+ (synopsis "Common Lisp library for GIF images")
(description
- "Magic (ed) is a tiny editing facility for Common Lisp, where you can
-directly load, edit, manipulate and evaluate file or file content from REPL.
-This package also can be a starting point for people who are not accustomed to
-Emacs or SLIME and would like to continue using their default terminal/console
-editor with Common Lisp.")
- (license license:expat))))
+ "Skippy is a Common Lisp library to read and write GIF image files.")
+ (license license:bsd-2))))
+
+(define-public cl-skippy
+ (sbcl-package->cl-source-package sbcl-skippy))
+
+(define-public ecl-skippy
+ (sbcl-package->ecl-package sbcl-skippy))
+
+(define-public sbcl-slime-swank
+ ;; Update together with emacs-slime.
+ (package
+ (name "sbcl-slime-swank")
+ (version "2.29.1")
+ (source
+ (origin
+ (file-name (git-file-name "cl-slime-swank" version))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/slime/slime/";)
+ (commit (string-append "v" version))))
+ (sha256
+ (base32 "1fcasqsdfwsphkfx1vd3r5mr89vgvzb9g2dbw82mc9lijg1mr1ki"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The doc folder drags `gawk' into the closure. Doc is already
+ ;; provided by emacs-slime.
+ `(begin
+ (delete-file-recursively "doc")
+ #t))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("swank" "swank/exts")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'set-fasl-directory
+ (lambda* (#:key outputs #:allow-other-keys)
+ (substitute* "swank-loader.lisp"
+ (("\\(probe-file fasl\\)" all)
+ ;; Do not try to delete Guix store files.
+ (string-append
+ all "\n"
+ " (not (equal (subseq (pathname-directory fasl) 1 3)"
+ " '(\"gnu\" \"store\"))) ; XXX: GUIX PATCH"))))))))
+ (home-page "https://github.com/slime/slime";)
+ (synopsis "Common Lisp Swank server")
+ (description
+ "This is only useful if you want to start a Swank server in a Lisp
+processes that doesn't run under Emacs. Lisp processes created by
+@command{M-x slime} automatically start the server.")
+ (license (list license:gpl2+ license:public-domain))))
-(define-public cl-magic-ed
- (sbcl-package->cl-source-package sbcl-magic-ed))
+(define-public cl-slime-swank
+ (sbcl-package->cl-source-package sbcl-slime-swank))
-(define-public ecl-magic-ed
- (sbcl-package->ecl-package sbcl-magic-ed))
+(define-public ecl-slime-swank
+ (sbcl-package->ecl-package sbcl-slime-swank))
-(define-public sbcl-maxpc
- (let ((commit "e5e58d053039517d30fd59ab2d128256b87790d5")
- (revision "1"))
+(define-public sbcl-slite
+ (let ((commit "942a95330592d30be5ac02fb1b697fb14ccbf1af")
+ (revision "0"))
(package
- (name "sbcl-maxpc")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-slite")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eugeneia/maxpc";)
+ (url "https://github.com/tdrhq/slite/";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "slite" version))
(sha256
- (base32 "15wrjbr2js6j67c1dd4p2qxj49q9iqv1lhb7cwdcwpn79crr39gf"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://mr.gy/software/maxpc/api.html";)
- (synopsis
- "Library for writing parsers and lexers based on combinatory parsing")
- (description
- "@emph{Max’s Parser Combinators} is a simple and pragmatic library for
-writing parsers and lexers based on combinatory parsing. MaxPC is capable of
-parsing deterministic, context-free languages, provides powerful tools for
-parse tree transformation and error handling, and can operate on
-@dfn{sequences} and @dfn{streams}. It supports unlimited backtracking, but
-does not implement @url{http://pdos.csail.mit.edu/~baford/packrat/thesis/,
-Packrat Parsing}. Instead, MaxPC achieves good performance through its
-optimized primitives, and explicit separation of matching and capturing input.
-In practice, MaxPC parsers perform better on typical computer languages—when
-compared to Packrat parsers—at the expense of not producing linear-time
-parsers.")
- (license license:agpl3))))
-
-(define-public cl-maxpc
- (sbcl-package->cl-source-package sbcl-maxpc))
-
-(define-public ecl-maxpc
- (sbcl-package->ecl-package sbcl-maxpc))
-
-(define-public sbcl-snakes
- (let ((commit "8c7eae579bb24539dbd584a81a1049f3d3ff8bf8")
- (revision "0"))
- (package
- (name "sbcl-snakes")
- (version (git-version "0.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/BnMcGn/snakes";)
- (commit commit)))
- (sha256
- (base32 "1ibp919qcpm6kg67b507kpjzdlhpdjr7vkh9vabln3a75k8lnlsg"))
- (file-name (git-file-name "cl-snakes" commit))))
+ (base32 "0b4c4vs1zlhcvr9flv8bx76v9hrwc9qmazmp60407q7cghn0k8zk"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-cl-cont
- sbcl-cl-utilities
- sbcl-closer-mop
- sbcl-fiveam
- sbcl-iterate))
- (home-page "https://github.com/BnMcGn/snakes";)
- (synopsis "Python-like generators for Common Lisp")
+ (list sbcl-cl-str
+ sbcl-fiveam
+ sbcl-parachute
+ sbcl-lisp-unit2))
+ (home-page "https://github.com/tdrhq/slite";)
+ (synopsis "Common Lisp system for Slite ")
(description
- "This package provides Python style generators for Common Lisp.
-It also includes a port of itertools.")
+ "This package provides the Common Lisp part of the emacs-slite test
runner.")
(license license:asl2.0))))
-(define-public cl-snakes
- (sbcl-package->cl-source-package sbcl-snakes))
+(define-public cl-slite
+ (sbcl-package->cl-source-package sbcl-slite))
-(define-public ecl-snakes
- (sbcl-package->ecl-package sbcl-snakes))
+(define-public ecl-slite
+ (sbcl-package->ecl-package sbcl-slite))
-(define-public sbcl-random-state
- (let ((commit "c270d4f15e0b66ba9680ca8734a5de56959cb118")
- (revision "1"))
+(define-public emacs-slite
+ (package
+ (inherit sbcl-slite)
+ (name "emacs-slite")
+ (build-system emacs-build-system)
+ (synopsis "SLIme-based TEst runner for FiveAM and Parachute Tests")
+ (description
+ "Slite interactively runs your Common Lisp tests (currently only FiveAM
+and Parachute are supported). It allows you to see the summary of test
+failures, jump to test definitions, rerun tests with debugger all from inside
+Emacs.
+
+In order to work, this also requires the slite Common Lisp system to be
+present. See the code@{*cl-slite packages}.")))
+
+(define-public sbcl-slot-extra-options
+ (let ((commit "29517d980325cd63744f1acf4cfe5c8ccec2b318"))
(package
- (name "sbcl-random-state")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-slot-extra-options")
+ (version (git-version "1.1.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/random-state";)
+ (url "https://github.com/some-mthfka/slot-extra-options/";)
(commit commit)))
- (file-name (git-file-name "cl-random-state" version))
+ (file-name (git-file-name "cl-slot-extra-options" version))
(sha256
- (base32 "0r3bk6hqpr0qmpza93pknl8wpsd6y0yy9qg7vz751a7gzzww9vj6"))))
+ (base32 "1b2swhjjs0w1034cy045q8l3ndmci7rjawka39q23vncy6d90497"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/random-state/";)
- (synopsis "Portable random number generation")
+ (list sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-serapeum
+ sbcl-iterate))
+ (native-inputs
+ (list sbcl-parachute))
+ (home-page "https://github.com/some-mthfka/slot-extra-options/";)
+ (synopsis "Extra options for slots using MOP")
(description
- "This library is a collection of @dfn{pseudo random number generators}.
-
-While Common Lisp does provide a @code{RANDOM} function, it does not allow the
-user to pass an explicit @code{SEED}, nor to portably exchange the random
-state between implementations. This can be a headache in cases like games,
-where a controlled seeding process can be very useful.
-
-For both curiosity and convenience, this library offers multiple algorithms to
-generate random numbers, as well as a bunch of generally useful methods to
-produce desired ranges.")
- (license license:zlib))))
-
-(define-public cl-random-state
- (sbcl-package->cl-source-package sbcl-random-state))
-
-(define-public ecl-random-state
- (sbcl-package->ecl-package sbcl-random-state))
+ "This library lets you build a metaclass which in turn lets you specify
+extra slot options in its classes. Options may be easily inspected and custom
+inheritance may be set up. The Meta-Object Protocol (MOP) is used for the
+implementation - through @code{closer-mop}. Some convenience function for
+processing slot options are also available.
-(define-public sbcl-decimals
- (package
- (name "sbcl-decimals")
- (version "2021")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tlikonen/cl-decimals";)
- (commit version)))
- (file-name (git-file-name "cl-decimals" version))
- (sha256
- (base32 "0wn5hq1pwd3wpjqqhpjzarcdk1q6416g8y447iaf55j5nbhlmbn6"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/tlikonen/cl-decimals";)
- (synopsis "Decimal number parser and formatting package for Common Lisp")
- (description "This Common Lisp package offers functions for parsing and
-formatting decimal numbers. The package's main interface are the functions
-@code{parse-decimal-number} and @code{format-decimal-number}. The former is
-for parsing strings for decimal numbers and the latter for pretty-printing
-them as strings.")
- (license license:cc0)))
+Possible use case: you want to automatically set up some definitions based on
+some slots, but you want to have control over it right in the class
+definition.")
+ (license license:lgpl3+))))
-(define-public cl-decimals
- (sbcl-package->cl-source-package sbcl-decimals))
+(define-public cl-slot-extra-options
+ (sbcl-package->cl-source-package sbcl-slot-extra-options))
-(define-public ecl-decimals
- (sbcl-package->ecl-package sbcl-decimals))
+(define-public ecl-slot-extra-options
+ (sbcl-package->ecl-package sbcl-slot-extra-options))
-(define-public sbcl-simple-date-time
- (let ((commit "d6992afddedf67a8172a0120a1deac32afcaa2e8")
- (revision "1"))
+(define-public sbcl-slynk
+ ;; Update together with emacs-sly.
+ (let ((commit "9c43bf65b967e12cef1996f1af5f0671d8aecbf4")
+ (revision "9"))
(package
- (name "sbcl-simple-date-time")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-slynk")
+ (version (git-version "1.0.43" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/quek/simple-date-time";)
- (commit commit)))
- (file-name (git-file-name "cl-simple-date-time" version))
+ (uri
+ (git-reference
+ (url "https://github.com/joaotavora/sly";)
+ (commit commit)))
(sha256
- (base32 "06iwf13gcdyqhkzfkcsfdl8iqbdl44cx01c3fjsmhl0v1pp8h2m4"))))
+ (base32 "15nyr02ykkws4q79jcmxcawddg8sgq9v5l8k7jv7gg3hnpzxjlb2"))
+ (file-name (git-file-name "cl-slynk" version))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-ppcre))
- (home-page "https://github.com/quek/simple-date-time";)
- (synopsis "Date and time library for Common Lisp")
- (description "This package is a simple date and time library.")
- (license license:bsd-4))))
+ (outputs '("out" "image"))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'create-asdf-configuration 'build-image
+ (lambda* (#:key outputs #:allow-other-keys)
+ (build-image (string-append
+ (assoc-ref outputs "image")
+ "/bin/slynk")
+ outputs
+ #:dependencies '("slynk"
+ "slynk/arglists"
+ "slynk/fancy-inspector"
+ "slynk/package-fu"
+ "slynk/mrepl"
+ "slynk/trace-dialog"
+ "slynk/profiler"
+ "slynk/stickers"
+ "slynk/indentation"
+ "slynk/retro"))
+ #t)))))
+ (synopsis "Common Lisp IDE for Emacs")
+ (description "SLY is a fork of SLIME, an IDE backend for Common Lisp.
+It also features a completely redesigned REPL based on Emacs's own
+full-featured @code{comint-mode}, live code annotations, and a consistent
interactive
+button interface. Everything can be copied to the REPL. One can create
+multiple inspectors with independent history.")
+ (home-page "https://github.com/joaotavora/sly";)
+ (license license:public-domain)
+ (properties `((cl-source-variant . ,(delay cl-slynk)))))))
-(define-public cl-simple-date-time
- (sbcl-package->cl-source-package sbcl-simple-date-time))
+(define-public cl-slynk
+ (sbcl-package->cl-source-package sbcl-slynk))
-(define-public ecl-simple-date-time
- (sbcl-package->ecl-package sbcl-simple-date-time))
+(define-public ecl-slynk
+ (let ((pkg (sbcl-package->ecl-package sbcl-slynk)))
+ (package
+ (inherit pkg)
+ (outputs '("out"))
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (delete 'build-image))))))))
-(define-public sbcl-april
- (let ((commit "bdd74f168ec82f28fe4ab692f2c0af39441a5701")
- (revision "3"))
+(define-public sbcl-smart-buffer
+ (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
+ (revision "1"))
(package
- (name "sbcl-april")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-smart-buffer")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phantomics/april";)
+ (url "https://github.com/fukamachi/smart-buffer";)
(commit commit)))
- (file-name (git-file-name "cl-april" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0hvlp2286z1ksa7jr7r661kdr0lpfv25n5chl72jrzq5zz70lidx"))
- (modules '((guix build utils)))
- (snippet '(begin
- ;; Remove bundled Apache-relicensed MaxPC.
- (delete-file-recursively "maxpc-apache")
- ;; Ensure references are to upstream MaxPC.
- (substitute* "vex/vex.asd"
- (("maxpc-apache") "maxpc"))))))
+ (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("smart-buffer-test" "smart-buffer")))
+ (native-inputs
+ (list sbcl-prove
+ sbcl-babel))
(inputs
- (list sbcl-alexandria
- sbcl-array-operations
- sbcl-cl-ppcre
- sbcl-cl-unicode
- sbcl-lparallel
- sbcl-maxpc
- sbcl-parse-number
- sbcl-prove
- sbcl-random-state
- sbcl-serapeum
- sbcl-simple-date-time
- sbcl-symbol-munger
- sbcl-trivia))
- (home-page "https://github.com/phantomics/april";)
- (synopsis "Array Programming Re-Imagined in Lisp")
+ (list sbcl-xsubseq sbcl-flexi-streams))
+ (home-page "https://github.com/fukamachi/smart-buffer";)
+ (synopsis "Smart octets buffer")
(description
- "April compiles a subset of the APL programming language into
-Common Lisp. Leveraging Lisp's powerful macros and numeric processing
-faculties, it brings APL's expressive potential to bear for Lisp developers.
-Replace hundreds of lines of number-crunching code with a single line of
-APL.")
- (license license:asl2.0))))
+ "Smart-buffer provides an output buffer which changes the destination
+depending on content size.")
+ (license license:bsd-3))))
-(define-public cl-april
- (sbcl-package->cl-source-package sbcl-april))
+(define-public cl-smart-buffer
+ (sbcl-package->cl-source-package sbcl-smart-buffer))
-(define-public ecl-april
- (sbcl-package->ecl-package sbcl-april))
+(define-public ecl-smart-buffer
+ (sbcl-package->ecl-package sbcl-smart-buffer))
-(define-public sbcl-cl-sxml
- (let ((commit "e5542b1d9bd6cee03ae27547d00660ccfbb60109")
- (revision "1"))
+(define-public sbcl-smug
+ (let ((commit "647a2428df297e1dd183ba7c19574bdb1320ae79")
+ (revision "0"))
(package
- (name "sbcl-cl-sxml")
- (version (git-version "0.0.0" revision commit))
- (source
+ (name "sbcl-smug")
+ (version (git-version "0.0.0" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eadmund/cl-sxml";)
+ (url "https://github.com/drewc/smug";)
(commit commit)))
- (file-name (git-file-name "cl-sxml" version))
+ (file-name (git-file-name "cl-smug" version))
(sha256
- (base32 "1105s9whidq1lf0lli2wdhcfcs5gwzxa0h1x3izx4mp2p7psvciz"))))
- (build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cxml))
- (native-inputs
- (list sbcl-fiveam
- sbcl-flexi-streams))
- (home-page "https://github.com/eadmund/cl-sxml";)
- (synopsis "SXML parsing for Common Lisp")
- (description
- "@code{CL-SXML} implements Oleg Kiselyov’s SXML, an S-expression-based
-rendering of the XML Infoset.")
- (license license:gpl3+))))
+ (base32 "13gzkj9skya2ziwclk041v7sif392ydbvhvikhg2raa3qjcxb3rq"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f)) ; There are no tests.
+ (synopsis "Parser combinators for Common Lisp")
+ (description
+ "@code{cl-smug} is a library for parsing text, based on monadic parser
+combinators. Using a simple technique from the functional programming
+camp, @code{cl-smug} makes it simple to create quick extensible recursive
+descent parsers without funky syntax or impenetrable macrology.")
+ (home-page "https://smug.drewc.ca/";)
+ (license license:expat))))
-(define-public cl-sxml
- (sbcl-package->cl-source-package sbcl-cl-sxml))
+(define-public cl-smug
+ (sbcl-package->cl-source-package sbcl-smug))
-(define-public ecl-cl-sxml
- (sbcl-package->ecl-package sbcl-cl-sxml))
+(define-public ecl-smug
+ (sbcl-package->ecl-package sbcl-smug))
-(define-public sbcl-lorem-ipsum
- (let ((commit "04a1839a03b53c954e799b9cf570ac915b032ce8")
+(define-public sbcl-snakes
+ (let ((commit "8c7eae579bb24539dbd584a81a1049f3d3ff8bf8")
(revision "0"))
(package
- (name "sbcl-lorem-ipsum")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-snakes")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/lorem-ipsum";)
+ (url "https://github.com/BnMcGn/snakes";)
(commit commit)))
(sha256
- (base32 "1530qq0bk3xr25m77q96pbi1idnxdkax8cwmvq4ch03rfjy34j7n"))
- (file-name (git-file-name "cl-lorem-ipsum" commit))))
+ (base32 "1ibp919qcpm6kg67b507kpjzdlhpdjr7vkh9vabln3a75k8lnlsg"))
+ (file-name (git-file-name "cl-snakes" commit))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/phoe/lorem-ipsum";)
- (synopsis "Lorem ipsum generator in portable Common Lisp")
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cl-cont
+ sbcl-cl-utilities
+ sbcl-closer-mop
+ sbcl-fiveam
+ sbcl-iterate))
+ (home-page "https://github.com/BnMcGn/snakes";)
+ (synopsis "Python-like generators for Common Lisp")
(description
- "This package provides functions for generating lorem ipsum text.")
- (license license:expat))))
+ "This package provides Python style generators for Common Lisp.
+It also includes a port of itertools.")
+ (license license:asl2.0))))
-(define-public cl-lorem-ipsum
- (sbcl-package->cl-source-package sbcl-lorem-ipsum))
+(define-public cl-snakes
+ (sbcl-package->cl-source-package sbcl-snakes))
-(define-public ecl-lorem-ipsum
- (sbcl-package->ecl-package sbcl-lorem-ipsum))
+(define-public ecl-snakes
+ (sbcl-package->ecl-package sbcl-snakes))
-(define-public sbcl-asd-generator
- (let ((commit "27f94971a7c68c4dcb51e3f6be4142743d0c44e8")
- (revision "0"))
+(define-public sbcl-spatial-trees
+ ;; There have been no releases.
+ (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
+ (revision "1"))
(package
- (name "sbcl-asd-generator")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-spatial-trees")
+ (version (git-version "0" revision commit))
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/phoe/asd-generator";)
- (commit commit)))
- (sha256
- (base32 "0yiybl7b9x1f85v0drj0yw9821y3yfhya4n6gycnv5vvx6jp9by4"))
- (file-name (git-file-name "cl-asd-generator" commit))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpav/spatial-trees";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; We cannot build "spatial-trees-viz" here because it depends on
+ ;; mcclim which depends on spatial-trees. FIXME: Break the circle.
+ '(#:asd-systems '("spatial-trees" "spatial-trees.nns")))
(inputs
- (list sbcl-cl-fad
- sbcl-iterate
- sbcl-alexandria
- sbcl-trivia))
- (home-page "https://github.com/phoe/asd-generator";)
- (synopsis "Automatic generator for .asd files")
+ (list sbcl-alexandria sbcl-optima sbcl-iterate))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/rpav/spatial-trees";)
+ (synopsis "Dynamic index data structures for spatially-extended data")
(description
- "This package provides an automatic generator for ASDF's .asd files.")
- (license license:gpl3+))))
+ "Spatial-trees is a set of dynamic index data structures for
+spatially-extended data.")
+ (license license:bsd-3))))
-(define-public cl-asd-generator
- (sbcl-package->cl-source-package sbcl-asd-generator))
+(define-public cl-spatial-trees
+ (sbcl-package->cl-source-package sbcl-spatial-trees))
-(define-public ecl-asd-generator
- (sbcl-package->ecl-package sbcl-asd-generator))
+(define-public ecl-spatial-trees
+ (sbcl-package->ecl-package sbcl-spatial-trees))
+
+(define-public sbcl-special-functions
+ (let ((commit "f3ca2792ff3f8351839c366413da6b1bb2965a58")
+ (revision "0"))
+ (package
+ (name "sbcl-special-functions")
+ (version (git-version "1.2.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Lisp-Stat/special-functions";)
+ (commit commit)))
+ (file-name (git-file-name "cl-special-functions" version))
+ (sha256
+ (base32 "092szffy7zfxgrvfck11wnj8l0mgcym13yiafj01ad02lbj1fnnv"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam
+ sbcl-select
+ sbcl-cl-variates))
+ (inputs
+ (list sbcl-alexandria-plus
+ sbcl-float-features
+ sbcl-let-plus
+ sbcl-numerical-utilities))
+ (home-page "https://lisp-stat.dev/docs/resources/special-functions/";)
+ (synopsis "Special functions in Common Lisp")
+ (description "This library implements
+@url{http://specialfunctionswiki.org/index.php/Main_Page, special
+functions} and has a focus on high accuracy double-float calculations
+using the latest algorithms.")
+ (license license:ms-pl))))
+
+(define-public cl-special-functions
+ (sbcl-package->cl-source-package sbcl-special-functions))
+
+(define-public ecl-special-functions
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-special-functions))
+ ;; https://github.com/Lisp-Stat/special-functions/issues/4
+ (arguments (list #:tests? #f))))
-(define-public sbcl-cl-gopher
- (let ((commit "0899e7fa2134206f9d9778c7d53c49b7a59ff070")
- (revision "3"))
+(define-public sbcl-specialization-store
+ (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3")
+ (revision "1"))
(package
- (name "sbcl-cl-gopher")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-specialization-store")
+ (version (git-version "0.0.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/knusbaum/cl-gopher";)
+ (url "https://github.com/markcox80/specialization-store";)
(commit commit)))
- (file-name (git-file-name "cl-gopher" version))
+ (file-name (git-file-name "specialization-store" version))
(sha256
- (base32 "1ky4s33m5d0wvdaqji12pxr93qqfl5x62zjp3m4ihbdj0ws3yw2f"))
- (snippet
- '(begin
- ;; These files are mostly examples (that assume Quicklisp) which
- ;; drag the SBCL package into the CL package.
- (for-each delete-file
- '("cl-gopher-network.lsh"
- "cl-gopher-start.lsh"))
- #t))))
+ (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-bordeaux-threads
- sbcl-drakma
- sbcl-flexi-streams
- sbcl-quri
- sbcl-split-sequence
- sbcl-usocket))
- (home-page "https://github.com/knusbaum/cl-gopher";)
- (synopsis "Gopher protocol library in Common Lisp")
+ (list sbcl-alexandria sbcl-introspect-environment))
+ (home-page "https://github.com/markcox80/specialization-store";)
+ (synopsis "Different type of generic function for Common Lisp")
(description
- "@code{cl-gopher} is a Common Lisp library for interacting with the
-Gopher protocol.
-
-It is suitable for building both clients and servers, and provides a sample
-client.")
+ "SPECIALIZATION-STORE system provides a new kind of function, called
+a store function, whose behavior depends on the types of objects passed to the
+function.")
(license license:bsd-2))))
-(define-public cl-gopher
- (sbcl-package->cl-source-package sbcl-cl-gopher))
+(define-public cl-specialization-store
+ (sbcl-package->cl-source-package sbcl-specialization-store))
-(define-public ecl-cl-gopher
- (sbcl-package->ecl-package sbcl-cl-gopher))
+(define-public ecl-specialization-store
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-specialization-store))
+ (arguments
+ ;; TODO: Find why the tests get stuck forever; disable them for now.
+ `(#:tests? #f))))
-(define-public sbcl-phos
- (let ((commit "6620b82b091cdfed655e1093ef045dbe518d5474"))
+(define-public sbcl-specialized-function
+ (let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247")
+ (revision "3"))
(package
- (name "sbcl-phos")
- (version (git-version "0.0.1" "1" commit))
+ (name "sbcl-specialized-function")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/omar-polo/phos";)
+ (url "https://github.com/numcl/specialized-function";)
(commit commit)))
- (file-name (git-file-name "phos" version))
+ (file-name (git-file-name "specialized-function" version))
(sha256
- (base32
- "1zwci86rkbaiix0w2gd5q6nr8v2vv945pkvwp0j240iyzd4hfxr3"))))
+ (base32 "19hfgc83b7as630r1w9r8yl0v6xq3dn01vcrl0bd4pza5hgjn4la"))))
(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
- (list sbcl-quri sbcl-cl-ppcre sbcl-trivia sbcl-usocket sbcl-cl+ssl
- ;; For the experimental GUI:
- sbcl-nodgui))
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("lisp-namespace" ,sbcl-lisp-namespace)
+ ("trivia" ,sbcl-trivia)
+ ("trivial-cltl2" ,sbcl-trivial-cltl2)
+ ("type-r" ,sbcl-type-r)))
(native-inputs
- (list sbcl-clunit2))
- (home-page "https://github.com/omar-polo/phos";)
- (synopsis "Gemini client library and experimental GUI")
- (description "This package contains a Gemini client library for Common
-Lisp. A subsystem offers an experimental GUI Gemini client.")
- (license license:isc))))
+ (list sbcl-fiveam)))))
-(define-public cl-phos
- (sbcl-package->cl-source-package sbcl-phos))
+(define-public cl-specialized-function
+ (sbcl-package->cl-source-package sbcl-specialized-function))
-(define-public ecl-phos
- (sbcl-package->ecl-package sbcl-phos))
+(define-public ecl-specialized-function
+ (sbcl-package->ecl-package sbcl-specialized-function))
-(define-public sbcl-germinal
- (let ((commit "5bfb371ea57dae8985c0e1c6f184f0338487d684")
- (revision "0"))
+(define-public sbcl-speechless
+ (let ((commit "50e9b03bdfc8a3bc0836a650d92de47b51c39834")
+ (revision "1"))
(package
- (name "sbcl-germinal")
+ (name "sbcl-speechless")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.carcosa.net/jmcbray/germinal";)
+ (url "https://github.com/Shirakumo/speechless/";)
(commit commit)))
- (file-name (git-file-name "cl-germinal" version))
(sha256
- (base32 "12jypa8m10825lp5yxfcm1fyk3r4ziwcri7ndxa0m5dz0y7hggck"))))
+ (base32 "1k0kc2l98jyv04l48xnj38qwpddan80c7m41srjld64jkna0fhas"))
+ (file-name (git-file-name "speechless" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-cl+ssl
- sbcl-cl-fad
- sbcl-cl-interpol
- sbcl-cl-ppcre
- sbcl-cl-str
- sbcl-local-time
- sbcl-osicat
- sbcl-ppath
- sbcl-quri
- sbcl-trivial-mimes
- sbcl-uax-15
- sbcl-usocket))
- (home-page "https://git.carcosa.net/jmcbray/germinal";)
- (synopsis "Gemini protocol server")
- (description "Germinal is a server for the Gemini protocol, written in
-Common Lisp.")
- (license license:agpl3))))
+ (list sbcl-cl-markless
+ sbcl-documentation-utils))
+ (synopsis "Dialogue system language implementation")
+ (description "This is a system implementing an advanced dialogue system
+that is capable of complex dialogue flow including choice trees and
+conditional branching. Speechless was first developed for the
+\"Kandria\" (@url{https://kandria.com}) game, and has since been separated and
+made public in the hopes that it may find use elsewhere or inspire other
+developers to build similar systems.
-(define-public cl-germinal
- (sbcl-package->cl-source-package sbcl-germinal))
+Speechless is based on the
+\"Markless\" (@url{https://shirakumo.github.io/markless}) document standard
+for its syntax and makes use of Markless' ability to be extended to add
+additional constructs useful for dialogue systems.
-(define-public ecl-germinal
- (sbcl-package->ecl-package sbcl-germinal))
+Speechless can compile dialogue from its base textual form into an efficient
+instruction set, which is then executed when the game is run. Execution of the
+dialogue is completely engine-agnostic, and only requires some simple
+integration with a client protocol to run.
-(define-public sbcl-css-lite
- (let ((commit "6ee4e6212ed56943d665df163d2a834b122e6273")
- (revision "0"))
+Thanks to Markless' extensibility, Speechless can also be further extended to
+include additional syntax and constructs that may be useful for your
+particular game.")
+ (home-page "http://shirakumo.github.io/speechless/";)
+ (license license:zlib))))
+
+(define-public speechless
+ (sbcl-package->cl-source-package sbcl-speechless))
+
+(define-public ecl-speechless
+ (sbcl-package->ecl-package sbcl-speechless))
+
+(define-public sbcl-spinneret
+ ;; No release since 2019, no tags.
+ (let ((commit "d4398b5a344b5c59e497c9ee78fdbae7cc434f74"))
(package
- (name "sbcl-css-lite")
- (version "0.01")
+ (name "sbcl-spinneret")
+ (version (git-version "3.0" "6" commit))
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/paddymul/css-lite";)
- (commit commit)))
- (sha256
- (base32 "1lyvw7hcy09k5qs6icky23s13psqxncyc73hdyiimb66p0jx6k0d"))
- (file-name (git-file-name "cl-css-lite" commit))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/ruricolist/spinneret/";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1mdd92gfxfdsd81fcd8fgz8z7dwsb0kcv7zyzdgnw8lavkib5zly"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/paddymul/css-lite";)
- (synopsis "CSS grammar for Lisp")
+ (inputs
+ (list sbcl-alexandria
+ sbcl-global-vars
+ sbcl-parenscript
+ sbcl-cl-markdown
+ sbcl-cl-ppcre
+ sbcl-serapeum
+ sbcl-trivial-gray-streams))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/ruricolist/spinneret";)
+ (synopsis "Common Lisp HTML5 generator")
(description
- "@code{cl-css-lite} is a library for generating CSS from an s-exp based
-syntax. When compiled with Parenscript loaded in the Lisp image, it
-also provides the same CSS generation facilities in Parenscript-generated
-JavaScript code.")
- (license license:bsd-3))))
+ "In the crowded space of Common Lisp HTML generators, Spinneret
+occupies the following coordinates:
-(define-public cl-css-lite
- (sbcl-package->cl-source-package sbcl-css-lite))
+@itemize
-(define-public ecl-css-lite
- (sbcl-package->ecl-package sbcl-css-lite))
+@item Modern. Targets HTML5. Does not treat XML and HTML as the same
+problem. Assumes you will be serving your documents as UTF-8.
-(define-public sbcl-nhooks
+@item Composable. Makes it easy to refactor HTML generation into separate
+functions and macros.
+
+@item Pretty. Treats HTML as a document format, not a serialization. Output
+is idiomatic and readable, following the coding style of the HTML5
+specification.
+
+@item Aggressive. If something can be interpreted as HTML, then it will be,
+meaning that some Lisp forms can't be mixed with HTML syntax. In the
+trade-off between 90% convenience and 10% correctness Spinneret is on the side
+of convenience.
+
+@item Bilingual. Spinneret (after loading @code{spinneret/ps}) has the same
+semantics in Lisp and Parenscript.
+
+@end itemize\n")
+ (license license:expat))))
+
+(define-public cl-spinneret
+ (sbcl-package->cl-source-package sbcl-spinneret))
+
+(define-public ecl-spinneret
+ (sbcl-package->ecl-package sbcl-spinneret))
+
+(define-public sbcl-split-sequence
(package
- (name "sbcl-nhooks")
- (version "1.2.2")
+ (name "sbcl-split-sequence")
+ (version "2.0.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/nhooks";)
- (commit version)))
- (file-name (git-file-name "cl-nhooks" version))
+ (url "https://github.com/sharplispers/split-sequence";)
+ (commit (string-append "v" version))))
(sha256
(base32
- "1m9dfp7wjm8k16x45qnw258ca8gnic3k2ik79sdn5gxcx6qxy3g8"))))
+ "172k7iv775kwism6304p6z7mqpjvipl57nq1bgvmbk445943fmhq"))
+ (file-name (git-file-name "split-sequence" version))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-serapeum))
(native-inputs
- (list sbcl-lisp-unit2))
- (home-page "https://github.com/atlas-engineer/nhooks";)
- (synopsis "Hook facility for Common Lisp")
- (description "This package holds an enhanced implementation of
-hooks (extension points). It works similarly to Emacs hooks with crucial
-improvements:
-
-@itemize
-
-@item If the compiler allows it (such as SBCL), type-checking is performed at
-compile-time and at run-time when adding handlers to a hook.
-
-@item On failure, multiple restarts are offered, such as disabling the
-offending handler or simply continuing to the next function.
-
-@item The hook handler execution order and combination can be customized.
-
-@item Anonymous functions (lambdas) can be added to hooks as handler objects.
-When inspecting hooks, readable names are thus exposed instead of lambda
-blackboxes. Handlers are compared through their names (through the mandatory
-name slot). A hook can not contain multiple handlers with the same name.
-
-@item A special provision is taken for “setters”, handlers that are meant to
-set a given place to a given values. Such handler objects can be compared and
-identified uniquely.
-
-@end itemize\n")
+ (list sbcl-fiveam))
+ (synopsis "Member of the Common Lisp Utilities family of programs")
+ (description
+ "Splits sequence into a list of subsequences delimited by objects
+satisfying the test.")
+ (home-page "https://cliki.net/split-sequence";)
(license license:expat)))
-(define-public cl-nhooks
- (sbcl-package->cl-source-package sbcl-nhooks))
+(define-public cl-split-sequence
+ (sbcl-package->cl-source-package sbcl-split-sequence))
-(define-public ecl-nhooks
- (sbcl-package->ecl-package sbcl-nhooks))
+(define-public ecl-split-sequence
+ (sbcl-package->ecl-package sbcl-split-sequence))
-(define-public sbcl-wordnet
- (let ((commit "8cd0db8f5e84e7a930fa74e590ecddf75cd8e5d6")
+(define-public sbcl-st-json
+ (let ((commit "4a0025bcc5b6921454822f1b9f38f697b4eeaf43")
(revision "0"))
(package
- (name "sbcl-wordnet")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-st-json")
+ (version (git-version "0.0.0" revision commit))
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/phoe/wordnet";)
- (commit commit)))
- (sha256
- (base32 "07p60k295fsfcp0gmkqhrxd68hb38aqva8f4k8xk8bqqxxf42vkq"))
- (file-name (git-file-name "cl-wordnet" commit))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/marijnh/ST-JSON";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "06qrhr5iw73k96lai2x9w52l6gnmlxy7fsr0r35gz6nz1f71x7gx"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f)) ; There are no tests.
- (inputs
- (list sbcl-split-sequence))
- (home-page "https://github.com/phoe/wordnet";)
- (synopsis "Common Lisp interface to WordNet")
+ (home-page "https://marijnhaverbeke.nl/st-json/";)
+ (synopsis "JSON for Common Lisp")
(description
- "This software provides an interface by which Common Lisp programs can
-access lexicographic data from WordNet.")
- (license license:expat))))
-
-(define-public cl-wordnet
- (sbcl-package->cl-source-package sbcl-wordnet))
-
-(define-public ecl-wordnet
- (sbcl-package->ecl-package sbcl-wordnet))
-
-(define-public sbcl-nfiles
- (package
- (name "sbcl-nfiles")
- (version "1.1.4")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/atlas-engineer/nfiles";)
- (commit version)))
- (file-name (git-file-name "cl-nfiles" version))
- (sha256
- (base32
- "1a8zsphbbl9r4sdm95kgm4ljd9b148c9fnwlq7f930fh9826kf72"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list gnupg
- sbcl-alexandria
- sbcl-nclasses
- sbcl-quri
- sbcl-serapeum
- sbcl-trivial-garbage
- sbcl-trivial-package-local-nicknames
- sbcl-trivial-types))
- (native-inputs
- (list sbcl-lisp-unit2))
- (arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "gpg.lisp"
- (("\"gpg\"")
- (string-append "\"" (assoc-ref inputs "gnupg")
"/bin/gpg\""))))))))
- (home-page "https://github.com/atlas-engineer/nfiles";)
- (synopsis "Manage file persistence and loading in Common Lisp")
- (description
- "NFiles is a Common Lisp library to help manage file persistence and
-loading, in particular user-centric files like configuration files. It boasts
-the following features:
-
-@itemize
-@item Dynamic and customizable path expansion.
-
-@item Extensible serialization and deserialization.
-
-@item Cached reads and writes. When a file object expands to the same path as
-another one, a read or write on it won’t do anything in case there was no
-change since last write.
-
-@item (Experimental!) On-the-fly PGP encryption.
-
-@item Profile support.
+ "ST-JSON (@code{ST} because it originated at Streamtech) is a Common
Lisp
+ library for encoding and decoding JSON values (as specified on json.org).
-@item On read error, existing files are backed up.
+This library does mostly the same thing as CL-JSON, but is simpler and more
+precise about types (distinguishing boolean false, the empty array, and the
+empty object).")
+ (license license:zlib))))
-@item On write error, no file is written to disk, the existing file is
preserved.
-@end itemize\n")
- (license license:bsd-3)))
+(define-public cl-st-json
+ (sbcl-package->cl-source-package sbcl-st-json))
-(define-public ecl-nfiles
- (let ((pkg (sbcl-package->ecl-package sbcl-nfiles)))
- (package
- (inherit pkg)
- (inputs
- (cons (list "iolib" ecl-iolib)
- (package-inputs pkg))))))
+(define-public ecl-st-json
+ (sbcl-package->ecl-package sbcl-st-json))
-(define-public cl-nfiles
- (package
- (inherit (sbcl-package->cl-source-package sbcl-nfiles))
- (inputs
- (cons (list "iolib" cl-iolib)
- (package-inputs sbcl-nfiles)))))
-(define-public sbcl-nasdf
- (let ((commit "ab7a018f3a67a999c72710644b10b4545130c139"))
+(define-public sbcl-staple
+ (let ((commit "0ee8e25fe6fe8fa83b2a6c93d4febd468c3eaa4e")
+ (revision "1"))
(package
- (name "sbcl-nasdf")
- (version "0.1.8")
+ (name "sbcl-staple")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/ntemplate";)
+ (url "https://github.com/Shinmera/staple/";)
(commit commit)))
- (file-name (git-file-name "cl-ntemplate" version))
(sha256
- (base32 "15j7kqxvn0blr0i2xgk0il0ia91p28clfqxdh00vlp423v9a2wbx"))))
+ (base32 "0qf0if7py3n4rszg25lcavpsqikfz6k5dvcmh5q67y8x5r12i5m7"))
+ (file-name (git-file-name "staple" version))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'cd-sdl
- (lambda _
- (chdir "nasdf"))))))
- (home-page "https://github.com/atlas-engineer/ntemplate";)
- (synopsis "ASDF helpers for system setup, testing and installation")
- (description
- "NASDF is an ASDF extension providing utilities to ease system setup,
-testing and installation.
+ '(#:asd-systems '("staple-package-recording"
+ "staple-code-parser"
+ "staple"
+ "staple-markdown"
+ "staple-markless"
+ "staple-restructured-text")))
+ (inputs
+ (list sbcl-3bmd
+ sbcl-babel
+ sbcl-cl-docutils
+ sbcl-cl-markless
+ sbcl-cl-ppcre
+ sbcl-clip
+ sbcl-concrete-syntax-tree
+ sbcl-definitions
+ sbcl-documentation-utils
+ sbcl-eclector
+ sbcl-language-codes
+ sbcl-pathname-utils))
+ (synopsis "Generate documentation about Lisp projects through an HTML
template")
+ (description "Staple is a documentation system. It provides you with a
+way to generate standalone documentation accumulated from various sources such
+as readmes, documentation files, and docstrings.")
+ (home-page "https://Shinmera.github.io/staple/";)
+ (license license:zlib))))
+
+(define-public cl-staple
+ (sbcl-package->cl-source-package sbcl-staple))
+
+(define-public ecl-staple
+ (sbcl-package->ecl-package sbcl-staple))
+
+(define-public sbcl-static-dispatch
+ (package
+ (name "sbcl-static-dispatch")
+ (version "0.5.1")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/alex-gutev/static-dispatch";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "static-dispatch" version))
+ (sha256
+ (base32 "1602vx6ybp0n8mbrrp6q8397fkkyvhrqpahc302pjdb57qildajz"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-agutil
+ sbcl-alexandria
+ sbcl-anaphora
+ sbcl-arrows
+ sbcl-cl-environments
+ sbcl-closer-mop
+ sbcl-iterate
+ sbcl-optima))
+ (home-page "https://github.com/alex-gutev/static-dispatch";)
+ (synopsis "Static generic function dispatch for Common Lisp")
+ (description "Static dispatch is a Common Lisp library, inspired by
+@code{inlined-generic-function}, which allows standard Common Lisp generic
+function dispatch to be performed statically (at compile time) rather than
+dynamically (runtime). This is similar to what is known as \"overloading\" in
+languages such as C++ and Java.
-@itemize
-@item Simple way to fetch Git submodules and “do the right thing” for
-setup. This may effectively supersede Quicklisp. A benefit of using Git
-submodules over the default Quicklisp distribution is improved
-reproducibility.
-@item Test helpers, like distinction between offline and online tests, or
-continuous integration options, and warning reports.
-@item Installation helpers, for instance to install libraries, icons and
-desktop files to the right directories.
-@end itemize\n")
- (license license:bsd-3))))
+The purpose of static dispatch is to provide an optimization in cases where
+the usual dynamic dispatch is too slow, and the dynamic features of generic
+functions, such as adding/removing methods at runtime are not required. An
+example of such a case is a generic equality comparison function. Currently
+generic functions are considered far too slow to implement generic arithmetic
+and comparison operations when used heavily in numeric code.")
+ (license license:expat)))
-(define-public ecl-nasdf
- (sbcl-package->ecl-package sbcl-nasdf))
+(define-public cl-static-dispatch
+ (sbcl-package->cl-source-package sbcl-static-dispatch))
-(define-public cl-nasdf
- (sbcl-package->cl-source-package sbcl-nasdf))
+(define-public ecl-static-dispatch
+ (sbcl-package->ecl-package sbcl-static-dispatch))
-(define-public sbcl-nclasses
+(define-public sbcl-static-vectors
(package
- (name "sbcl-nclasses")
- (version "0.6.1")
+ (name "sbcl-static-vectors")
+ (version "1.8.9")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/nclasses";)
- (commit version)))
- (file-name (git-file-name "cl-nclasses" version))
+ (url "https://github.com/sionescu/static-vectors";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "00is7fg1jsj9r3jawphbk5gh8kmiixl7g60xg1ic2q2cpilfd1by"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-moptilities))
+ (base32 "079qa20lhanzsz1qf4iags91n0ziylbjgbcymm5a5qj7yryas4fw"))))
(native-inputs
- (list sbcl-lisp-unit2))
- (home-page "https://github.com/atlas-engineer/nclasses";)
- (synopsis "Simplify class, condition, and generic function definitions.")
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-alexandria sbcl-cffi))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/sionescu/static-vectors";)
+ (synopsis "Allocate SIMPLE-ARRAYs in static memory")
(description
- "NClasses provides helper macros to help write classes, conditions,
-generic functions, and CLOS code in general with less boilerplate.
-
-It's a fork of @code{hu.dwim.defclass-star}. It includes some bug fixes and
-extra features like type inference.")
- (license license:public-domain)))
+ "With @code{static-vectors}, you can create vectors allocated in static
+memory.")
+ (license license:expat)))
-(define-public ecl-nclasses
- (sbcl-package->ecl-package sbcl-nclasses))
+(define-public cl-static-vectors
+ (sbcl-package->cl-source-package sbcl-static-vectors))
-(define-public cl-nclasses
- (sbcl-package->cl-source-package sbcl-nclasses))
+(define-public ecl-static-vectors
+ (sbcl-package->ecl-package sbcl-static-vectors))
-(define-public sbcl-prompter
- (let ((commit "7890ed5d02e70aba01ceb964c6ee4f40776e7dc0")
+(define-public sbcl-statistics
+ (let ((commit "94fc87a2bf81355a40ce3730b4ed77710ecfabaf")
(revision "0"))
(package
- (name "sbcl-prompter")
- (version (git-version "0.1.1" revision commit))
+ (name "sbcl-statistics")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/prompter";)
+ (url "https://github.com/Lisp-Stat/statistics";)
(commit commit)))
- (file-name (git-file-name "cl-prompter" version))
+ (file-name (git-file-name "cl-statistics" version))
(sha256
- (base32
- "0r15a6cagyp5x8aqx92ln2anni737h73bdshkvpzrac04ajss4md"))))
+ (base32 "0is69w6iwh4hyzc5ndgb3i2331f677sa7kw5wy8pmx6hawbkgyir"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-clunit2))
(inputs
- (list
- sbcl-alexandria
- sbcl-calispel
- sbcl-cl-containers
- sbcl-cl-str
- sbcl-closer-mop
- sbcl-lparallel
- sbcl-moptilities
- sbcl-nclasses
- sbcl-serapeum
- sbcl-trivial-package-local-nicknames))
- (native-inputs
- (list sbcl-lisp-unit2))
- (home-page "https://github.com/atlas-engineer/prompter";)
- (synopsis "Live-narrowing, fuzzy-matching, extensible prompt framework")
- (description
- "This prompter library is heavily inspired by Emacs' minibuffer and
-Helm (@url{https://emacs-helm.github.io/helm/}). It only deals with the
-backend side of things, it does not handle any display. Features include
-asynchronous suggestion computation, multiple sources, actions and resumable
-prompters.")
- (license license:bsd-3))))
+ (list sbcl-alexandria
+ sbcl-anaphora
+ sbcl-conduit-packages
+ sbcl-distributions
+ sbcl-let-plus
+ sbcl-numerical-utilities))
+ (home-page "https://lisp-stat.dev/docs/";)
+ (synopsis "Statistical functions in Common Lisp")
+ (description "This package provides a consolidation of Common Lisp
+statistics libraries.")
+ (license (list license:expat license:ms-pl)))))
-(define-public cl-prompter
- (sbcl-package->cl-source-package sbcl-prompter))
+(define-public cl-statistics
+ (sbcl-package->cl-source-package sbcl-statistics))
-(define-public ecl-prompter
- (sbcl-package->ecl-package sbcl-prompter))
+(define-public ecl-statistics
+ (sbcl-package->ecl-package sbcl-statistics))
-(define-public sbcl-cl-template
- (let ((commit "46193a9a389bb950530e579eae7e6e5a18184832")
+(define-public sbcl-stdutils
+ (let ((commit "4a4e5a4036b815318282da5dee2a22825369137b")
(revision "0"))
(package
- (name "sbcl-cl-template")
- (version (git-version "0.0.1" revision commit))
- (home-page "https://github.com/alpha123/cl-template";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/alpha123/cl-template";)
- (commit commit)))
- (file-name (git-file-name "cl-template" version))
- (sha256
- (base32 "1rhg023a2nxsk5x6abd6i0a8sh36aj0bgsh80w60m3b7xlsva2x2"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "Template engine for Common Lisp")
- (description "@code{cl-template} is a template engine for Common Lisp,
-taking inspiration from Ruby's ERb module.")
- (license license:expat))))
+ (name "sbcl-stdutils")
+ (version (git-version "1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/eslick/cl-stdutils";)
+ (commit commit)))
+ (file-name (git-file-name "cl-stdutils" version))
+ (sha256
+ (base32 "16vxxphqdq8264x0aanm36x9r6d3ci1gjf4vf46mwl59gcff4wcj"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments '(#:tests? #f)) ; There are no tests.
+ (inputs
+ (list sbcl-cl-fad
+ sbcl-cl-ppcre))
+ (home-page "https://github.com/eslick/cl-stdutils/";)
+ (synopsis "Grab bag of Common Lisp utility functions")
+ (description
+ "This package provides a grab bag of miscellaneous Common Lisp
+utilities.")
+ (license license:bsd-3))))
-(define-public cl-template
- (sbcl-package->cl-source-package sbcl-cl-template))
+(define-public cl-stdutils
+ (sbcl-package->cl-source-package sbcl-stdutils))
-(define-public ecl-cl-template
- (sbcl-package->ecl-package sbcl-cl-template))
+(define-public ecl-stdutils
+ (sbcl-package->ecl-package sbcl-stdutils))
-(define-public sbcl-fast-websocket
- (let ((commit "baeeaddf1447015863d708f840ef9dfc5ff5b7a2")
- (revision "1"))
+(define-public sbcl-stealth-mixin
+ (let ((commit "2f853fcead554221d4be3b10522b502ea729e944")
+ (revision "0"))
(package
- (name "sbcl-fast-websocket")
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/fukamachi/fast-websocket";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/fast-websocket";)
- (commit commit)))
- (file-name (git-file-name "cl-fast-websoclet" version))
- (sha256
- (base32 "1j7v00gbkzx4mq2v8y44jm4jx321hgrv9igfw23cvzzlyd3dzp6y"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; Test system must be loaded before, otherwise tests fail with:
- ;; Component FAST-WEBSOCKET-ASD::FAST-WEBSOCKET-TEST not found,
- ;; required by #<SYSTEM "fast-websocket">.
- '(#:asd-systems '("fast-websocket-test"
- "fast-websocket")))
- (inputs
- (list sbcl-fast-io
- sbcl-babel
- sbcl-alexandria))
- (native-inputs
- (list sbcl-prove
- sbcl-trivial-utf-8))
- (synopsis "WebSocket protocol parser for Common Lisp")
- (description
- "@code{fast-websocket} is an optimized low-level WebSocket protocol
-parser/composer.")
- (license license:bsd-2))))
+ (name "sbcl-stealth-mixin")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/robert-strandh/Stealth-mixin";)
+ (commit commit)))
+ (file-name (git-file-name "cl-stealth-mixin" version))
+ (sha256
+ (base32 "0ar9cdmbmdnqz1ywpw34n47hlh0vqmb6pl76f5vbfgip3c81xwyi"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-closer-mop))
+ (home-page "https://github.com/robert-strandh/Stealth-mixin";)
+ (synopsis "Create stealth mixin classes")
+ (description
+ "Stealth-mixin is a Common Lisp library for creating stealth mixin
+classes. These are classes that are dynamically mixed into other classes
+without the latter being aware of it.")
+ (license license:bsd-2))))
-(define-public cl-fast-websocket
- (sbcl-package->cl-source-package sbcl-fast-websocket))
+(define-public cl-stealth-mixin
+ (sbcl-package->cl-source-package sbcl-stealth-mixin))
-(define-public ecl-fast-websocket
- (sbcl-package->ecl-package sbcl-fast-websocket))
+(define-public ecl-stealth-mixin
+ (sbcl-package->ecl-package sbcl-stealth-mixin))
-(define-public sbcl-event-emitter
- (let ((commit "cb0e15f9de4c617cef3f5d5a22a41e28f9613d0b")
- (revision "0"))
+(define-public sbcl-stmx
+ ;; No release for years and recent commits contain fixes for recent SBCL
+ ;; versions.
+ (let ((commit "95f7dea8e1e58dee59e14a1deb148908d920839f")
+ (revision "3"))
(package
- (name "sbcl-event-emitter")
- (version (git-version "0.0.1" revision commit))
- (home-page "https://github.com/fukamachi/event-emitter";)
+ (name "sbcl-stmx")
+ (version (git-version "2.0.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/event-emitter";)
+ (url "https://github.com/cosmos72/stmx/";)
(commit commit)))
- (file-name (git-file-name "cl-event-emitter" version))
+ (file-name (git-file-name "cl-stmx" version))
(sha256
- (base32 "1i18xzfr6334db9dzj0lsl7wxw1r1l0ixvn883mjbyqw0czp21h6"))))
+ (base32 "1qq25y79casaa56a76gj9hk2f3hjcc5z3f4na4vy3sw99km54hn9"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
- (synopsis "Event mechanism for Common Lisp objects")
- (description "Event Emitter provides an event mechanism like Node.js for
-Common Lisp objects. It is mostly ported from Node.js @code{events} module.")
- (license license:bsd-2))))
+ (inputs
+ (list sbcl-alexandria sbcl-bordeaux-threads sbcl-log4cl
+ sbcl-closer-mop sbcl-trivial-garbage))
+ (home-page "https://stmx.org/";)
+ (synopsis "High performance Transactional Memory for Common Lisp")
+ (description
+ "STMX is a high-performance implementation of composable Transactional
+Memory, which is a concurrency control mechanism aimed at making concurrent
+programming easier to write and understand. Instead of traditional lock-based
+programming, one programs with atomic memory transactions, which can be
+composed together to make larger atomic memory transactions.
-(define-public cl-event-emitter
- (sbcl-package->cl-source-package sbcl-event-emitter))
+A memory transaction gets committed if it returns normally, while it gets
+rolled back if it signals an error (and the error is propagated to the
+caller).
-(define-public ecl-event-emitter
- (sbcl-package->ecl-package sbcl-event-emitter))
+Finally, memory transactions can safely run in parallel in different threads,
+are re-executed from the beginning in case of conflicts or if consistent reads
+cannot be guaranteed, and their effects are not visible from other threads
+until they commit.
-(define-public sbcl-sha1
- (let ((commit "be8b1b155c3a6ad3eb9b200212af6ff52f5611de")
+Memory transactions give freedom from deadlocks, are immune to thread-safety
+bugs and race conditions, provide automatic roll-back on failure, and aim at
+resolving the tension between granularity and concurrency.")
+ (license license:llgpl))))
+
+(define-public cl-stmx
+ (sbcl-package->cl-source-package sbcl-stmx))
+
+(define-public ecl-stmx
+ (sbcl-package->ecl-package sbcl-stmx))
+
+(define-public sbcl-string-case
+ (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
(revision "0"))
(package
- (name "sbcl-sha1")
- (version (git-version "1.0" revision commit))
- (home-page "https://github.com/massung/sha1";)
+ (name "sbcl-string-case")
+ (version (git-version "0.0.2" revision commit))
+ (home-page "https://github.com/pkhuong/string-case";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Efficient string= case in Common Lisp")
+ (description
+ "@code{string-case} is a Common Lisp macro that generates specialised
decision
+trees to dispatch on string equality.")
+ (license license:bsd-3))))
+
+(define-public cl-string-case
+ (sbcl-package->cl-source-package sbcl-string-case))
+
+(define-public ecl-string-case
+ (sbcl-package->ecl-package sbcl-string-case))
+
+(define-public sbcl-string-pokemonize
+ (let ((commit "2dc01643defb497e4d1eb833def71dfc1e8d5da6")
+ (revision "0"))
+ (package
+ (name "sbcl-string-pokemonize")
+ (version (git-version "20210503" revision commit))
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/massung/sha1";)
- (commit commit)))
- (file-name (git-file-name "cl-sha1" version))
- (sha256
- (base32 "1cfn0j5yfwqkwr2dm73wr9hz8dmws3ngxlbk9886ahxkg544qx4z"))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phoe/string-pokemonize";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1zk5klc94pxv7mhx6qrp93rk4ypwd6wfijap7gf9l0wpphg90r9x"))))
(build-system asdf-build-system/sbcl)
- (synopsis "SHA1 Digest and HMAC for Common Lisp")
+ (arguments
+ `(#:tests? #f ; There are no tests.
+ #:asd-systems '("string-pokemonize")))
+ (synopsis "Alternate upper- and lowercase")
(description
- "This is a very simple implementation of SHA1 and HMAC-SHA1 for
-Common Lisp. The code is intended to be easy to follow and is therefore a
-little slower than it could be.")
- (license license:asl2.0))))
+ "@code{string-pokemonize} provides a function that alternates uppercase
+and lowercase characters for a given string.")
+ (home-page "https://github.com/phoe/string-pokemonize";)
+ (license license:expat))))
-(define-public cl-sha1
- (sbcl-package->cl-source-package sbcl-sha1))
+(define-public cl-string-pokemonize
+ (sbcl-package->cl-source-package sbcl-string-pokemonize))
-(define-public ecl-sha1
- (sbcl-package->ecl-package sbcl-sha1))
+(define-public ecl-string-pokemonize
+ (sbcl-package->ecl-package sbcl-string-pokemonize))
-(define-public sbcl-websocket-driver
- (let ((commit "df94496ecb525d086eeada4f5875975515b7212e")
+(define-public sbcl-stripe
+ (let ((commit "b59631d21d63e101de6eb96b56941471504ba644")
(revision "0"))
(package
- (name "sbcl-websocket-driver")
- (version (git-version "0.2.0" revision commit))
- (home-page "https://github.com/fukamachi/websocket-driver";)
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/websocket-driver";)
- (commit commit)))
- (file-name (git-file-name "cl-websocket-driver" version))
- (sha256
- (base32 "0y852sqdnxfma6kw833by4wkgbgbv4ppzawjk8pk3y1pmh6is83y"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-babel
- sbcl-clack
- sbcl-fast-http
- sbcl-fast-io
- sbcl-fast-websocket
- sbcl-event-emitter
- sbcl-sha1
- sbcl-cl-base64
- sbcl-split-sequence
- sbcl-bordeaux-threads
- sbcl-quri))
- (synopsis "WebSocket server/client for Common Lisp")
- (description "This library provides a WebSocket server and client
-implementation for Common Lisp.")
- (license license:bsd-2))))
+ (name "sbcl-stripe")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/atlas-engineer/stripe";)
+ (commit commit)))
+ (file-name (git-file-name "cl-stripe" version))
+ (sha256
+ (base32 "00sfq2f6dnpwa6pf7rgw5hazbwx4yf1g0jrkfz9h4kq5zyxwk1cy"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-dexador
+ sbcl-golden-utils
+ sbcl-local-time
+ sbcl-yason))
+ (home-page "https://github.com/atlas-engineer/stripe";)
+ (synopsis "Stripe payment API client for Common Lisp")
+ (description "A client for the Stripe payment API.")
+ (license license:expat))))
-(define-public cl-websocket-driver
- (sbcl-package->cl-source-package sbcl-websocket-driver))
+(define-public cl-stripe
+ (sbcl-package->cl-source-package sbcl-stripe))
-(define-public ecl-websocket-driver
- (sbcl-package->ecl-package sbcl-websocket-driver))
+(define-public ecl-stripe
+ (sbcl-package->ecl-package sbcl-stripe))
-(define-public sbcl-jzon
+(define-public sbcl-supertrace
+ (let ((commit "66d22c3ff131ecd1c8048dfced1d62ed6024ecb0"))
+ (package
+ (name "sbcl-supertrace")
+ (version (git-version "0.1.0" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/supertrace";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0n369n6b7y1m49biccnnr7svymjdsk8sksrkqrn3mj21vgv7s7bg"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-cffi sbcl-rove sbcl-cl-ppcre sbcl-bordeaux-threads))
+ (inputs
+ (list sbcl-cffi))
+ (home-page "https://github.com/fukamachi/supertrace";)
+ (synopsis "Improved Common Lisp tracing for debugging and profiling")
+ (description
+ "Supertrace provides a superior Common Lisp @code{trace} functionality
+for debugging and profiling real world applications.")
+ (license license:bsd-2))))
+
+(define-public cl-supertrace
+ (sbcl-package->cl-source-package sbcl-supertrace))
+
+(define-public ecl-supertrace
+ (sbcl-package->ecl-package sbcl-supertrace))
+
+(define-public sbcl-swap-bytes
(package
- (name "sbcl-jzon")
- (version "1.1.0")
+ (name "sbcl-swap-bytes")
+ (build-system asdf-build-system/sbcl)
+ (version "1.2")
+ (home-page "https://github.com/sionescu/swap-bytes";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Zulu-Inuoe/jzon";)
+ (url home-page)
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-jzon" version))
- (sha256
- (base32 "0rbardn1dfizpyyy1c127zzk1fnq4pslz75xa7ldpfjsi5jc5fmr"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("com.inuoe.jzon")
- #:asd-test-systems '("com.inuoe.jzon-tests")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-test-asd
- (lambda _
- (substitute* "test/com.inuoe.jzon-tests.asd"
- ((":depends-on")
- (string-append
- ":perform (test-op (op c) (symbol-call :fiveam :run!"
- " (find-symbol \"JZON\" :com.inuoe.jzon-tests)))"
- "\n"
- " :depends-on"))))))))
- (native-inputs
- (list sbcl-alexandria
- sbcl-fiveam))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "1hw1v1lw26rifyznpnj1csphha9jgzwpiic16ni3pvs6hcsni9rz"))))
(inputs
- (list sbcl-closer-mop
- sbcl-flexi-streams
- sbcl-float-features
- sbcl-trivial-gray-streams))
- (home-page "https://github.com/Zulu-Inuoe/jzon/";)
- (synopsis "Correct and safe JSON parser")
- (description
- "@code{jzon} is a correct and safe JSON RFC 8259 parser for Common Lisp.")
+ (list sbcl-trivial-features))
+ (native-inputs
+ (list sbcl-fiveam))
+ (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-jzon
- (sbcl-package->cl-source-package sbcl-jzon))
+(define-public cl-swap-bytes
+ (sbcl-package->cl-source-package sbcl-swap-bytes))
-(define-public ecl-jzon
- (sbcl-package->ecl-package sbcl-jzon))
+(define-public ecl-swap-bytes
+ (sbcl-package->ecl-package sbcl-swap-bytes))
-(define-public sbcl-simple-routes
- (let ((commit "6f88c38945a4de73e85786d3499c39cacb400598")
- (revision "1"))
+(define-public sbcl-sxql
+ (let ((commit "cc3478cacb0557475a59cf619dad66c5dc8080ba")
+ (revision "3"))
(package
- (name "sbcl-simple-routes")
- (version (git-version "0.3" revision commit))
+ (name "sbcl-sxql")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/vancan1ty/simple-routes";)
+ (url "https://github.com/fukamachi/sxql";)
(commit commit)))
- (file-name (git-file-name "cl-simple-routes" version))
+ (file-name (git-file-name "cl-sqxl" version))
(sha256
- (base32 "0zkjl69zf1ynmqmvwccdbip3wxfyi7xplivv70qwxzd27mc0kh3k"))))
+ (base32 "011an993amy8q3gl4hyqrgnc93cgny3cv9gbp679rrmyyp8zmywr"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-cl-ppcre
- sbcl-hunchentoot))
- (home-page "https://gitlab.com/vancan1ty/simple-routes";)
- (synopsis "URL routing library for Hunchentoot")
- (description
- "@code{simple-routes} is a simple Common Lisp RESTful routing facility
-on top of Hunchentoot.")
- (license license:bsd-2))))
-
-(define-public cl-simple-routes
- (sbcl-package->cl-source-package sbcl-simple-routes))
-
-(define-public ecl-simple-routes
- (sbcl-package->ecl-package sbcl-simple-routes))
+ (list sbcl-alexandria
+ sbcl-cl-package-locks
+ sbcl-cl-syntax
+ sbcl-iterate
+ sbcl-optima
+ sbcl-split-sequence
+ sbcl-trivia
+ sbcl-trivial-types))
+ (native-inputs
+ (list sbcl-prove))
+ (home-page "https://github.com/fukamachi/sxql";)
+ (synopsis "SQL generator for Common Lisp")
+ (description "SQL generator for Common Lisp.")
+ (license license:bsd-3))))
-(define-public sbcl-eris
- (package
- (name "sbcl-eris")
- (version "0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://git.ykonai.net/eris-cl";)
- (commit version)))
- (file-name (git-file-name "cl-eris" version))
- (sha256
- (base32 "0qm74ld70aic39giamvix88500flv86047a82rx9gkjwaisf58rc"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-function-cache
- sbcl-ironclad
- sbcl-mmap
- sbcl-osicat
- sbcl-serapeum
- sbcl-trivial-gray-streams))
- (home-page "https://git.ykonai.net/eris-cl/";)
- (synopsis "ERIS implementation for Common Lisp")
- (description
- "This is a Common Lisp implementation of the Encoding for Robust Immutable
-Storage specification (ERIS).")
- (license license:lgpl3+)))
+(define-public cl-sxql
+ (sbcl-package->cl-source-package sbcl-sxql))
-(define-public cl-eris
- (sbcl-package->cl-source-package sbcl-eris))
+(define-public ecl-sxql
+ (sbcl-package->ecl-package sbcl-sxql))
-(define-public sbcl-cl-ipfs-api2
- (let ((commit "3ee52c80023bcc662f7d01276ea0a5814bd0011b")
- (revision "0"))
+(define-public sbcl-sxql-composer
+ (let ((commit "2b2230cb01ae1b68e28921d99e4814046867fb75")
+ (revision "1"))
(package
- (name "sbcl-cl-ipfs-api2")
- (version (git-version "0.51" revision commit))
+ (name "sbcl-sxql-composer")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/JadedCtrl/cl-ipfs-api2";)
+ (url "https://github.com/mmontone/sxql-composer";)
(commit commit)))
- (file-name (git-file-name "cl-ipfs-api2" version))
+ (file-name (git-file-name "sxql-composer" version))
(sha256
- (base32 "1h0csxk4db1hid793mk5kz3nbjyl7z4ic1zk2wy46k1vz5lnnsph"))))
+ (base32 "1agkrj3ymskzc3c7pxbrj123d1kygjqcls145m0ap3i07q96hh1r"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:tests? #f)) ; There are no tests.
(inputs
- (list sbcl-arnesi
- sbcl-drakma
- sbcl-yason))
- (home-page "https://github.com/JadedCtrl/cl-ipfs-api2/";)
- (synopsis "Bindings for the IPFS HTTP API")
+ (list sbcl-sxql))
+ (synopsis "Build and compose SXQL queries dynamically")
(description
- "@code{cl-sbcl-cl-ipfs-api2} is a pretty simple set of IPFS bindings
-for Common Lisp, using the HTTP API for (almost) everything, except for pubsub
-(which uses the locally installed go-ipfs program).")
- (license license:lgpl3))))
+ "This is a Common Lisp library to build and compose SXQL queries
+dynamically.")
+ (home-page "https://github.com/mmontone/sxql-composer";)
+ (license license:expat))))
-(define-public cl-ipfs-api2
- (sbcl-package->cl-source-package sbcl-cl-ipfs-api2))
+(define-public cl-sxql-composer
+ (sbcl-package->cl-source-package sbcl-sxql-composer))
-(define-public ecl-cl-ipfs-api2
- (sbcl-package->ecl-package sbcl-cl-ipfs-api2))
+(define-public ecl-sxql-composer
+ (sbcl-package->ecl-package sbcl-sxql-composer))
-(define-public sbcl-purgatory
- (let ((commit "3afd8f6bb4093ffb2f39ffdedf11278b3617fff9")
- (revision "1"))
+(define-public sbcl-sycamore
+ (let ((commit "fd2820fec165ad514493426dea209728f64e6d18"))
(package
- (name "sbcl-purgatory")
- (version (git-version "0.1.2" revision commit))
+ (name "sbcl-sycamore")
+ (version "0.0.20120604")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://notabug.org/cage/purgatory";)
+ (url "https://github.com/ndantam/sycamore/";)
(commit commit)))
- (file-name (git-file-name "cl-purgatory" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0iy2jdgrwqrq9cph7bwf79d8l4zdsgcd9sfcn0lclzai2v0yizp9"))))
+ (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-cl-ppcre-unicode
- sbcl-usocket))
- (synopsis "Common Lisp implementation of the 9p protocol")
- (description "This is a Common Lisp library that implements
-the 9p network filesystem protocol.")
- (home-page "https://notabug.org/cage/purgatory/";)
- (license license:llgpl))))
+ (list sbcl-alexandria sbcl-cl-ppcre))
+ (synopsis "Purely functional data structure library in Common Lisp")
+ (description
+ "Sycamore is a fast, purely functional data structure library in Common
Lisp.
+If features:
-(define-public ecl-purgatory
- (sbcl-package->ecl-package sbcl-purgatory))
+@itemize
+@item Fast, purely functional weight-balanced binary trees.
+@item Leaf nodes are simple-vectors, greatly reducing tree height.
+@item Interfaces for tree Sets and Maps (dictionaries).
+@item Ropes.
+@item Purely functional pairing heaps.
+@item Purely functional amortized queue.
+@end itemize\n")
+ (home-page "https://ndantam.github.io/sycamore/";)
+ (license license:bsd-3))))
-(define-public cl-purgatory
- (sbcl-package->cl-source-package sbcl-purgatory))
+(define-public cl-sycamore
+ (sbcl-package->cl-source-package sbcl-sycamore))
-(define-public sbcl-just-getopt-parser
- (package
- (name "sbcl-just-getopt-parser")
- (version "2021.11")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/tlikonen/cl-just-getopt-parser";)
- (commit version)))
- (sha256
- (base32 "0ngh8b51ngh3bqacl40j6wwiinhwxswsy02d9k7qlzv9sbjxay4s"))
- (file-name (git-file-name "cl-just-getopt-parser" version))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Getopt-like command-line parser for Common Lisp")
- (description
- "This package provides the @code{getopt} function to parse command-line
-options. The options are organized in valid options, other arguments and
-unknown arguments. Optional Lisp conditions for error situations are also
-defined.")
- (home-page "https://github.com/tlikonen/cl-just-getopt-parser";)
- (license license:cc0)))
+(define-public ecl-sycamore
+ (sbcl-package->ecl-package sbcl-sycamore))
-(define-public ecl-just-getopt-parser
- (sbcl-package->ecl-package sbcl-just-getopt-parser))
+(define-public sbcl-symbol-munger
+ (let ((commit "e96558e8315b8eef3822be713354787b2348b25e")
+ (revision "2"))
+ (package
+ (name "sbcl-symbol-munger")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/AccelerationNet/symbol-munger";)
+ (commit commit)))
+ (file-name (git-file-name "cl-symbol-munger" version))
+ (sha256
+ (base32
+ "16fshnxp9212503z1vjlmx5pafv14bzpihn486x1ljakqjigfnfz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)))
+ (arguments
+ ;; There is a cyclical dependency between symbol-munger and lisp-unit2.
+ ;; See https://github.com/AccelerationNet/symbol-munger/issues/4
+ '(#:tests? #f))
+ (synopsis
+ "Capitalization and spacing conversion functions for Common Lisp")
+ (description
+ "This is a Common Lisp library to change the capitalization and spacing
+of a string or a symbol. It can convert to and from Lisp, english, underscore
+and camel-case rules.")
+ (home-page "https://github.com/AccelerationNet/symbol-munger";)
+ ;; The package declares a BSD license, but all of the license
+ ;; text is MIT.
+ ;; See https://github.com/AccelerationNet/symbol-munger/issues/5
+ (license license:expat))))
+
+(define-public cl-symbol-munger
+ (sbcl-package->cl-source-package sbcl-symbol-munger))
-(define-public cl-just-getopt-parser
- (sbcl-package->cl-source-package sbcl-just-getopt-parser))
+(define-public ecl-symbol-munger
+ (sbcl-package->ecl-package sbcl-symbol-munger))
-(define-public sbcl-formgrep
- (let ((commit "91238cdbdd0ad815ff5d574d032b4a502febd190")
+(define-public sbcl-system-load
+ (let ((commit "3ff1a40be55866cc5316ac7a530d872b12510294")
(revision "0"))
(package
- (name "sbcl-formgrep")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-system-load")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/death/formgrep";)
+ (url "https://github.com/Shinmera/system-load";)
(commit commit)))
- (file-name (git-file-name "cl-formgrep" version))
+ (file-name (git-file-name "cl-system-load" version))
(sha256
- (base32 "1rqzkmz6nddg5ywvs3v0k8cvxdwas38mfwgbr3rs4fdsbps90k9r"))))
+ (base32 "08d8kr8j5l2m8p69f47iklxhna394vx9mrys0sgplf5f2bqb7xcv"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cl-fad
- sbcl-cl-ppcre
- sbcl-eclector))
- (home-page "https://github.com/death/formgrep";)
- (synopsis "Find top-level Lisp forms matching an operator pattern")
+ (home-page "https://github.com/Shinmera/system-load";)
+ (synopsis "Access system's CPU and memory usage from Common Lisp")
(description
- "This library provides the @code{FORMGREP} function and related
-utilities which find top-level Lisp forms matching the regular expression
-corresponding to an operator name, returning the matched forms and the names
-of the files and the line numbers where they were found.")
- (license license:expat))))
+ "System-Load is a Common Lisp library for accessing the system's CPU and
+memory usage.")
+ (license license:zlib))))
-(define-public cl-formgrep
- (sbcl-package->cl-source-package sbcl-formgrep))
+(define-public cl-system-load
+ (sbcl-package->cl-source-package sbcl-system-load))
-(define-public ecl-formgrep
- (sbcl-package->ecl-package sbcl-formgrep))
+(define-public ecl-system-load
+ (sbcl-package->ecl-package sbcl-system-load))
-(define-public sbcl-lmdb
- (let ((commit "f439b707939a52769dc9747838ff4a616fab14a3")
- (revision "0"))
+(define-public sbcl-system-locale
+ (let ((commit "4b334bc2fa45651bcaa28ae7d9331095d6bf0a17"))
(package
- (name "sbcl-lmdb")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-system-locale")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/antimer/lmdb";)
+ (url "https://github.com/Shinmera/system-locale/";)
(commit commit)))
- (file-name (git-file-name "cl-lmdb" version))
+ (file-name (git-file-name name commit))
(sha256
- (base32 "0akvimmvd4kcx6gh1j1dzvcclhc0jc4hc9vkh3ldgzb8wyf4vl8q"))))
+ (base32 "00p5c053kmgq4ks6l9mxsqz6g3bjcybvkvj0bh3r90qgpkaawm1p"))))
(build-system asdf-build-system/sbcl)
- (arguments
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/lmdb.lisp"
- (("\"liblmdb.so\"")
- (string-append
- "\"" (search-input-file inputs "/lib/liblmdb.so")
"\""))))))))
(inputs
- (list lmdb
- sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cl-reexport
- sbcl-mgl-pax
- sbcl-osicat
- sbcl-trivial-features
- sbcl-trivial-garbage
- sbcl-trivial-utf-8))
- (native-inputs
- (list sbcl-try))
- (home-page "https://github.com/antimer/lmdb";)
- (synopsis "LMDB bindings for Common Lisp")
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/system-locale/";)
+ (synopsis "Get the system's locale and language settings in Common Lisp")
(description
- "LMDB, the Lightning Memory-mapped Database, is an ACID key-value
-database with multiversion concurrency control. This package is a Common Lisp
-wrapper around the C LMDB library. It covers most of C LMDB's functionality,
-has a simplified API, much needed safety checks, and comprehensive
-documentation.")
- (license license:expat))))
-
-(define-public cl-lmdb
- (sbcl-package->cl-source-package sbcl-lmdb))
-
-(define-public sbcl-listopia
- (package
- (name "sbcl-listopia")
- (version "0.12.0")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Dimercel/listopia";)
- (commit version)))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "07xa2s2s60h9f40az3zdacybl5pk1x8bhvga9phsra0czbv44lx2"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
- (home-page "https://github.com/Dimercel/listopia";)
- (synopsis "List manipulation library for Common Lisp")
- (description "This package is a list manipulation library for Common Lisp
-inspired by Haskell package @code{Data.List}.")
- (license license:llgpl)))
-
-(define-public cl-listopia
- (sbcl-package->cl-source-package sbcl-listopia))
-
-(define-public ecl-listopia
- (sbcl-package->ecl-package sbcl-listopia))
-
-(define-public sbcl-clog
- (package
- (name "sbcl-clog")
- (version "1.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/rabbibotton/clog";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-clog" version))
- (sha256
- (base32 "0f4i6571nm0j704zgnh60sc9slifs11byb2gs8gamqjcfh931dap"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-3bmd
- sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cl-ppcre
- sbcl-cl-sqlite
- sbcl-cl-template
- sbcl-clack
- sbcl-closer-mop
- sbcl-colorize
- sbcl-dbi
- sbcl-hunchentoot
- sbcl-lack
- sbcl-mgl-pax
- sbcl-parse-float
- sbcl-quri
- sbcl-trivial-open-browser
- sbcl-websocket-driver))
- (arguments
- '(#:asd-systems '("clog" "clog/docs" "clog/tools")
- #:phases (modify-phases %standard-phases
- (add-after 'unpack 'fix-symbol-name
- (lambda _
- (substitute* "source/clog-docs.lisp"
- (("clog:@CLOG-MANUAL")
- "clog::@CLOG_MANUAL")))))))
- (home-page "https://github.com/rabbibotton/clog";)
- (synopsis "Common Lisp Omnificent GUI")
- (description
- "This package provides a Common Lisp web framework for building GUI
-applications. CLOG can take the place, or work along side, most cross platform
-GUI frameworks and website frameworks. The CLOG package starts up the
-connectivity to the browser or other websocket client (often a browser embedded
-in a native template application).")
- (license license:bsd-3)))
-
-(define-public cl-clog
- (sbcl-package->cl-source-package sbcl-clog))
-
-(define-public ecl-clog
- (sbcl-package->ecl-package sbcl-clog))
-
-(define-public sbcl-nkeymaps
- (package
- (name "sbcl-nkeymaps")
- (version "1.1.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/atlas-engineer/nkeymaps";)
- (commit version)))
- (file-name (git-file-name "cl-nkeymaps" version))
- (sha256
- (base32 "179hrnkn3pkwkp4ap6ax0zgp7xcr9cq7icff42r79gh43ri3kpzy"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-fset
- sbcl-cl-str
- sbcl-trivial-package-local-nicknames))
- (native-inputs
- (list sbcl-lisp-unit2))
- (home-page "https://github.com/atlas-engineer/nkeymaps";)
- (synopsis "Keymap facility for Common Lisp")
- (description
- "This is a keymap facility for Common Lisp inspired by Emacsy
-(keymap.scm) which is inspired by Emacs.
-@itemize
-
-@item Support prefix keys to other keymaps. For instance, if you prefix
-my-mode-map with C-c, then all bindings for my-mode will be accessible after
-pressing C-c.
-
-@item List all bindings matching a given prefix. (Also known as which-key in
-Emacs.)
-
-@item List the bindings associated to a command.
-
-@item Support multiple inheritance.
-
-@item Support keycode.
-
-@item Validate keyspec at compile time.
-
-@item define-key can set multiple bindings in a single call.
-
-@item Support multiple scheme to make it easy to switch between, say,
-Emacs-style and VI-style bindings. This orthogonality to keymaps composes
-better than having multiple keymaps: changing scheme applies to the entire
-program, which is easier than looping through all keymaps to change them.
-
-@item Translate keyspecs as a fallback. For instance if shift-a is not bound,
-check A.
-
-@item Behaviour can be customized with global parameters such as
-*print-shortcut*.
-
-@item The compose function can merge multiple keymaps together.
+ "This library retrieves locale information configured on the
+system. This is helpful if you want to write applications and libraries that
+display messages in the user's native language.")
+ (license license:zlib))))
-@item Support multiple arguments when that makes sense (e.g. multiple keymaps
-for lookup-key).
+(define-public cl-system-locale
+ (sbcl-package->cl-source-package sbcl-system-locale))
-@item Key remapping à-la Emacs.
+(define-public ecl-system-locale
+ (sbcl-package->ecl-package sbcl-system-locale))
-@item Typed keymaps, i.e. keymaps where bound values can only be of a given
-type. This is convenient to catch typos, for instance when binding 'FOO
-instead of #'FOO.
-@end itemize")
- (license license:bsd-3)))
+(define-public sbcl-tailrec
+ (let ((commit "6f882846d8f5bca9138df26510862e64bb15d92f")
+ (revision "2"))
+ (package
+ (name "sbcl-tailrec")
+ (version (git-version "0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/charje/tailrec";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1h8m2npdzd2cpnl75pvv4yvvfwxa7kl6qvalc9s0y4yws0kaih3i"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria sbcl-trivial-macroexpand-all
+ sbcl-trivial-with-current-source-form))
+ (home-page "https://github.com/charje/tailrec";)
+ (synopsis "Macro to optimize a Common Lisp function for tail recursion")
+ (description "Just wrap your Common Lisp function in this macro call and
+it will be optimized for tail recursion. You will be warned if the function
+is not tail recursive.")
+ (license license:llgpl))))
-(define-public cl-nkeymaps
- (sbcl-package->cl-source-package sbcl-nkeymaps))
+(define-public cl-tailrec
+ (sbcl-package->cl-source-package sbcl-tailrec))
-(define-public ecl-nkeymaps
- (sbcl-package->ecl-package sbcl-nkeymaps))
+(define-public ecl-tailrec
+ (sbcl-package->ecl-package sbcl-tailrec))
-(define-public sbcl-xkbcommon
- (let ((commit "aa9513d93f42d7816f88dd1bd8bd21375e7d7512")
+(define-public sbcl-tar
+ (let ((commit "7c6e07a10c93d9e311f087b5f6328cddd481669a")
(revision "0"))
(package
- (name "sbcl-xkbcommon")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-tar")
+ (version (git-version "0.2.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sdilts/cl-xkbcommon";)
+ (url "https://gitlab.common-lisp.net/cl-tar/cl-tar";)
(commit commit)))
- (file-name (git-file-name "cl-xkbcommon" version))
+ (file-name (git-file-name "cl-tar" version))
(sha256
- (base32 "02zdbkh7yliw9vg8i8wx2xgcpfni0fr4z0w19kkxvaib8xm9rx1q"))))
+ (base32 "0wp23cs3i6a89dibifiz6559la5nk58d1n17xvbxq4nrl8cqsllf"))))
(build-system asdf-build-system/sbcl)
+ ;; TODO: Build the tar program with 'build-program' when the
+ ;; 'asdf-release-ops' library is added to Guix.
(arguments
- (list #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "xkbcommon.lisp"
- (("libxkbcommon.so.0")
- (search-input-file inputs
"/lib/libxkbcommon.so"))))))))
+ '(#:asd-systems '("tar"
+ "tar/common-extract"
+ "tar/create"
+ "tar/docs"
+ "tar/extract"
+ "tar/simple-extract")))
(native-inputs
- (list pkg-config))
+ (list sbcl-parachute))
(inputs
- (list libxkbcommon
- sbcl-cffi))
- (home-page "https://github.com/sdilts/cl-xkbcommon";)
- (synopsis "Common Lisp FFI bindings for xkbcommon")
+ (list sbcl-40ants-doc
+ sbcl-alexandria
+ sbcl-babel
+ sbcl-local-time
+ sbcl-osicat
+ sbcl-split-sequence
+ sbcl-tar-file))
+ (home-page "https://gitlab.common-lisp.net/cl-tar/cl-tar";)
+ (synopsis "High-level interface for tar files")
(description
- "This package provides Common Lisp FFI bindings for xkbcommon
-(libxkbcommon) using cffi-grovel.")
+ "@code{cl-tar} is a Common Lisp library providing a high-level interface
+for interacting with tar archives.")
(license license:expat))))
-(define-public cl-xkbcommon
- (sbcl-package->cl-source-package sbcl-xkbcommon))
-
-(define-public ecl-xkbcommon
- (sbcl-package->ecl-package sbcl-xkbcommon))
-
-(define-public sbcl-njson
- (package
- (name "sbcl-njson")
- (version "1.2.2")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/atlas-engineer/njson";)
- (commit version)))
- (file-name (git-file-name "cl-njson" version))
- (sha256
- (base32
- "05v5bk3l47mds4ihxs8jlqm19gqq7hb4q0161bgg99w9847l63lk"))))
- (build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cl-json sbcl-jzon))
- (native-inputs (list sbcl-lisp-unit2))
- (arguments
- '(#:asd-systems '("njson" "njson/cl-json" "njson/jzon")))
- (home-page "https://github.com/atlas-engineer/njson";)
- (synopsis "JSON handling framework for Common Lisp")
- (description
- "NJSON aims to make it convenient for one to decode, encode,
-and process JSON data, in the minimum keystrokes/minutes possible.
-
-NJSON is parser-independent, with existing Common Lisp JSON parsers being
-loadable as additional system. @code{jzon} is included by default, though.
-Conveniences that NJSON provides are:
-
-@itemize
-@item @code{encode} and @code{decode} as single entry points for JSON reading
-and writing, be it from streams/string/files, or from those.
-
-@item @code{jget}, @code{jcopy}, @code{jkeys}, and their aliases to
-manipulate the decoded objects' properties without the need to worry
-about the low-level details of how these values are decoded.
-
-@item @code{jif}, @code{jwhen}, @code{jor}, @code{jand}, and other macros
-mimicking Lisp ones, while using truth values of JSON-decoded data.
+(define-public cl-tar
+ (sbcl-package->cl-source-package sbcl-tar))
-@item @code{jbind} and @code{jmatch} macros to destructure and
-validate parsed JSON.
+(define-public ecl-tar
+ (sbcl-package->ecl-package sbcl-tar))
-@item @code{njson/aliases} package to nickname to @code{j} for all the
-forms conveniently accessible as @code{j:get}, @code{j:copy},
-@code{j:if} etc.
+(define-public sbcl-tar-file
+ (let ((commit "0c10bc82f14702c97a26dc25ce075b5d3a2347d1")
+ (revision "0"))
+ (package
+ (name "sbcl-tar-file")
+ (version (git-version "0.2.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://gitlab.common-lisp.net/cl-tar/cl-tar-file";)
+ (commit commit)))
+ (file-name (git-file-name "cl-tar-file" version))
+ (sha256
+ (base32 "0i8j05fkgdqy4c4pqj0c68sh4s3klpx9kc5wp73qwzrl3xqd2svy"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-40ants-doc
+ sbcl-alexandria
+ sbcl-babel
+ sbcl-chipz
+ sbcl-flexi-streams
+ sbcl-salza2
+ sbcl-trivial-gray-streams))
+ (home-page "https://gitlab.common-lisp.net/cl-tar/cl-tar-file";)
+ (synopsis "Read and write physical entries to and from tar files")
+ (description
+ "@code{cl-tar-file} is a Common Lisp library that allows reading from
+and writing to various tar archive formats. Currently supported are the POSIX
+ustar, PAX (ustar with a few new entry types), GNU, and v7 (very old) formats.
-@end itemize\n")
- (license license:bsd-3)))
+This library is rather low level and is focused exclusively on reading and
+writing physical tar file entries using streams. Therefore, it contains no
+functionality for automatically building archives from a set of files on the
+filesystem or writing the contents of a file to the filesystem. Additionally,
+there are no smarts that read multiple physical entries and combine them into
+a single logical entry (e.g., with PAX extended headers or GNU long link/path
+name support). For a higher-level library that reads and writes logical
+entries, and also includes filesystem integration, see @code{cl-tar}.")
+ (license license:bsd-3))))
-(define-public cl-njson
- (sbcl-package->cl-source-package sbcl-njson))
+(define-public cl-tar-file
+ (sbcl-package->cl-source-package sbcl-tar-file))
-(define-public ecl-njson
- (sbcl-package->ecl-package sbcl-njson))
+(define-public ecl-tar-file
+ (sbcl-package->ecl-package sbcl-tar-file))
-(define-public sbcl-nactivitypub
- (package
- (name "sbcl-nactivitypub")
- (version "0.0.5")
- (source (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/atlas-engineer/nactivitypub";)
- (commit version)))
- (file-name (git-file-name "cl-nactivitypub" version))
- (sha256
- (base32
- "0m2vwi11zp0bpvr0hglq1svdxlp3cc70yvix30yksfzp6kk3amyn"))))
- (build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cl-str
- sbcl-dexador
- sbcl-local-time
- sbcl-lparallel
- sbcl-njson
- sbcl-quri
- sbcl-serapeum))
- (home-page "https://github.com/atlas-engineer/nactivitypub";)
- (synopsis
- "Common Lisp implementation of ActivityPub and ActivityStreams standards")
- (description
- "This package provides a Common Lisp implementation of ActivityPub and
-ActivityStreams standards for social networking.
+(define-public sbcl-terminal-keypress
+ (let ((commit "2ef48c045aa627229764b2aa393a83d392d93d08")
+ (revision "1"))
+ (package
+ (name "sbcl-terminal-keypress")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/eudoxia0/terminal-keypress";)
+ (commit commit)))
+ (file-name (git-file-name "cl-terminal-keypress" version))
+ (sha256
+ (base32 "11c4krpq5x55qkchx6ykcnb455ssb4r3jjywx3c3irfrkj733ybp"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria sbcl-trivial-raw-io))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/eudoxia0/terminal-keypress";)
+ (synopsis "Read keyboard events in the terminal from Common Lisp")
+ (description
+ "This is a library for reading semi-raw user input from terminals.
+Semi-raw as in, we can't detect if the user pressed the @code{Control} key
+alone, and the function keys are a mystery. What is supported, however, is:
-Features:
@itemize
+@item Regular characters
+@item Control+[key]
+@item Alt+[key]
+@item Control+Alt+[key]
+@end itemize")
+ (license license:expat))))
-@item Parsing and un-parsing ActivityStreams JSON-LD objects to/from CLOS
-objects with convenient accessors on those.
-
-@item Sending and fetching ActivityStreams objects to/from the
-ActivityStreams-enabled HTTP(S) URLs.
-
-@item Semantic info extraction with methods like @code{name*}, @code{url*},
-@code{author*}, and @code{published*}.
+(define-public cl-terminal-keypress
+ (sbcl-package->cl-source-package sbcl-terminal-keypress))
-@item No reliance on JSON parser. @code{njson} is used for parser-independent
-JSON handling. Load the parser backend you prefer!
+(define-public ecl-terminal-keypress
+ (sbcl-package->ecl-package sbcl-terminal-keypress))
-@end itemize")
- (license license:bsd-3)))
+(define-public sbcl-terminal-size
+ (let ((commit "e0b3d56a9dd3366baf2a05d84381da5747a2ef4a")
+ (revision "1"))
+ (package
+ (name "sbcl-terminal-size")
+ (version (git-version "0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/eudoxia0/terminal-size";)
+ (commit commit)))
+ (file-name (git-file-name "cl-terminal-size" version))
+ (sha256
+ (base32 "1212wbadms9jzrqgarpj3d9xh9w4dab8jhx4k2aryqgf116zs42h"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cffi sbcl-osicat))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/eudoxia0/terminal-size";)
+ (synopsis "Get the size of the terminal from Common Lisp")
+ (description
+ "This package provides the @code{terminal-size:size} function to get the
+size of the terminal from Common Lisp.")
+ (license license:expat))))
-(define-public cl-nactivitypub
- (sbcl-package->cl-source-package sbcl-nactivitypub))
+(define-public cl-terminal-size
+ (sbcl-package->cl-source-package sbcl-terminal-size))
-(define-public ecl-nactivitypub
- (sbcl-package->ecl-package sbcl-nactivitypub))
+(define-public ecl-terminal-size
+ (sbcl-package->ecl-package sbcl-terminal-size))
-(define-public sbcl-nsymbols
- (package
- (name "sbcl-nsymbols")
- (version "0.3.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/atlas-engineer/nsymbols";)
- (commit version)))
- (file-name (git-file-name "cl-nsymbols" version))
- (sha256
- (base32 "1awh793s4fwhddllfcjz4sbkxwinh5w54s3glxh7rv00c7skdjd6"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-lisp-unit2))
- (inputs (list cl-closer-mop))
- (arguments
- '(#:asd-systems '("nsymbols" "nsymbols/star")))
- (synopsis
- "Functions to search, filter, and group symbols in chosen packages")
- (home-page "https://github.com/atlas-engineer/nsymbols";)
- (description "Nsymbols extends the regular package API of ANSI CL with more
-operations, allowing one to list:
+(define-public sbcl-terminfo
+ (let ((commit "b8b2e3ed786bfcf9f1aa4a264cee2e93135080f5")
+ (revision "1"))
+ (package
+ (name "sbcl-terminfo")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/npatrick04/terminfo";)
+ (commit commit)))
+ (file-name (git-file-name "terminfo" version))
+ (sha256
+ (base32 "1nmin9rr6f75xdhxysba66xa1dh62fh27w9ad1cvmj0062armf6b"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Terminfo database front end in Common Lisp")
+ (home-page "https://github.com/npatrick04/terminfo";)
+ (description
+ "This is a terminfo database front end in Common Lisp. The package
+provides a method for determining which capabilities a terminal
+(e.g. \"xterm\") has and methods to compile or put commands to a stream.")
+ (license license:expat))))
-@itemize
-@item @code{package-symbols}.
-@item @code{package-variables}.
-@item @code{package-functions}.
-@item @code{package-generic-functions}.
-@item @code{package-macros}.
-@item @code{package-classes}.
-@item @code{package-structures}.
-@item And other symbol types, given @code{define-symbol-type} for those.
-@end itemize
+(define-public cl-terminfo
+ (sbcl-package->cl-source-package sbcl-terminfo))
-Nsymbols can also find symbols by their name/matching symbol with
-@code{resolve-symbol}. All these operations are aware of symbol
-visibility in the given packages, due to a @code{symbol-visibility}
-function.
+(define-public ecl-terminfo
+ (sbcl-package->ecl-package sbcl-terminfo))
-An additional @code{nsymbols/star} system has a set of functions
-mirroring the regular Nsymbols ones, but using @code{closer-mop} to
-provide better results and returning structured data instead of
-symbols.")
- (license license:bsd-3)))
+(define-public sbcl-terrable
+ (let ((commit "e4fe23ffa08e8d53a8168105b413861da59cc786")
+ (revision "1"))
+ (package
+ (name "sbcl-terrable")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shirakumo/terrable";)
+ (commit commit)))
+ (file-name (git-file-name "terrable" version))
+ (sha256
+ (base32 "0pnqflgz410zydc1ivwnd8hcl24bgr7x12yjzr7g4lq3ibc8y97b"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-documentation-utils sbcl-fast-io sbcl-ieee-floats
+ sbcl-static-vectors sbcl-trivial-garbage))
+ (home-page "https://shirakumo.github.io/terrable/";)
+ (synopsis "Parser library for Terragen TER terrain files")
+ (description
+ "This package provides Common Lisp support for reading the Terragen
+@code{.TER} format. The format specification can be found at
+@url{https://planetside.co.uk/wiki/index.php?title=Terragen_.TER_Format}";)
+ (license license:zlib))))
-(define-public cl-nsymbols
- (sbcl-package->cl-source-package sbcl-nsymbols))
+(define-public cl-terrable
+ (sbcl-package->cl-source-package sbcl-terrable))
-(define-public ecl-nsymbols
- (sbcl-package->ecl-package sbcl-nsymbols))
+(define-public ecl-terrable
+ (sbcl-package->ecl-package sbcl-terrable))
-(define-public sbcl-utils-kt
- (let ((commit "4adfe2889036ab5ffdd3cc2182ca2cc692bf11ff"))
+(define-public sbcl-the-cost-of-nothing
+ (let ((commit "f364029fbbf37ae5786f2f9ddf6185dd204a7185")
+ (revision "0"))
(package
- (name "sbcl-utils-kt")
- (version (git-version "2007-12-02" "1" commit))
+ (name "sbcl-the-cost-of-nothing")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/kennytilton/utils-kt";)
+ (url "https://github.com/marcoheisig/the-cost-of-nothing";)
(commit commit)))
- (file-name (git-file-name "cl-utils-kt" version))
+ (file-name (git-file-name "cl-the-cost-of-nothing" version))
(sha256
- (base32 "016x3w034brz02z9mrsrkhk2djizg3yqsvhl9k62xqcnpy3b87dn"))))
+ (base32 "1ccrglyr1wnnfp218w1qj7yfl4yzlxkki3hqaifi5axgbi5dmmh8"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/kennytilton/utils-kt";)
- (synopsis "Kenny's utilities for Common Lisp")
+ (arguments
+ ;; The test operation benchmarks the Common Lisp implementation; it
+ ;; doesn't test the package.
+ (list #:tests? #f))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-local-time
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/marcoheisig/the-cost-of-nothing";)
+ (synopsis "Measure the run time of Common Lisp code")
(description
- "This library contains generic hacks meant to be used in any project.
-It was originally developed for the Cells library.")
+ "THE-COST-OF-NOTHING is a library for measuring the run time of Common
+Lisp code. It provides macros and functions for accurate benchmarking and
+lightweight monitoring. Furthermore, it provides predefined benchmarks to
+determine the cost of certain actions on a given platform and implementation.")
(license license:expat))))
-(define-public cl-utils-kt
- (sbcl-package->cl-source-package sbcl-utils-kt))
+(define-public cl-the-cost-of-nothing
+ (sbcl-package->cl-source-package sbcl-the-cost-of-nothing))
-(define-public ecl-utils-kt
- (sbcl-package->ecl-package sbcl-utils-kt))
+(define-public ecl-the-cost-of-nothing
+ (sbcl-package->ecl-package sbcl-the-cost-of-nothing))
-(define-public sbcl-cells
- (let ((commit "e8542b17fddd6340c1e237ce482a52327c8ead8e"))
+(define-public sbcl-tooter
+ (let ((commit "2dcc2facddcacd79d0cce545a8c4b73c35826fc1")
+ (revision "4"))
(package
- (name "sbcl-cells")
- (version (git-version "3.0" "1" commit))
+ (name "sbcl-tooter")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/kennytilton/cells";)
+ (url "https://github.com/Shinmera/tooter";)
(commit commit)))
- (file-name (git-file-name "cl-cells" version))
+ (file-name (git-file-name "cl-tooter" version))
(sha256
- (base32 "0rkzvwq38lwb1045w54kw020pb9i63hxiawwhqkf8k1inhak3fdk"))))
+ (base32 "1zisrmslj4rnibm02vxh7hbas2cfsjh6iizs2nfdg3a3pn7bhf6h"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-utils-kt))
- (arguments
- ;; Tests fail with #<TYPE-ERROR expected-type: STREAM datum: NIL>.
- '(#:tests? #f))
- (home-page "https://github.com/kennytilton/cells";)
- (synopsis "Common Lisp implementation of the dataflow programming
paradigm")
+ (list sbcl-alexandria
+ sbcl-cl-ppcre
+ sbcl-documentation-utils
+ sbcl-drakma
+ sbcl-yason))
+ (synopsis "Common Lisp client library for Mastodon instances")
(description
- "Cells is a mature, stable extension to CLOS allowing one to create
-classes whose instances can have slot values determined by instance-specific
-formulas.")
- (license license:llgpl))))
+ "This is a Common Lisp library implementing the full v1 REST API
+protocol for Mastodon.")
+ (home-page "https://shinmera.github.io/tooter/";)
+ (license license:zlib))))
-(define-public cl-cells
- (sbcl-package->cl-source-package sbcl-cells))
+(define-public cl-tooter
+ (sbcl-package->cl-source-package sbcl-tooter))
-(define-public ecl-cells
- (sbcl-package->ecl-package sbcl-cells))
+(define-public ecl-tooter
+ (sbcl-package->ecl-package sbcl-tooter))
-(define-public sbcl-cl-algebraic-data-type
- (let ((commit "b2568428193a512d141d6b615772d50ceb5f9bca"))
+(define-public sbcl-transmission
+ (let ((commit "4bbf1d2761bfa5dfa79b7bc12c3238089b994d95"))
(package
- (name "sbcl-cl-algebraic-data-type")
- (version (git-version "1.2.0" "1" commit))
+ (name "sbcl-transmission")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/stylewarning/cl-algebraic-data-type";)
+ (url "https://github.com/libre-man/cl-transmission/";)
(commit commit)))
- (file-name (git-file-name "cl-algebraic-data-type" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1lnqxcv8pd5z8n0g5p2l0dbljx9pqiv18hxl0vhsh7ldhkrjv2jx"))))
+ (base32 "0sg3f2jqs2z3mvscjhc43hkd34vlcc4c8hq8rhh5w1gjg19z57hb"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-global-vars))
(arguments
- '(#:tests? #f)) ; No tests.
- (home-page "https://github.com/stylewarning/cl-algebraic-data-type";)
- (synopsis "Common Lisp library for algebraic data types")
- (description
- "CL-ALGEBRAIC-DATA-TYPE, or ADT, is a library for defining algebraic
-data types in a similar spirit to Haskell or Standard ML, as well as for
-operating on them.")
- (license license:bsd-3))))
+ '(#:asd-systems '("cl-transmission")))
+ (inputs
+ (list sbcl-cl-ppcre sbcl-jonathan sbcl-named-readtables sbcl-rutils
+ sbcl-drakma))
+ (native-inputs
+ (list sbcl-prove))
+ (home-page "https://github.com/libre-man/cl-transmission/";)
+ (synopsis "Common Lisp interface with Transmission using its RPC")
+ (description
+ "@code{cl-transmission} is a library to interface with the Transmission
+torrent client using its RPC (remote procedure call).")
+ (license license:expat))))
-(define-public cl-algebraic-data-type
- (sbcl-package->cl-source-package sbcl-cl-algebraic-data-type))
+(define-public cl-transmission
+ (sbcl-package->cl-source-package sbcl-transmission))
-(define-public ecl-algebraic-data-type
- (sbcl-package->ecl-package sbcl-cl-algebraic-data-type))
+(define-public ecl-transmission
+ (sbcl-package->ecl-package sbcl-transmission))
-(define-public sbcl-screamer
- (let ((commit "ce50614024de090b376107668da5e53232540ec7"))
+(define-public sbcl-trees
+ (let ((commit "7b06048af0248c4302088c758208276f9faf2beb"))
(package
- (name "sbcl-screamer")
- (version (git-version "0.0.1" "1" commit))
+ (name "sbcl-trees")
+ (version (git-version "0.11" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/nikodemus/screamer/";)
+ (url "https://github.com/froydnj/trees/";)
(commit commit)))
- (file-name (git-file-name "cl-screamer" version))
+ (file-name (git-file-name "cl-trees" version))
(sha256
- (base32 "1jl42pl6kwkiq71d0naf3r1mn1qy89ndimfgiz58c4g66xbjb7kx"))))
+ (base32 "1xvydf3qc17rd7ia8sffxcpclgm3l0iyhx8k72ddk59v3pg5is4k"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-iterate
- sbcl-hu.dwim.stefil))
- (home-page "https://nikodemus.github.io/screamer/";)
- (synopsis "Nondeterministic programming and constraint propagation")
+ (home-page "https://github.com/froydnj/trees/";)
+ (synopsis "Binary trees in normal and balanced flavors")
(description
- "Screamer is an extension of Common Lisp that adds support for
-nondeterministic programming. Screamer consists of two levels. The basic
-nondeterministic level adds support for backtracking and undoable side
-effects. On top of this nondeterministic substrate, Screamer provides a
-comprehensive constraint programming language in which one can formulate and
-solve mixed systems of numeric and symbolic constraints. Together, these two
-levels augment Common Lisp with practically all of the functionality of both
-Prolog and constraint logic programming languages such as CHiP and CLP(R).
-Furthermore, Screamer is fully integrated with Common Lisp. Screamer programs
-can coexist and interoperate with other extensions to as CLIM and Iterate.")
- (license license:expat))))
+ "This package implements binary trees of various kinds, presenting a
+uniform interface to them all.")
+ (license license:bsd-3))))
-(define-public cl-screamer
- (sbcl-package->cl-source-package sbcl-screamer))
+(define-public cl-trees
+ (sbcl-package->cl-source-package sbcl-trees))
-(define-public ecl-screamer
- (sbcl-package->ecl-package sbcl-screamer))
+(define-public ecl-trees
+ (sbcl-package->ecl-package sbcl-trees))
-(define-public sbcl-clache
- (let ((commit "112976729565e1035532389ca25090ae99badd07"))
+(define-public sbcl-triads
+ (let ((commit "840b025bf3d65cc5eaead4542a02a3ca6d77c2b6")
+ (revision "0"))
(package
- (name "sbcl-clache")
- (version (git-version "0.2.1" "1" commit))
+ (name "sbcl-triads")
+ (version (git-version "0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/html/clache/";)
+ (url "https://github.com/charJe/triads";)
(commit commit)))
- (file-name (git-file-name "cl-clache" version))
+ (file-name (git-file-name "cl-triads" version))
(sha256
- (base32 "0wxg004bsay58vr6xr6mlk7wj415qmvisqxvpnjsg6glfwca86ys"))))
+ (base32 "146mwshynhdw82m2nxrcjvf1nk0z3fn6ywcd2vqxkly5qricc53w"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cl-annot
- sbcl-cl-fad
- sbcl-cl-store
- sbcl-cl-syntax
- sbcl-ironclad
- sbcl-trivial-garbage))
- (native-inputs
- (list sbcl-prove))
+ (outputs '("out" "bin"))
(arguments
- `(#:phases
+ '(#:asd-systems '("charje.triads")
+ #:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "clache-test.asd"
- (("cl-test-more") "prove"))
- #t)))))
- (home-page "https://github.com/html/clache/";)
- (synopsis "General caching facility for Common Lisp")
- (description
- "CLACHE provides a general caching facility for Common Lisp. The API is
-similar to the standard hash-table interface.")
- (license license:llgpl))))
+ (add-after 'create-asdf-configuration 'build-binary
+ (lambda* (#:key outputs #:allow-other-keys)
+ (setenv "HOME" (getcwd))
+ (invoke
+ "sbcl" "--eval" "(require :asdf)" "--eval"
+ (format
+ #f "~S"
+ `(progn
+ (require "charje.triads"
+ ,(string-append (getcwd) "/charje.triads.asd"))
+ (asdf:make "charje.triads"))))
+ (install-file
+ (string-append (getcwd) "/triads")
+ (string-append (assoc-ref outputs "bin") "/bin")))))))
+ (inputs
+ (list sbcl-cl-str
+ sbcl-serapeum
+ sbcl-trivia))
+ (home-page "https://github.com/charJe/triads";)
+ (synopsis "Music composition tool to convert roman numerals into triads")
+ (description "Triads is a simple command line tool that reads roman
+numeral notation from standard input (or a file) and an musical key and outputs
+the roman numeral in addition to the notes of the triad associated with that
+roman numeral given in the key.")
+ (license license:gpl3))))
-(define-public cl-clache
- (sbcl-package->cl-source-package sbcl-clache))
+(define-public cl-triads
+ (sbcl-package->cl-source-package sbcl-triads))
-(define-public ecl-clache
- (sbcl-package->ecl-package sbcl-clache))
+(define-public ecl-triads
+ (let ((ecl-package (sbcl-package->ecl-package sbcl-triads)))
+ (package
+ (inherit ecl-package)
+ (outputs '("out"))
+ (arguments
+ (substitute-keyword-arguments (package-arguments ecl-package)
+ ((#:phases phases)
+ `(modify-phases ,phases
+ (delete 'build-binary))))))))
-(define-public sbcl-definitions
- (let ((commit "1f4bd7a634a2299aea19cefb5da8041bbb27f2ec"))
+(define-public sbcl-trial
+ (let ((commit "db4e98ede16640238bd51bf5d63cda57c75a51ae")
+ (revision "2"))
(package
- (name "sbcl-definitions")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-trial")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/definitions/";)
+ (url "https://github.com/Shirakumo/trial";)
(commit commit)))
- (file-name (git-file-name "cl-definitions" version))
+ (file-name (git-file-name "cl-trial" version))
(sha256
- (base32 "16dh9iy3v344xj4qllsp47007px3yx26fxxh9gh2cvs8dqgk3kch"))))
+ (base32 "0haslkzcgivz42k23n90w1dzw8zdgdrqcndadl33pqqlf0d20ilw"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems '("trial"
+ "trial-alloy"
+ "trial-animation"
+ "trial-assimp"
+ ;; TODO: It requires a long packaging journey.
+ ;; "trial-feedback"
+ "trial-gif"
+ "trial-glfw"
+ ;; FIXME: Check why this system is failing:
+ ;; WARNING: Invalid qualifiers for APPEND method
+ ;; combination in method
+ ;; ...
+ ;; "trial-glop"
+ "trial-gltf"
+ "trial-harmony"
+ "trial-jpeg"
+ "trial-notify"
+ "trial-png"
+ ;; TODO: I'm not sure which QOI system to use here.
There are two:
+ ;; - https://github.com/bpanthi977/qoi
+ ;; - https://github.com/mfiano/qoi
+ ;; "trial-qoi"
+ ;; TODO: It requires a long packaging journey.
+ ;; "trial-qt"
+ "trial-sdl2"
+ "trial-terragen"
+ "trial-tga"
+ "trial-tiff"
+ "trial-workbench")))
+ (native-inputs
+ (list sbcl-trivial-features))
(inputs
- (list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/definitions";)
- (synopsis "General definitions reflection library")
+ (list sbcl-3d-matrices
+ sbcl-3d-quaternions
+ sbcl-3d-transforms
+ sbcl-3d-vectors
+ sbcl-alexandria
+ sbcl-alloy
+ sbcl-atomics
+ sbcl-bordeaux-threads
+ sbcl-cl-gamepad
+ sbcl-cl-glfw3
+ sbcl-cl-gltf
+ sbcl-cl-jpeg
+ sbcl-cl-opengl
+ sbcl-cl-ppcre
+ sbcl-cl-tga
+ sbcl-classimp
+ sbcl-closer-mop
+ sbcl-deploy
+ sbcl-dns-client
+ sbcl-fast-io
+ sbcl-file-notify
+ sbcl-flare
+ sbcl-float-features
+ sbcl-flow
+ sbcl-for
+ sbcl-form-fiddle
+ sbcl-glop
+ sbcl-glsl-toolkit
+ sbcl-harmony
+ sbcl-ieee-floats
+ sbcl-jzon
+ sbcl-lambda-fiddle
+ sbcl-language-codes
+ sbcl-lquery
+ sbcl-messagebox
+ sbcl-mmap
+ sbcl-pathname-utils
+ sbcl-pngload
+ sbcl-promise
+ sbcl-retrospectiff
+ sbcl-sdl2
+ sbcl-simple-tasks
+ sbcl-static-vectors
+ sbcl-system-locale
+ sbcl-terrable
+ sbcl-trivial-extensible-sequences
+ sbcl-trivial-garbage
+ sbcl-trivial-indent
+ sbcl-trivial-main-thread
+ sbcl-verbose
+ sbcl-zpng))
+ (home-page "https://github.com/Shirakumo/trial";)
+ (synopsis "Common Lisp game engine")
(description
- "This system implements a general definitions introspection library.
-It gives you the ability to retrieve definitions or bindings associated with
-designators such as symbols, packages, and names in general. For instance, it
-allows you to retrieve all function, type, variable, method, etc. definitions
-of a symbol.")
+ "Trial is a game engine written in Common Lisp. Unlike many other
+engines, it is meant to be more of a loose connection of components that can be
+fit together as required by any particular game.")
(license license:zlib))))
-(define-public cl-definitions
- (sbcl-package->cl-source-package sbcl-definitions))
+(define-public cl-trial
+ (sbcl-package->cl-source-package sbcl-trial))
-(define-public ecl-definitions
- (sbcl-package->ecl-package sbcl-definitions))
+;; TODO: Enable with new ECL when this issue is fixed:
+;; https://github.com/Shinmera/3d-quaternions/issues/2
+;; (define-public ecl-trial
+;; (sbcl-package->ecl-package sbcl-trial))
-(define-public sbcl-filtered-functions
- (let ((commit "130f69e7b9e1051bf569ef63364b09a3873f0ced"))
+(define-public sbcl-tripod
+ (let ((commit "b019a27cd7eb895870f84b0eb6c3edc5d7b05928")
+ (revision "1"))
(package
- (name "sbcl-filtered-functions")
- (version (git-version "0.2.0" "1" commit))
+ (name "sbcl-tripod")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pcostanza/filtered-functions";)
+ (url "https://github.com/aartaka/tripod";)
(commit commit)))
- (file-name (git-file-name "cl-filtered-functions" version))
+ (file-name (git-file-name "cl-tripod" version))
(sha256
- (base32 "0m13k8pl0gfll8ss83c0z3gax7zrrw2i4s26451jfbka1xr4fgy9"))))
+ (base32 "0y8sns6njq9x7km58vpj7gx4cia9zkcpng3d38300xk0nnk2kz8w"))))
(build-system asdf-build-system/sbcl)
+ (outputs '("out" "bin"))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'create-asdf-configuration 'build-program
+ (lambda* (#:key outputs #:allow-other-keys)
+ ;; FIXME: Using #$output:bin here prevents cl-tripod and
+ ;; ecl-tripod from building, but using assoc-ref works.
+ (build-program (string-append ;; #$output:bin
+ (assoc-ref outputs "bin")
+ "/bin/tripod")
+ outputs
+ #:entry-program '((tripod:entry-point))
+ #:compress? #t))))))
(inputs
- (list sbcl-closer-mop))
- (home-page "https://github.com/pcostanza/filtered-functions";)
- (synopsis "Extension of CLOS generic function invocation")
+ (list sbcl-alexandria
+ sbcl-cl-gopher
+ sbcl-cl-markdown
+ sbcl-clss
+ sbcl-hunchentoot
+ sbcl-local-time
+ sbcl-nactivitypub
+ sbcl-njson
+ sbcl-phos
+ sbcl-plump
+ sbcl-trivial-mimes))
+ (home-page "https://aartaka.me/blog/tripod";)
+ (synopsis "Common Lisp web server aiming to ease website hosting")
(description
- "Filtered functions provide an extension of CLOS generic function
-invocation that add a simple preprocessing step before the actual method
-dispatch is performed and thus enable the use of arbitrary predicates for
-selecting and applying methods. See
-@url{http://www.p-cos.net/documents/filtered-dispatch.pdf} for a paper that
-introduces and explains filtered functions in detail.")
- (license license:expat))))
+ "Tripod is a Common Lisp web server aiming to ease plain text, HTML,
+and Gopher website hosting.")
+ (license license:bsd-2))))
-(define-public cl-filtered-functions
- (sbcl-package->cl-source-package sbcl-filtered-functions))
+(define-public cl-tripod
+ ;; No "bin" output for the source package.
+ (let ((pkg (sbcl-package->cl-source-package sbcl-tripod)))
+ (package/inherit pkg
+ (outputs '("out")))))
-(define-public ecl-filtered-functions
- (sbcl-package->ecl-package sbcl-filtered-functions))
+(define-public ecl-tripod
+ ;; FIXME: Making a standalone binary doesn't work with ECL.
+ (let ((pkg (sbcl-package->ecl-package sbcl-tripod)))
+ (package/inherit pkg
+ (outputs '("out"))
+ (arguments
+ (substitute-keyword-arguments (package-arguments pkg)
+ ((#:phases phases)
+ #~(modify-phases #$phases
+ (delete 'build-program))))))))
-(define-public sbcl-defstar
- (let ((commit "132829dac9f84fa7202a0c5793aa6accb8d2662a"))
+;;; Split the trivia package in two to work around the circular dependency
+;;; between guicho271828/trivia and guicho271828/type-i.
+(define-public sbcl-trivia.trivial
+ (let ((commit "8b406c3f83521d290e97bb787d3f6c1eb3b716af")
+ (revision "0"))
(package
- (name "sbcl-defstar")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-trivia.trivial")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://bitbucket.org/eeeickythump/defstar/";)
+ (url "https://github.com/guicho271828/trivia";)
(commit commit)))
- (file-name (git-file-name "cl-defstar" version))
+ (file-name (git-file-name "cl-trivia" version))
(sha256
- (base32 "0n6m3aqvdfnsrhlhqjcy72d1i55lbkjg13ij5c7vw003p1n78wxi"))))
+ (base32
+ "0fnnjnba07qrsf82jm4q6dini7z72xabcssy5y2bqy082r07l8l7"))))
(build-system asdf-build-system/sbcl)
- (home-page "http://bitbucket.org/eeeickythump/defstar/";)
- (synopsis "Easy inline (return) type declarations for functions")
- (description
- "Defstar is a collection of Common Lisp macros that can be used in
-place of @code{defun}, @code{defmethod}, @code{defgeneric}, @code{defvar},
-@code{defparameter}, @code{flet}, @code{labels}, @code{let*} and
-@code{lambda}. Each macro has the same name as the form it replaces, with a
-star added at the end, e.g. @code{defun}. (the exception is the @code{let*}
-replacement, which is called @code{*let}).")
- (license license:gpl3))))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-closer-mop
+ sbcl-lisp-namespace
+ sbcl-trivial-cltl2))
+ (arguments
+ '(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("trivia.balland2006.asd"
+ "trivia.ppcre.asd"
+ "trivia.quasiquote.asd"
+ "trivia.cffi.asd"
+ "trivia.fset.asd"
+ "trivia.asd"
+ "trivia.test.asd")))))))
+ (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.")
+ (home-page "https://github.com/guicho271828/trivia";)
+ (license license:llgpl))))
-(define-public cl-defstar
- (sbcl-package->cl-source-package sbcl-defstar))
+(define-public cl-trivia.trivial
+ (sbcl-package->cl-source-package sbcl-trivia.trivial))
-(define-public ecl-defstar
- (sbcl-package->ecl-package sbcl-defstar))
+(define-public ecl-trivia.trivial
+ (sbcl-package->ecl-package sbcl-trivia.trivial))
-(define-public sbcl-dynamic-mixins
- (let ((commit "7cc09bee7d68527f37406671fabe910e8235b746"))
+(define-public sbcl-trivia
+ (package
+ (inherit sbcl-trivia.trivial)
+ (name "sbcl-trivia")
+ (native-inputs
+ (list sbcl-fiveam
+ sbcl-optima))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-cl-ppcre
+ sbcl-fare-quasiquote
+ sbcl-fset
+ sbcl-iterate
+ sbcl-trivia.trivial
+ sbcl-type-i))
+ (arguments
+ '(#:asd-systems '("trivia"
+ "trivia.ppcre"
+ "trivia.quasiquote"
+ "trivia.cffi"
+ "trivia.fset")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-build
+ (lambda _
+ (for-each delete-file
+ '("trivia.level0.asd"
+ "trivia.level1.asd"
+ "trivia.level2.asd"
+ "trivia.trivial.asd")))))))))
+
+(define-public cl-trivia
+ (sbcl-package->cl-source-package sbcl-trivia))
+
+(define-public ecl-trivia
+ (sbcl-package->ecl-package sbcl-trivia))
+
+(define-public sbcl-trivial-arguments
+ (let ((commit "ecd84ed9cf9ef8f1e873d7409e6bd04979372aa7")
+ (revision "1"))
(package
- (name "sbcl-dynamic-mixins")
- (version (git-version "0.0" "1" commit))
+ (name "sbcl-trivial-arguments")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/dynamic-mixins";)
+ (url "https://github.com/Shinmera/trivial-arguments";)
(commit commit)))
- (file-name (git-file-name "cl-dynamic-mixins" version))
+ (file-name (git-file-name "trivial-arguments" version))
(sha256
- (base32 "00g3s509ysh2jp1qwsgb5bwl6qvhzcljwjz3z4mspbcak51484zj"))))
+ (base32 "02vaqfavhj8jqxnr68nnzvzshm8jbgcy6m9lvyv4daa6f7ihqf88"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-closer-mop))
- (home-page "https://github.com/rpav/dynamic-mixins";)
- (synopsis "Simple, dynamic class combination for CLOS")
+ (home-page "https://github.com/Shinmera/trivial-arguments";)
+ (synopsis "Common Lisp library to retrieve a function's lambda-list")
(description
- "Dynamic-mixins is for simple, dynamic class combination; it allows
-objects to be mixed and updated without manually defining many permutations.")
- (license license:bsd-2))))
+ "This is a simple library to retrieve the argument list of a function.")
+ (license license:zlib))))
-(define-public cl-dynamic-mixins
- (sbcl-package->cl-source-package sbcl-dynamic-mixins))
+(define-public cl-trivial-arguments
+ (sbcl-package->cl-source-package sbcl-trivial-arguments))
-(define-public ecl-dynamic-mixins
- (sbcl-package->ecl-package sbcl-dynamic-mixins))
+(define-public ecl-trivial-arguments
+ (sbcl-package->ecl-package sbcl-trivial-arguments))
+
+(define-public sbcl-trivial-backtrace
+ (let ((commit "7f90b4a4144775cca0728791e4b92ac2557b07a1")
+ (revision "2"))
+ (package
+ (name "sbcl-trivial-backtrace")
+ (version (git-version "1.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/hraban/trivial-backtrace";)
+ (commit commit)))
+ (file-name (git-file-name "trivial-backtrace" version))
+ (sha256
+ (base32 "11j0p3vgmnn5q84xw7sacr5p3cvff2hfhsh2is8xpm2iwxc723kn"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lift))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'check 'delete-test-results
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((test-results (string-append (assoc-ref outputs "out")
+ "/share/common-lisp/"
+ (%lisp-type)
+ "/trivial-backtrace"
+ "/test-results")))
+ (when (file-exists? test-results)
+ (delete-file-recursively test-results)))
+ #t)))))
+ (home-page "https://common-lisp.net/project/trivial-backtrace/";)
+ (synopsis "Portable simple API to work with backtraces in Common Lisp")
+ (description
+ "One of the many things that didn't quite get into the Common Lisp
+standard was how to get a Lisp to output its call stack when something has
+gone wrong. As such, each Lisp has developed its own notion of what to
+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:expat))))
+
+(define-public cl-trivial-backtrace
+ (sbcl-package->cl-source-package sbcl-trivial-backtrace))
-(define-public sbcl-stealth-mixin
- (let ((commit "2f853fcead554221d4be3b10522b502ea729e944")
- (revision "0"))
+(define-public ecl-trivial-backtrace
+ (sbcl-package->ecl-package sbcl-trivial-backtrace))
+
+(define-public sbcl-trivial-benchmark
+ (let ((commit "1fbc8d15f09ed8aa426bc73956b8b7c9b2668802")
+ (revision "2"))
(package
- (name "sbcl-stealth-mixin")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-trivial-benchmark")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Stealth-mixin";)
+ (url "https://github.com/Shinmera/trivial-benchmark/";)
(commit commit)))
- (file-name (git-file-name "cl-stealth-mixin" version))
+ (file-name (git-file-name "cl-trivial-benchmark" version))
(sha256
- (base32 "0ar9cdmbmdnqz1ywpw34n47hlh0vqmb6pl76f5vbfgip3c81xwyi"))))
+ (base32 "1p48wgpady0n8frdcgp7sbg93b0fbvpx1qk5valmanhwr9j3xh88"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-closer-mop))
- (home-page "https://github.com/robert-strandh/Stealth-mixin";)
- (synopsis "Create stealth mixin classes")
+ (list sbcl-alexandria))
+ (home-page "https://shinmera.github.io/trivial-benchmark/";)
+ (synopsis "Easy to use benchmarking system for Common Lisp")
(description
- "Stealth-mixin is a Common Lisp library for creating stealth mixin
-classes. These are classes that are dynamically mixed into other classes
-without the latter being aware of it.")
- (license license:bsd-2))))
+ "Trivial-Benchmark runs a block of code many times and outputs some
+statistical data for it. On SBCL this includes the data from @code{time}, for
+all other implementations just the @code{real-time} and @code{run-time} data.
+However, you can extend the system by adding your own @code{metrics} to it, or
+even by adding additional statistical @code{compute}ations.")
+ (license license:zlib))))
-(define-public cl-stealth-mixin
- (sbcl-package->cl-source-package sbcl-stealth-mixin))
+(define-public cl-trivial-benchmark
+ (sbcl-package->cl-source-package sbcl-trivial-benchmark))
-(define-public ecl-stealth-mixin
- (sbcl-package->ecl-package sbcl-stealth-mixin))
+(define-public ecl-trivial-benchmark
+ (sbcl-package->ecl-package sbcl-trivial-benchmark))
-(define-public sbcl-sealable-metaobjects
- (let ((commit "e09ec97252e0844528f61abdc0c7ee256875f8ee"))
+(define-public sbcl-trivial-channels
+ (let ((commit "e2370118d8983ba69c0360a7695f8f2e2fd6a8a6")
+ (revision "1"))
(package
- (name "sbcl-sealable-metaobjects")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-trivial-channels")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/sealable-metaobjects/";)
+ (url "https://github.com/rpav/trivial-channels";)
(commit commit)))
- (file-name (git-file-name "cl-sealable-metaobjects" version))
+ (file-name (git-file-name "trivial-channels" version))
(sha256
- (base32 "0hz1ivlpfhnk1w2cw4q2i000j2dc7maay06ndzziyywg7li6zf2p"))))
+ (base32 "04wnxcgk40x8p0gxnz9arv1a5wasdqrdxa8c4p5v7r2mycfps6jj"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-closer-mop))
- (home-page "https://github.com/marcoheisig/sealable-metaobjects/";)
- (synopsis "CLOSsy way to trade genericity for performance")
+ (list sbcl-bordeaux-threads sbcl-trivial-timeout))
+ (home-page "https://github.com/rpav/trivial-channels";)
+ (synopsis "Common Lisp simple thread-safe channels with timeout")
(description
- "This library is an extension of the Common Lisp Object System (CLOS)
-that allows a compiler to inline a generic function under certain
-conditions.")
- (license license:expat))))
+ "It's very basic implementation of channels and queue for Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-sealable-metaobjects
- (sbcl-package->cl-source-package sbcl-sealable-metaobjects))
+(define-public cl-trivial-channels
+ (sbcl-package->cl-source-package sbcl-trivial-channels))
-(define-public ecl-sealable-metaobjects
- (sbcl-package->ecl-package sbcl-sealable-metaobjects))
+(define-public ecl-trivial-channels
+ (sbcl-package->ecl-package sbcl-trivial-channels))
-(define-public sbcl-fast-generic-functions
- (let ((commit "9c307cd28af6453e45038ac3510de3123ff23743"))
+(define-public sbcl-trivial-clipboard
+ (let ((commit "aee67d6132a46237f61d508ae4bd9ff44032566d")
+ (revision "7"))
(package
- (name "sbcl-fast-generic-functions")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-trivial-clipboard")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/fast-generic-functions/";)
+ (url "https://github.com/snmsts/trivial-clipboard";)
(commit commit)))
- (file-name (git-file-name "cl-fast-generic-functions" version))
+ (file-name (git-file-name "cl-trivial-clipboard" version))
(sha256
- (base32 "16hf9bi2p5s77p3m3aqsihcd9iicqjhhxxpsarjv93c41qs54yad"))))
+ (base32 "029qmx523xfk54p99ndgbmdd20s5i32mzpf77xymngrn4c33v9jk"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-closer-mop
- sbcl-sealable-metaobjects
- sbcl-trivial-macroexpand-all))
+ ;; Pick xsel instead of xclip because its closure size is slightly
+ ;; smaller.
+ (list wl-clipboard xsel))
+ (native-inputs
+ (list sbcl-fiveam))
(arguments
- ;; Tests fail:
https://github.com/marcoheisig/fast-generic-functions/issues/10
- '(#:tests? #f))
- (home-page "https://github.com/marcoheisig/fast-generic-functions/";)
- (synopsis "Seal generic functions to boost performance")
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/text.lisp"
+ (("\"xsel\"")
+ (string-append "\"" (assoc-ref inputs "xsel") "/bin/xsel\""))
+ (("\"wl-copy\"")
+ (string-append "\""
+ (assoc-ref inputs "wl-clipboard")
+ "/bin/wl-copy\""))
+ (("\"wl-paste\"")
+ (string-append "\""
+ (assoc-ref inputs "wl-clipboard")
+ "/bin/wl-paste\""))))))))
+ (home-page "https://github.com/snmsts/trivial-clipboard";)
+ (synopsis "Access system clipboard in Common Lisp")
(description
- "This library introduces @emph{fast generic functions}, i.e. functions
-that behave just like regular generic functions, except that the can be sealed
-on certain domains. If the compiler can then statically detect that the
-arguments to a fast generic function fall within such a domain, it will
-perform a variety of optimizations.")
+ "@command{trivial-clipboard} gives access to the system clipboard.")
(license license:expat))))
-(define-public cl-fast-generic-functions
- (sbcl-package->cl-source-package sbcl-fast-generic-functions))
-
-(define-public ecl-fast-generic-functions
- (sbcl-package->ecl-package sbcl-fast-generic-functions))
-
-(define-public sbcl-compiler-macro-notes
- (package
- (name "sbcl-compiler-macro-notes")
- (version "0.2.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/digikar99/compiler-macro-notes";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-compiler-macro-notes" version))
- (sha256
- (base32 "1jv8snj2wvim3k9qhl1vsx82n56nzdmwa3ms9c4ml2d58fwpfjzs"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cl-environments))
- (home-page "https://github.com/digikar99/compiler-macro-notes";)
- (synopsis "Macros and conditions for use within macros and
compiler-macros")
- (description
- "Alternative to the @code{compiler-macro} library:
-
-@itemize
-@item Here, we do not treat compiler notes as warnings, but instead these are
-a separate class of conditions. These are also not errors.
-@item Two main condition classes are provided: compiler-macro-notes:note and
-compiler-macro-notes:optimization-failure-note. While the latter is a subclass
-of the former, the latter notes are printed in a slightly different manner to
-the former.
-@item To be able to correctly print the expansion path that led to the
-condition, user code is expected to avoid performing a nonlocal exit to a
-place outside with-notes.
-@end itemize\n")
- (license license:expat)))
-
-(define-public cl-compiler-macro-notes
- (sbcl-package->cl-source-package sbcl-compiler-macro-notes))
+(define-public cl-trivial-clipboard
+ (sbcl-package->cl-source-package sbcl-trivial-clipboard))
-(define-public ecl-compiler-macro-notes
- (sbcl-package->ecl-package sbcl-compiler-macro-notes))
+(define-public ecl-trivial-clipboard
+ (sbcl-package->ecl-package sbcl-trivial-clipboard))
-(define-public sbcl-ctype
- (let ((commit "4fc4c5ae44c435ed82556969f698005bee50101c"))
+(define-public sbcl-trivial-cltl2
+ (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
+ (revision "2"))
(package
- (name "sbcl-ctype")
- (version (git-version "0.0.0" "1" commit))
+ (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 "https://github.com/s-expressionists/ctype";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-ctype" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "05smc81ml9rbcbzdhqg2mi9drnjsipq62r5q7f7qql8hbx01vl9i"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (arguments
- '(#:asd-systems '("ctype" "ctype-tfun")))
- (home-page "https://github.com/s-expressionists/ctype";)
- (synopsis "Common Lisp type system implementation")
- (description
- "This system is an implementation of the Common Lisp type system;
-particularly @code{cl:typep} and @code{cl:subtypep}.")
- (license license:bsd-2))))
-
-(define-public cl-ctype
- (sbcl-package->cl-source-package sbcl-ctype))
-
-(define-public ecl-ctype
- (sbcl-package->ecl-package sbcl-ctype))
-
-(define-public sbcl-polymorphic-functions
- (package
- (name "sbcl-polymorphic-functions")
- (version "0.2.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/digikar99/polymorphic-functions/";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-polymorphic-functions" version))
- (sha256
- (base32 "161ylp3avmkylgfddp7i1kscv3bqx734jk1i97xhsbl7x83nin0h"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-compiler-macro-notes
- sbcl-ctype
- sbcl-fiveam
- sbcl-cl-form-types
- sbcl-introspect-environment
- sbcl-slime-swank))
- (arguments
- ;; Tests fail: https://github.com/digikar99/polymorphic-functions/issues/8
- '(#:tests? #f))
- (home-page "https://github.com/digikar99/polymorphic-functions/";)
- (synopsis "Function type to dispatch on types instead of classes")
- (description
- "This library provides all of
-
-@itemize
-@item ad hoc polymorphism and
-@item subtype polymorphism
-@item parametric polymorphism (in a very limited sense)
-@end itemize
-
-to dispatch on the basis of types rather than classes.")
- (license license:expat)))
+ (base32
+ "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
+ (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 cl-polymorphic-functions
- (sbcl-package->cl-source-package sbcl-polymorphic-functions))
+(define-public cl-trivial-cltl2
+ (sbcl-package->cl-source-package sbcl-trivial-cltl2))
-(define-public ecl-polymorphic-functions
- (sbcl-package->ecl-package sbcl-polymorphic-functions))
+(define-public ecl-trivial-cltl2
+ (sbcl-package->ecl-package sbcl-trivial-cltl2))
-(define-public sbcl-slot-extra-options
- (let ((commit "29517d980325cd63744f1acf4cfe5c8ccec2b318"))
+(define-public sbcl-trivial-custom-debugger
+ (let ((commit "a560594a673bbcd88136af82086107ee5ff9ca81"))
(package
- (name "sbcl-slot-extra-options")
- (version (git-version "1.1.1" "1" commit))
+ (name "sbcl-trivial-custom-debugger")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/some-mthfka/slot-extra-options/";)
+ (url "https://github.com/phoe/trivial-custom-debugger";)
(commit commit)))
- (file-name (git-file-name "cl-slot-extra-options" version))
+ (file-name (git-file-name "trivial-custom-debugger" version))
(sha256
- (base32 "1b2swhjjs0w1034cy045q8l3ndmci7rjawka39q23vncy6d90497"))))
+ (base32 "1iri5wsp9sc1f5q934cj87zd79r5dc8fda0gl7x1pz95v0wx28yk"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-serapeum
- sbcl-iterate))
- (native-inputs
- (list sbcl-parachute))
- (home-page "https://github.com/some-mthfka/slot-extra-options/";)
- (synopsis "Extra options for slots using MOP")
+ (arguments
+ '(;; FIXME: Tests disabled because of a circular dependency between
+ ;; trivial-custom-debugger and parachute.
+ #:tests? #f))
+ ;;(native-inputs
+ ;; (list sbcl-parachute))
+ (home-page "https://github.com/phoe/trivial-custom-debugger/";)
+ (synopsis "Allow arbitrary functions as the standard Lisp debugger")
(description
- "This library lets you build a metaclass which in turn lets you specify
-extra slot options in its classes. Options may be easily inspected and custom
-inheritance may be set up. The Meta-Object Protocol (MOP) is used for the
-implementation - through @code{closer-mop}. Some convenience function for
-processing slot options are also available.
-
-Possible use case: you want to automatically set up some definitions based on
-some slots, but you want to have control over it right in the class
-definition.")
- (license license:lgpl3+))))
+ "This is a portability library that allows one to fully override the
+standard debugger provided by their Common Lisp system for situations where
+binding @code{*debugger-hook*} is not enough -- most notably, for
+@code{break}.")
+ (license license:expat))))
-(define-public cl-slot-extra-options
- (sbcl-package->cl-source-package sbcl-slot-extra-options))
+(define-public cl-trivial-custom-debugger
+ (sbcl-package->cl-source-package sbcl-trivial-custom-debugger))
-(define-public ecl-slot-extra-options
- (sbcl-package->ecl-package sbcl-slot-extra-options))
+(define-public ecl-trivial-custom-debugger
+ (package
+ (inherit (sbcl-package->ecl-package sbcl-trivial-custom-debugger))
+ (arguments
+ ;; Tests fail on ECL:
https://github.com/phoe/trivial-custom-debugger/issues/3
+ '(#:tests? #f))))
-(define-public sbcl-slite
- (let ((commit "942a95330592d30be5ac02fb1b697fb14ccbf1af")
- (revision "0"))
+(define-public sbcl-trivial-do
+ (let ((commit "03a1729f1e71bad3ebcf6cf098a0cce52dfa1163"))
(package
- (name "sbcl-slite")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-trivial-do")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tdrhq/slite/";)
+ (url "https://github.com/yitzchak/trivial-do";)
(commit commit)))
- (file-name (git-file-name "slite" version))
+ (file-name (git-file-name name commit))
(sha256
- (base32 "0b4c4vs1zlhcvr9flv8bx76v9hrwc9qmazmp60407q7cghn0k8zk"))))
+ (base32 "1ffva79nkicc7wc8c2ic5nayis3b2rk5sxzj74yjkymkjgbpcrgd"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-str
- sbcl-fiveam
- sbcl-parachute
- sbcl-lisp-unit2))
- (home-page "https://github.com/tdrhq/slite";)
- (synopsis "Common Lisp system for Slite ")
+ (home-page "https://github.com/yitzchak/trivial-do";)
+ (synopsis "Additional dolist style macros for Common Lisp")
(description
- "This package provides the Common Lisp part of the emacs-slite test
runner.")
- (license license:asl2.0))))
-
-(define-public cl-slite
- (sbcl-package->cl-source-package sbcl-slite))
-
-(define-public ecl-slite
- (sbcl-package->ecl-package sbcl-slite))
-
-(define-public emacs-slite
- (package
- (inherit sbcl-slite)
- (name "emacs-slite")
- (build-system emacs-build-system)
- (synopsis "SLIme-based TEst runner for FiveAM and Parachute Tests")
- (description
- "Slite interactively runs your Common Lisp tests (currently only FiveAM
-and Parachute are supported). It allows you to see the summary of test
-failures, jump to test definitions, rerun tests with debugger all from inside
-Emacs.
-
-In order to work, this also requires the slite Common Lisp system to be
-present. See the code@{*cl-slite packages}.")))
-
-(define-public sbcl-parseq
- (package
- (name "sbcl-parseq")
- (version "0.5.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mrossini-ethz/parseq";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-parseq" version))
- (sha256
- (base32 "0b4lnhwqdlaqccanyssdj2v0am2ygw6qr4543b49kz2rwirykw0w"))))
- (build-system asdf-build-system/sbcl)
- (home-page "https://github.com/mrossini-ethz/parseq";)
- (synopsis "Parsing expression grammars for sequences")
- (description
- "Parseq (pronounced parsec) is a parsing library for common lisp. It can
-be used for parsing lisp's sequences types: strings, vectors (e.g. binary
-data) and lists. Furthermore, parseq is able to parse nested structures such
-as trees (e.g. lists of lists, lists of vectors, vectors of strings).
-
-Parseq uses parsing expression grammars (PEG) that can be defined through a
-simple interface. Extensions to the standard parsing expressions are
-available. Parsing expressions can be parameterised and made context
-aware. Additionally, the definition of each parsing expression allows the
-arbitrary transformation of the parsing tree.
-
-The library is inspired by Esrap and uses a very similar interface. No code
-is shared between the two projects, however. The features of Esrap are are
-mostly included in parseq and complemented with additional, orthogonal
-features. Any resemblance to esrap-liquid is merely coincidental.")
- (license license:gpl2)))
-
-(define-public cl-parseq
- (sbcl-package->cl-source-package sbcl-parseq))
-
-(define-public ecl-parseq
- (sbcl-package->ecl-package sbcl-parseq))
+ "Additional dolist style macros for Common Lisp, such as
+@code{doalist}, @code{dohash}, @code{dolist*}, @code{doplist}, @code{doseq}
+and @code{doseq*}.")
+ (license license:zlib))))
-(define-public sbcl-physical-quantities
- (package
- (name "sbcl-physical-quantities")
- (version "0.2.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/mrossini-ethz/physical-quantities";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-physical-quantities" version))
- (sha256
- (base32 "0mb2s94s6fhw5vfa89naalw7ld11sdsszlqpz0c65dvpfyfmmdmh"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-parseq))
- (home-page "https://github.com/mrossini-ethz/physical-quantities";)
- (synopsis "Numeric type with optional unit and/or uncertainty for physics")
- (description
- "This lisp library handles physical quantities which consist of
+(define-public cl-trivial-do
+ (sbcl-package->cl-source-package sbcl-trivial-do))
-@itemize
-@item value / magnitude
-@item uncertainty / error
-@item unit
-@end itemize
+(define-public ecl-trivial-do
+ (sbcl-package->ecl-package sbcl-trivial-do))
-where the type of the value can be any subtype of real. For the uncertainty,
-both absolute and relative values are possible. Combinations of lisp symbols
-or strings are used to describe units. User defined units including
-abbreviations and prefixes are supported. Error propagation and unit checking
-is performed for all defined operations.")
- (license license:gpl2)))
+(define-public sbcl-trivial-download
+ (let ((commit "d2472061d86b1cf3d32f388daacd4e32a13af699"))
+ (package
+ (name "sbcl-trivial-download")
+ (version (git-version "0.3" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/eudoxia0/trivial-download/";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "06f46zr3gp3wlm2kgxna24qd2gpr1v89x9fynh1x5vrw6c6hqjcv"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-drakma))
+ (home-page "https://github.com/eudoxia0/trivial-download/";)
+ (synopsis "Download files from Common Lisp")
+ (description
+ "@code{trivial-download} allows you to download files from the Internet
+from Common Lisp. It provides a progress bar.")
+ (license license:bsd-2))))
-(define-public cl-physical-quantities
- (sbcl-package->cl-source-package sbcl-physical-quantities))
+(define-public cl-trivial-download
+ (sbcl-package->cl-source-package sbcl-trivial-download))
-(define-public ecl-physical-quantities
- (sbcl-package->ecl-package sbcl-physical-quantities))
+(define-public ecl-trivial-download
+ (sbcl-package->ecl-package sbcl-trivial-download))
-(define-public sbcl-sb-cga
- (let ((commit "9a554ea1c01cac998ff7eaa5f767bc5bcdc4c094"))
+(define-public sbcl-trivial-escapes
+ (let ((commit "1eca78da2078495d09893be58c28b3aa7b8cc4d1"))
(package
- (name "sbcl-sb-cga")
- (version (git-version "1.0.1" "1" commit))
+ (name "sbcl-trivial-escapes")
+ (version (git-version "1.2.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/nikodemus/sb-cga/";)
+ (url "https://github.com/williamyaoh/trivial-escapes";)
(commit commit)))
- (file-name (git-file-name "cl-sb-cga" version))
+ (file-name (git-file-name name commit))
(sha256
- (base32 "1y54qlwfrhch9aghk7nsbdx7x2qsvgsws1g2k631l9dsgdakw4w8"))))
+ (base32 "0v6h8lk17iqv1qkxgqjyzn8gi6v0hvq2vmfbb01md3zjvjqxn6lr"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (home-page "https://github.com/nikodemus/sb-cga/";)
- (synopsis "Computer graphic algebra for Common Lisp")
+ (list sbcl-named-readtables))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/williamyaoh/trivial-escapes";)
+ (synopsis "C-style escape directives for Common Lisp")
(description
- "SB-CGA is a computer graphics algebra library for Common Lisp.
-
-Despite the prefix it is actually portable - but optimizations that make it
-fast (using SIMD instructions) are currently implemented for SBCL/x86-64
-only.")
- (license license:expat))))
+ "This Common Lisp library interprets escape characters the same way that
+most other programming language do.
+It provides four readtables. The default one lets you write strings like this:
+@code{#\"This string has\na newline in it!\"}.")
+ (license license:public-domain))))
-(define-public cl-sb-cga
- (sbcl-package->cl-source-package sbcl-sb-cga))
+(define-public cl-trivial-escapes
+ (sbcl-package->cl-source-package sbcl-trivial-escapes))
-(define-public ecl-sb-cga
- (sbcl-package->ecl-package sbcl-sb-cga))
+(define-public ecl-trivial-escapes
+ (sbcl-package->ecl-package sbcl-trivial-escapes))
-(define-public sbcl-mathkit
- (let ((commit "fd884f94b36ef5e9bc19459ad0b3cda6303d2a2a"))
+(define-public sbcl-trivial-extensible-sequences
+ (let ((commit "d40b2da23716601578b1f645727047f80baeb49a")
+ (revision "0"))
(package
- (name "sbcl-mathkit")
- (version (git-version "0.0" "1" commit))
+ (name "sbcl-trivial-extensible-sequences")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispgames/mathkit/";)
+ (url "https://github.com/Shinmera/trivial-extensible-sequences";)
(commit commit)))
- (file-name (git-file-name "cl-mathkit" version))
+ (file-name (git-file-name "cl-trivial-extensible-sequences" version))
(sha256
- (base32 "174y6ndmf52h8sml87qjfl48llmynvdizzk2h0mr85zbaysx73i3"))))
+ (base32 "0352psdd8j0phjycr6ldckwspyal4jcf0f2fizi6fwdp7nvadng7"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-sb-cga))
- (home-page "https://github.com/lispgames/mathkit/";)
- (synopsis "Pure math functions useful for games, 3D, and GL in general")
+ (home-page "https://shinmera.github.io/trivial-extensible-sequences/";)
+ (synopsis "Portability library for the extensible sequences protocol")
(description
- "This is a purely math-related utility kit, providing functions which
-can be useful for games, 3D, and GL in general.")
- (license license:expat))))
+ "This package provides a portability layer for the extensible sequences
+standard extension to Common Lisp. Extensible sequences allow you to create
+your own sequence types that integrate with the rest of the functions and
+operations that interact with sequences.")
+ (license license:zlib))))
-(define-public cl-mathkit
- (sbcl-package->cl-source-package sbcl-mathkit))
+(define-public cl-trivial-extensible-sequences
+ (sbcl-package->cl-source-package sbcl-trivial-extensible-sequences))
-(define-public ecl-mathkit
- (sbcl-package->ecl-package sbcl-mathkit))
+;; NOTE: (Sharlatan-20230312T215058+0000): ECL is not supported
+;; (define-public ecl-trivial-extensible-sequences
+;; (sbcl-package->ecl-package sbcl-trivial-extensible-sequences))
-(define-public sbcl-rucksack
- (let ((commit "89278f88513ef328d290aa8b2baa06d63b44a9b1")
+(define-public sbcl-trivial-features
+ (package
+ (name "sbcl-trivial-features")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/trivial-features/trivial-features";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "trivial-features" version))
+ (sha256
+ (base32 "0jsqah1znzqilxnw5vannb083ayk0d7phkackqzwwqkyg5hpn6pq"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(;; FIXME: Tests disabled because of a circular dependency between
+ ;; trivial-features and cffi.
+ #:tests? #f))
+ ;; (native-inputs
+ ;; `(("cffi" ,sbcl-cffi)))
+ (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.")
+ (license license:expat)))
+
+(define-public cl-trivial-features
+ (sbcl-package->cl-source-package sbcl-trivial-features))
+
+(define-public ecl-trivial-features
+ (sbcl-package->ecl-package sbcl-trivial-features))
+
+(define-public sbcl-trivial-file-size
+ (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
(revision "0"))
(package
- (name "sbcl-rucksack")
- (version (git-version "0.1.20" revision commit))
- (source
+ (name "sbcl-trivial-file-size")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/trivial-file-size";)
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/arieltan/rucksack";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-rucksack" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0acpsxaxpp90km7gdbn9sysilycp3yg1g040fg1vqakpj2yb8vad"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Flexible, light weight, persistence library")
- (description
- "@code{cl-rucksack} is a persistence library based on Arthur Lemmens'
-Rucksack with some enhancements.")
- (home-page "https://github.com/arieltan/rucksack/";)
- (license license:expat))))
+ (base32
+ "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "Size of a file in bytes in Common Lisp")
+ (description
+ "The canonical way to determine the size of a file in bytes, using
Common Lisp,
+is to open the file with an element type of (unsigned-byte 8) and then
+calculate the length of the stream. This is less than ideal. In most cases
+it is better to get the size of the file from its metadata, using a system
+call.
-(define-public cl-rucksack
- (sbcl-package->cl-source-package sbcl-rucksack))
+This library exports a single function, file-size-in-octets. It returns the
+size of a file in bytes, using system calls when possible.")
+ (license license:expat))))
-(define-public sbcl-sdl2kit
- (let ((commit "aae663224a10ece2b0c374aa5942a3f0bc1b3c2f"))
+(define-public cl-trivial-file-size
+ (sbcl-package->cl-source-package sbcl-trivial-file-size))
+
+(define-public ecl-trivial-file-size
+ (sbcl-package->ecl-package sbcl-trivial-file-size))
+
+(define-public sbcl-trivial-garbage
+ (let ((commit "3474f6414b73d4e3aa2d5c53080f4247a34f6380")
+ (revision "0"))
(package
- (name "sbcl-sdl2kit")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-trivial-garbage")
+ (version (git-version "0.21" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/lispgames/sdl2kit/";)
+ (url "https://github.com/trivial-garbage/trivial-garbage";)
(commit commit)))
- (file-name (git-file-name "cl-sdl2kit" version))
+ (file-name (git-file-name "cl-trivial-garbage" version))
(sha256
- (base32 "10ymmxqsvdn7ndda9k2qcixj75l7namgqdxc5y2w3v5r1313fy2d"))))
+ (base32 "0rfwxvwg0kpcaa0hsi035yrkfdfks4bq8d9azmrww2f0rmv9g6sd"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cl-opengl
- sbcl-defpackage-plus
- sbcl-sdl2))
- (home-page "https://github.com/lispgames/sdl2kit/";)
- (synopsis "Utility kit for CL-SDL2")
- (description
- "This is a utility kit for @code{cl-sdl2} that provides something
similar to
-GLUT. However, it's also geared at being useful for \"real\" applications or
-games.")
- (license license:expat))))
+ (native-inputs
+ (list sbcl-rt))
+ (home-page "https://common-lisp.net/project/trivial-garbage/";)
+ (synopsis "Portable GC-related APIs for Common Lisp")
+ (description "@command{trivial-garbage} provides a portable API to
+finalizers, weak hash-tables and weak pointers on all major implementations of
+the Common Lisp programming language.")
+ (license license:public-domain))))
-(define-public cl-sdl2kit
- (sbcl-package->cl-source-package sbcl-sdl2kit))
+(define-public cl-trivial-garbage
+ (sbcl-package->cl-source-package sbcl-trivial-garbage))
-(define-public ecl-sdl2kit
- (sbcl-package->ecl-package sbcl-sdl2kit))
+(define-public ecl-trivial-garbage
+ (sbcl-package->ecl-package sbcl-trivial-garbage))
-(define-public sbcl-glkit
- (let ((commit "0d8e7c5fed4231f2177afcf0f3ff66f196ed6a46"))
+(define-public sbcl-trivial-gray-streams
+ (let ((revision "1")
+ (commit "2b3823edbc78a450db4891fd2b566ca0316a7876"))
(package
- (name "sbcl-glkit")
- (version (git-version "0.0" "1" commit))
+ (name "sbcl-trivial-gray-streams")
+ (version (git-version "2.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/lispgames/glkit/";)
- (commit commit)))
- (file-name (git-file-name "cl-glkit" version))
+ (uri
+ (git-reference
+ (url "https://github.com/trivial-gray-streams/trivial-gray-streams";)
+ (commit commit)))
(sha256
- (base32 "1x3y5jcr1f0v9sgn3y5b7b8fhgd6vv37nz73016gdwh511idi8jn"))))
+ (base32 "1hipqwwd5ylskybd173rvlsk7ds4w4nq1cmh9952ivm6dgh7pwzn"))
+ (file-name (git-file-name "cl-trivial-gray-streams" version))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cl-opengl
- sbcl-defpackage-plus
- sbcl-mathkit
- sbcl-sb-cga
- sbcl-sdl2
- sbcl-static-vectors))
- (home-page "https://github.com/lispgames/glkit/";)
- (synopsis "OpenGL utilities for math, shaders, and more")
- (description
- "This is a utility kit for functionality related to OpenGL. It
provides the following:
-
-@itemize
-@item @code{kit.glm}: This re-exports @code{sb-cga} and @code{mathkit} for
-convenience.
-@item @code{kit.gl.shader}: This provides shader dictionary and compilation
-functionality similar to what was originally found in @code{sdl2kit}.
-@item @code{kit.gl.vao}: This provides an interface for Vertex Array Objects.
-@end itemize\n")
- (license license:expat))))
+ (synopsis "Compatibility layer for Gray streams implementations")
+ (description "Gray streams is an interface proposed for inclusion with
+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 "https://www.cliki.net/trivial-gray-streams";)
+ (license license:x11))))
-(define-public cl-glkit
- (sbcl-package->cl-source-package sbcl-glkit))
+(define-public cl-trivial-gray-streams
+ (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
-(define-public ecl-glkit
- (sbcl-package->ecl-package sbcl-glkit))
+(define-public ecl-trivial-gray-streams
+ (sbcl-package->ecl-package sbcl-trivial-gray-streams))
-(define-public sbcl-cl-fond
- (let ((commit "dac975cbc73f231b400d5b8d8539b16330239a4a")
+(define-public sbcl-trivial-indent
+ (let ((commit "f25275094b80df8aa158af46db980bbc3ce2f88b")
(revision "1"))
(package
- (name "sbcl-cl-fond")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-trivial-indent")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shirakumo/cl-fond";)
- (commit commit)))
- (file-name (git-file-name "cl-fond" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/trivial-indent";)
+ (commit commit)))
+ (file-name (git-file-name "cl-trivial-indent" version))
(sha256
- (base32 "03ygcw1azb44bhdsqcq99xi4ci0by76ap5jf5l2d1vfxq04v8grq"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cffi
- sbcl-cl-opengl
- sbcl-documentation-utils
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (home-page "https://shirakumo.github.io/cl-fond/";)
- (synopsis "Bindings to libfond, a simple text rendering engine for
OpenGL")
- (description "This is a Common Lisp bindings library to libfond, a
-simple OpenGL text rendering engine.")
+ (base32 "1zg8cyy1xqpcjrxxqz5zb5xixhwcszkv4p2vq305lb2rka6f3dyx"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis
+ "Simple Common Lisp library to allow indentation hints for SWANK")
+ (description
+ "This library allows you to define custom indentation hints for your
+macros if the one recognised by SLIME automatically produces unwanted
+results.")
+ (home-page "https://shinmera.github.io/trivial-indent/";)
(license license:zlib))))
-(define-public cl-fond
- (sbcl-package->cl-source-package sbcl-cl-fond))
-
-(define-public ecl-cl-fond
- (sbcl-package->ecl-package sbcl-cl-fond))
-
-(define-public sbcl-doplus
- (package
- (name "sbcl-doplus")
- (version "1.1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/alessiostalla/doplus";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-doplus" version))
- (sha256
- (base32 "1yvda9psw9m08d3bzdb8a2drvhrnr07a0rhza5ibk30v1dkwfw7c"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-parse-declarations sbcl-fset))
- (arguments
- '(#:asd-systems '("doplus" "doplus-fset")))
- (synopsis "Iteration macro for Common Lisp")
- (description "@code{doplus} is an iteration macro for Common Lisp.")
- (home-page "https://github.com/alessiostalla/doplus";)
- (license license:gpl3+)))
-
-(define-public cl-doplus
- (sbcl-package->cl-source-package sbcl-doplus))
+(define-public cl-trivial-indent
+ (sbcl-package->cl-source-package sbcl-trivial-indent))
-(define-public ecl-doplus
- (sbcl-package->ecl-package sbcl-doplus))
+(define-public ecl-trivial-indent
+ (sbcl-package->ecl-package sbcl-trivial-indent))
-(define-public sbcl-trees
- (let ((commit "7b06048af0248c4302088c758208276f9faf2beb"))
+(define-public sbcl-trivial-macroexpand-all
+ (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
+ (revision "0"))
(package
- (name "sbcl-trees")
- (version (git-version "0.11" "1" commit))
+ (name "sbcl-trivial-macroexpand-all")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/cbaggers/trivial-macroexpand-all";)
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/froydnj/trees/";)
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-trees" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1xvydf3qc17rd7ia8sffxcpclgm3l0iyhx8k72ddk59v3pg5is4k"))))
+ (base32
+ "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/froydnj/trees/";)
- (synopsis "Binary trees in normal and balanced flavors")
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "Portable macroexpand-all for Common Lisp")
(description
- "This package implements binary trees of various kinds, presenting a
-uniform interface to them all.")
- (license license:bsd-3))))
+ "This library provides a macroexpand-all function that calls the
+implementation specific equivalent.")
+ (license license:unlicense))))
-(define-public cl-trees
- (sbcl-package->cl-source-package sbcl-trees))
+(define-public cl-trivial-macroexpand-all
+ (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
-(define-public ecl-trees
- (sbcl-package->ecl-package sbcl-trees))
+(define-public ecl-trivial-macroexpand-all
+ (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
-(define-public sbcl-cl-geometry
- (let ((commit "24eddedc47b931cec27361752736ef0b54fc9984"))
+(define-public sbcl-trivial-main-thread
+ (let ((commit "25f114973bb69eb63e01d0bbfead31f8e682846a")
+ (revision "1"))
(package
- (name "sbcl-cl-geometry")
- (version (git-version "0.0.3" "1" commit))
+ (name "sbcl-trivial-main-thread")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vydd/cl-geometry";)
+ (url "https://github.com/Shinmera/trivial-main-thread";)
(commit commit)))
- (file-name (git-file-name "cl-cl-geometry" version))
+ (file-name (git-file-name "trivial-main-thread" version))
(sha256
- (base32 "188xrd8plvc34gz7q01zmkdrzxbpwzln103l5dl78pa4a6vzz34h"))))
+ (base32 "0bw1887i7396lqg75qvmgjfzz4xbiq9w5dp8wxdgrcsm0qwlraw7"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-iterate
- sbcl-trees))
- (home-page "https://github.com/lispgames/cl-geometry/";)
- (synopsis "Simple two dimensional computational geometry in Common Lisp")
+ (list sbcl-bordeaux-threads sbcl-simple-tasks sbcl-trivial-features))
+ (home-page "https://shinmera.github.io/trivial-main-thread/";)
+ (synopsis "Compatibility library to run things in the main thread")
(description
- "This is a system for two dimensional computational geometry for Common
Lisp.
-
-Note: the system assumes exact rational arithmetic, so no floating point
-coordinates are allowed. This is not checked when creating geometric
-objects.")
- ;; The .asd says BSD-style but the LICENSE.txt is expat.
- (license license:expat))))
+ "This package provides a Common Lisp system which wraps the
+BORDEAUX-THREADS system to be able to run things in the main thread of the
+implementation, for example drawing calls of GUI applications.")
+ (license license:zlib))))
-(define-public cl-cl-geometry
- (sbcl-package->cl-source-package sbcl-cl-geometry))
+(define-public cl-trivial-main-thread
+ (sbcl-package->cl-source-package sbcl-trivial-main-thread))
-(define-public ecl-cl-geometry
- (sbcl-package->ecl-package sbcl-cl-geometry))
+(define-public ecl-trivial-main-thread
+ (sbcl-package->ecl-package sbcl-trivial-main-thread))
-(define-public sbcl-amb
- (let ((commit "884bef69a1ea02f3b9deae0341e1a038ff31b896")
- (revision "0"))
+(define-public sbcl-trivial-mimes
+ (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9")
+ (revision "2"))
(package
- (name "sbcl-amb")
- (version (git-version "1.0.0" revision commit))
- (source
+ (name "sbcl-trivial-mimes")
+ (version (git-version "1.1.0" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/amb";)
+ (url "https://github.com/Shinmera/trivial-mimes";)
(commit commit)))
- (file-name (git-file-name "cl-amb" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1klh1aakklj1famrff0sccnwlv8238b1q446288aqnqgxxw6pf21"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria))
- (native-inputs
- (list sbcl-parachute))
- (synopsis "Implementation of John McCarthy's ambiguous operator")
- (description
- "@code{cl-amb} provides an implementation of John McCarthy's ambiguous
-operator in portable Common Lisp.")
- (home-page "https://github.com/phoe/amb/";)
- (license license:expat))))
+ (base32 "00kcm17q5plpzdj1qwg83ldhxksilgpcdkf3m9azxcdr968xs9di"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-hu.dwim.stefil))
+ (inputs
+ (list sbcl-cl-fad))
+ (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
+mime-type of a file.")
+ (license license:zlib))))
-(define-public cl-amb
- (sbcl-package->cl-source-package sbcl-amb))
+(define-public cl-trivial-mimes
+ (sbcl-package->cl-source-package sbcl-trivial-mimes))
-(define-public ecl-amb
- (sbcl-package->ecl-package sbcl-amb))
+(define-public ecl-trivial-mimes
+ (sbcl-package->ecl-package sbcl-trivial-mimes))
-(define-public sbcl-quicklisp-stats
- (let ((commit "953b45c2212ae513d48a611d3dd09c846a6102cd")
+(define-public sbcl-trivial-monitored-thread
+ (let ((commit "b0bab23f9a9bd06f0f33809635c7ba4e6a3d5a21")
(revision "0"))
(package
- (name "sbcl-quicklisp-stats")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-trivial-monitored-thread")
+ (version (git-version "0.3.11" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/quicklisp-stats";)
+ (url "https://gitlab.com/ediethelm/trivial-monitored-thread";)
(commit commit)))
- (file-name (git-file-name "cl-quicklisp-stats" version))
+ (file-name (git-file-name "trivial-monitored-thread" version))
(sha256
- (base32 "0v8dgmlgd283n1g486q4sj2mghgdvgywg2nqp43nnrfc04mkvgc0"))))
+ (base32 "1ipnp2l944hc587bifxsnmiymw468imar0v8bqvgxv8pc5sym4ib"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-alexandria
- sbcl-drakma
- sbcl-split-sequence))
- (arguments
- `(#:tests? #f)) ; There are no tests.
- (synopsis "Fetches and operates on Quicklisp download statistics")
+ (list sbcl-iterate sbcl-log4cl sbcl-trivial-utilities))
+ (home-page "https://gitlab.com/ediethelm/trivial-monitored-thread";)
+ (synopsis "Thread monitoring library for Common Lisp")
(description
- "@code{cl-quicklisp-stats} is a system that fetches and performs basic
-operations on the Quicklisp download statistics.")
- (home-page "https://github.com/phoe/quicklisp-stats/";)
+ "Trivial Monitored Thread offers a very simple (aka trivial) way of
+spawning threads and being informed when one any of them crash and die.")
(license license:expat))))
-(define-public cl-quicklisp-stats
- (sbcl-package->cl-source-package sbcl-quicklisp-stats))
+(define-public cl-trivial-monitored-thread
+ (sbcl-package->cl-source-package sbcl-trivial-monitored-thread))
-(define-public ecl-quicklisp-stats
- (sbcl-package->ecl-package sbcl-quicklisp-stats))
+(define-public ecl-trivial-monitored-thread
+ (sbcl-package->ecl-package sbcl-trivial-monitored-thread))
-(define-public sbcl-sketch
- ;; No release in years.
- (let ((commit "4cc00b08e202c7adda41391463096cf9df1705c3"))
+(define-public sbcl-trivial-octet-streams
+ (let ((commit "bc5d398b18549fd42e9c2a365df28ad865f1b85d")
+ (revision "0"))
(package
- (name "sbcl-sketch")
- (version (git-version "2017-11" "1" commit))
+ (name "sbcl-trivial-octet-streams")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vydd/sketch";)
+ (url "https://github.com/sharplispers/trivial-octet-streams";)
(commit commit)))
- (file-name (git-file-name "cl-sketch" version))
+ (file-name (git-file-name "cl-trivial-octet-streams" version))
(sha256
- (base32 "1qrnma8yvmxps9rz3pvlzsir37namppsldijdlr4110pcwi9j9h6"))))
+ (base32 "0ysnsarlzynb7jf4b63b6kkxjancxc66jwmn0sb3vxyh87siiv6n"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cl-geometry
- sbcl-glkit
- sbcl-mathkit
- sbcl-md5
- sbcl-sdl2
- sbcl-sdl2-image
- sbcl-sdl2-ttf
- sbcl-sdl2kit
- sbcl-split-sequence
- sbcl-static-vectors))
- (arguments
- '(#:asd-systems '("sketch" "sketch-examples")))
- (home-page "https://github.com/vydd/sketch";)
- (synopsis "Creative framework for electronic art, visual design and
more")
+ (home-page "https://github.com/sharplispers/trivial-octet-streams";)
+ (synopsis "In-memory octet streams for Common Lisp")
(description
- "Sketch is a Common Lisp environment for the creation of electronic
-art, visual design, game prototyping, game making, computer graphics,
-exploration of human-computer interaction and more. It is inspired by
-the Processing language and shares some of the API.")
- (license license:expat))))
-
-(define-public cl-sketch
- (sbcl-package->cl-source-package sbcl-sketch))
+ "TRIVIAL-OCTET-STREAMS is a Common Lisp library implementing in-memory
+octet streams analogous to string streams.")
+ (license license:bsd-3))))
-(define-public ecl-sketch
- (sbcl-package->ecl-package sbcl-sketch))
+(define-public cl-trivial-octet-streams
+ (sbcl-package->cl-source-package sbcl-trivial-octet-streams))
-(define-public sbcl-cl-cron
- (let ((commit "092aef5d5666fb43c04258e4043f609670a20456")
- (revision "0"))
+(define-public ecl-trivial-octet-streams
+ (sbcl-package->ecl-package sbcl-trivial-octet-streams))
+
+(define-public sbcl-trivial-open-browser
+ (let ((commit "7ab4743dea9d592639f15c565bfa0756e828c427")
+ (revision "1"))
(package
- (name "sbcl-cl-cron")
+ (name "sbcl-trivial-open-browser")
(version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ciel-lang/cl-cron";)
+ (url "https://github.com/eudoxia0/trivial-open-browser";)
(commit commit)))
- (file-name (git-file-name "cl-cron" version))
+ (file-name (git-file-name "cl-trivial-open-browser" version))
(sha256
- (base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d"))))
+ (base32 "0ixay1piq420i6adx642qhw45l6ik7rvgk52lyz27dvx5f8yqsdb"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bordeaux-threads))
- (home-page "https://github.com/ciel-lang/cl-cron/";)
- (synopsis "Run cron like jobs in Common Lisp")
+ (inputs (list xdg-utils))
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/trivial-open-browser.lisp"
+ (("xdg-open")
+ (search-input-file inputs "/bin/xdg-open"))))))))
+ (home-page "https://github.com/eudoxia0/trivial-open-browser";)
+ (synopsis "Open a browser window from Common Lisp")
(description
- "@code{cl-cron} is a simple tool that provides cron like facilities
-directly inside of Common Lisp.")
- (license license:gpl3+))))
+ "This package provides a library to open a web browser to a URL.")
+ (license license:expat))))
-(define-public cl-cron
- (sbcl-package->cl-source-package sbcl-cl-cron))
+(define-public cl-trivial-open-browser
+ (sbcl-package->cl-source-package sbcl-trivial-open-browser))
-(define-public ecl-cl-cron
- (sbcl-package->ecl-package sbcl-cl-cron))
+(define-public ecl-trivial-open-browser
+ (sbcl-package->ecl-package sbcl-trivial-open-browser))
-(define-public sbcl-string-pokemonize
- (let ((commit "2dc01643defb497e4d1eb833def71dfc1e8d5da6")
- (revision "0"))
- (package
- (name "sbcl-string-pokemonize")
- (version (git-version "20210503" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/phoe/string-pokemonize";)
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1zk5klc94pxv7mhx6qrp93rk4ypwd6wfijap7gf9l0wpphg90r9x"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f ; There are no tests.
- #:asd-systems '("string-pokemonize")))
- (synopsis "Alternate upper- and lowercase")
- (description
- "@code{string-pokemonize} provides a function that alternates uppercase
-and lowercase characters for a given string.")
- (home-page "https://github.com/phoe/string-pokemonize";)
- (license license:expat))))
+(define-public sbcl-trivial-package-local-nicknames
+ (package
+ (name "sbcl-trivial-package-local-nicknames")
+ (version "0.2")
+ (home-page "https://github.com/phoe/trivial-package-local-nicknames";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url home-page)
+ (commit "16b7ad4c2b120f50da65154191f468ea5598460e")))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg"))))
+ (build-system asdf-build-system/sbcl)
+ (synopsis "Common Lisp compatibility library for package local nicknames")
+ (description
+ "This library is a portable compatibility layer around package local
nicknames (PLN).
+This was done so there is a portability library for the PLN API not included
+in DEFPACKAGE.")
+ (license license:unlicense)))
-(define-public cl-string-pokemonize
- (sbcl-package->cl-source-package sbcl-string-pokemonize))
+(define-public cl-trivial-package-local-nicknames
+ (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
-(define-public ecl-string-pokemonize
- (sbcl-package->ecl-package sbcl-string-pokemonize))
+(define-public ecl-trivial-package-local-nicknames
+ (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames))
-(define-public sbcl-binary-types
- (let ((commit "9ec42042a50403961c08179a892ae3de725b1d7a"))
+(define-public sbcl-trivial-raw-io
+ (let ((commit "b1a3c876305baa0dead419841de7b3e433a75867")
+ (revision "1"))
(package
- (name "sbcl-binary-types")
- (version (git-version "1.2" "1" commit))
+ (name "sbcl-trivial-raw-io")
+ (version (git-version "0.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/frodef/binary-types/";)
+ (url "https://github.com/kingcons/trivial-raw-io";)
(commit commit)))
- (file-name (git-file-name "binary-types" version))
+ (file-name (git-file-name "trivial-raw-io" version))
(sha256
- (base32 "0kp4xwblfxh7gmgqc38k9xzrqlcr0q1jm5167ma1pajdxd3182j8"))))
+ (base32 "19290zw2b64k78wr62gv30pp7cmqg07q85vfwjknaffjdd73xwi1"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/frodef/binary-types/";)
- (synopsis "Read and write binary records for Common Lisp")
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://github.com/kingcons/trivial-raw-io";)
+ (synopsis "Trivial portability for raw *nix IO in Common Lisp")
(description
- "Binary-types is a Common Lisp package for reading and writing binary
-files. Binary-types provides macros that are used to declare the mapping
-between Lisp objects and some binary (i.e. octet-based) representation.")
- (license license:bsd-3))))
+ "This library exports three symbols: @code{with-raw-io},
+@code{read-char}, and @code{read-line}, to provide raw POSIX I/O in Common
+Lisp.")
+ (license license:bsd-2))))
-(define-public cl-binary-types
- (sbcl-package->cl-source-package sbcl-binary-types))
+(define-public cl-trivial-raw-io
+ (sbcl-package->cl-source-package sbcl-trivial-raw-io))
-(define-public ecl-binary-types
- (sbcl-package->ecl-package sbcl-binary-types))
+(define-public ecl-trivial-raw-io
+ (sbcl-package->ecl-package sbcl-trivial-raw-io))
-(define-public sbcl-trivial-custom-debugger
- (let ((commit "a560594a673bbcd88136af82086107ee5ff9ca81"))
+(define-public sbcl-trivial-rfc-1123
+ (let ((commit "9ef59c3fdec08b0e3c9ed02d39533887b6d1b8e3")
+ (revision "0"))
(package
- (name "sbcl-trivial-custom-debugger")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-trivial-rfc-1123")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/trivial-custom-debugger";)
+ (url "https://github.com/stacksmith/trivial-rfc-1123";)
(commit commit)))
- (file-name (git-file-name "trivial-custom-debugger" version))
+ (file-name (git-file-name "cl-trivial-rfc-1123" version))
(sha256
- (base32 "1iri5wsp9sc1f5q934cj87zd79r5dc8fda0gl7x1pz95v0wx28yk"))))
+ (base32 "1w4ywpj10fnp7cya62dzlxlg8nyk4lppn2pnmfixsndwr4ib1h6x"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(;; FIXME: Tests disabled because of a circular dependency between
- ;; trivial-custom-debugger and parachute.
- #:tests? #f))
- ;;(native-inputs
- ;; (list sbcl-parachute))
- (home-page "https://github.com/phoe/trivial-custom-debugger/";)
- (synopsis "Allow arbitrary functions as the standard Lisp debugger")
+ (arguments `(#:asd-systems '("trivial-rfc-1123")))
+ (inputs (list sbcl-cl-ppcre))
+ (home-page "https://github.com/stacksmith/trivial-rfc-1123";)
+ (synopsis "Parse and print RFC-1123 timestamps")
(description
- "This is a portability library that allows one to fully override the
-standard debugger provided by their Common Lisp system for situations where
-binding @code{*debugger-hook*} is not enough -- most notably, for
-@code{break}.")
- (license license:expat))))
+ "This package parses and prints dates in RFC-1123 format.")
+ (license license:bsd-3))))
-(define-public cl-trivial-custom-debugger
- (sbcl-package->cl-source-package sbcl-trivial-custom-debugger))
+(define-public cl-trivial-rfc-1123
+ (sbcl-package->cl-source-package sbcl-trivial-rfc-1123))
-(define-public ecl-trivial-custom-debugger
- (package
- (inherit (sbcl-package->ecl-package sbcl-trivial-custom-debugger))
- (arguments
- ;; Tests fail on ECL:
https://github.com/phoe/trivial-custom-debugger/issues/3
- '(#:tests? #f))))
+(define-public ecl-trivial-rfc-1123
+ (sbcl-package->ecl-package sbcl-trivial-rfc-1123))
-(define-public sbcl-safe-read
- (let ((commit "d25f08597b34d7aaeb86b045d57f7b020a5bb5f0")
- (revision "0"))
+(define-public sbcl-trivial-shell
+ (let ((commit "e02ec191b34b52deca5d1c4ee99d4fa13b8772e0"))
(package
- (name "sbcl-safe-read")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-trivial-shell")
+ (version (git-version "0.2.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/safe-read";)
+ (url "https://github.com/hraban/trivial-shell";)
(commit commit)))
- (file-name (git-file-name "cl-safe-read" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1r9k8danfnqgpbn2vb90n6wdc6jd92h1ig565yplrbh6232lhi26"))))
+ (base32 "08mpkl5ij5sjfsyn8pq2kvsvpvyvr7ha1r8g1224fa667b8k2q85"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-local-time sbcl-trivial-garbage))
- (home-page "https://github.com/phoe/safe-read/";)
- (synopsis "Safer variant of READ")
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda _
+ (substitute* "dev/definitions.lisp"
+ (("/bin/sh")
+ (which "sh"))))))))
+ (native-inputs
+ (list sbcl-lift))
+ (home-page "https://common-lisp.net/project/trivial-shell/";)
+ (synopsis "Common Lisp access to the shell")
(description
- "This package provides a safer variant of @code{READ} secure against
-internbombing, excessive input and macro characters.")
- (license license:bsd-2))))
+ "A simple Common-Lisp interface to the underlying operating system.
+It's independent of the implementation and operating system.")
+ (license license:expat))))
-(define-public cl-safe-read
- (sbcl-package->cl-source-package sbcl-safe-read))
+(define-public cl-trivial-shell
+ (sbcl-package->cl-source-package sbcl-trivial-shell))
-(define-public ecl-safe-read
- (sbcl-package->ecl-package sbcl-safe-read))
+(define-public ecl-trivial-shell
+ (sbcl-package->ecl-package sbcl-trivial-shell))
+
+(define-public sbcl-trivial-sockets
+ (package
+ (name "sbcl-trivial-sockets")
+ (version "0.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/usocket/trivial-sockets/";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-trivial-sockets" version))
+ (sha256
+ (base32 "0xj9x5z3psxqap9c29qz1xswx5fiqxyzd35kmbw2g6z08cgb7nd0"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/usocket/trivial-sockets";)
+ (synopsis "Simple socket library for Common Lisp")
+ (description
+ "This library is a portable socket interface that allows CL programs to
+open connected (client) stream sockets to network services.")
+ (license license:expat)))
+
+(define-public cl-trivial-sockets
+ (sbcl-package->cl-source-package sbcl-trivial-sockets))
-(define-public sbcl-portable-condition-system
- (let ((commit "1307ec146d227a9d8ea42312c1ba2a5206a9eb3c")
- (revision "0"))
+(define-public sbcl-trivial-timeout
+ (let ((commit "e70d9b4f7caeab83ea6ac50d724470fe49561e66")
+ (revision "2"))
(package
- (name "sbcl-portable-condition-system")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-trivial-timeout")
+ (version (git-version "0.1.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/portable-condition-system";)
+ (url "https://github.com/hraban/trivial-timeout";)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "trivial-timeout" version))
(sha256
- (base32 "099lb9f4bavj95wik99wla5rf6fk1gdw9pvn0cqlaf0wf20csd3h"))))
+ (base32 "0s8z9aj6b3kv21yiyk13cjylzf5zlnw9v86vcff477m1gk9yddjs"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("portable-condition-system")))
(native-inputs
- (list sbcl-1am))
- (inputs
- (list sbcl-alexandria
- sbcl-split-sequence))
- (home-page "https://github.com/phoe/portable-condition-system";)
- (synopsis "Portable condition system for Common Lisp")
+ (list sbcl-lift))
+ (home-page "https://github.com/hraban/trivial-timeout";)
+ (synopsis "Timeout library for Common Lisp")
(description
- "This package provides an example implementation of the Common Lisp
-condition system and library, based on the original condition system
-implementation by Kent M. Pitman.")
- (license license:cc0))))
+ "This library provides an OS and implementation independent access to
+timeouts.")
+ (license license:expat))))
-(define-public cl-portable-condition-system
- (sbcl-package->cl-source-package sbcl-portable-condition-system))
+(define-public cl-trivial-timeout
+ (sbcl-package->cl-source-package sbcl-trivial-timeout))
-(define-public ecl-portable-condition-system
- (sbcl-package->ecl-package sbcl-portable-condition-system))
+(define-public ecl-trivial-timeout
+ (sbcl-package->ecl-package sbcl-trivial-timeout))
-(define-public sbcl-ospm
+(define-public sbcl-trivial-types
(package
- (name "sbcl-ospm")
- (version "0.0.2")
+ (name "sbcl-trivial-types")
+ (version "0.0.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/atlas-engineer/ospm";)
- (commit version)))
- (file-name (git-file-name "cl-ospm" version))
+ (url "https://github.com/m2ym/trivial-types";)
+ (commit "ee869f2b7504d8aa9a74403641a5b42b16f47d88")))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1z2wz2xg7rn7p1lladdhj789iz2f3wfjgpi2hjr08vkf1pkp15xf"))))
+ (base32 "1s4cp9bdlbn8447q7w7f1wkgwrbvfzp20mgs307l5pxvdslin341"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-calispel
- sbcl-hu.dwim.defclass-star
- sbcl-local-time
- sbcl-moptilities
- sbcl-named-readtables
- sbcl-serapeum
- sbcl-trivia))
- (native-inputs
- ;; FIXME: Tests have execution errors because of Guix being run in a
container.
- (list sbcl-lisp-unit2 guix))
- (home-page "https://github.com/atlas-engineer/ospm";)
- (synopsis "System package manager in Common Lisp")
+ (home-page "https://github.com/m2ym/trivial-types";)
+ (synopsis "Trivial type definitions for Common Lisp")
(description
- "This library is a universal interface to the operating system package
manager.
-It has extensive support for Guix, among others:
+ "TRIVIAL-TYPES provides missing but important type definitions such as
+PROPER-LIST, ASSOCIATION-LIST, PROPERTY-LIST and TUPLE.")
+ (license license:llgpl)))
-@itemize
-@item package listing and searching;
-@item package installation and uninstallation;
-@item package file listing;
-@item profile listing;
-@item manifest listing and installation;
-@item generation listing, switching and deletion.
-@end itemize\n")
- (license license:bsd-3)))
+(define-public cl-trivial-types
+ (sbcl-package->cl-source-package sbcl-trivial-types))
-(define-public cl-ospm
- (let ((pkg (sbcl-package->cl-source-package sbcl-ospm)))
+(define-public ecl-trivial-types
+ (sbcl-package->ecl-package sbcl-trivial-types))
+
+(define-public sbcl-trivial-utf-8
+ (let ((commit "6ca9943588cbc61ad22a3c1ff81beb371e122394")
+ (revision "2"))
(package
- (inherit pkg)
- (inputs
- (cons (list "osicat" cl-osicat)
- (package-inputs pkg))))))
+ (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 "cl-trivial-utf-8" version))
+ (sha256
+ (base32 "0gzgbyzbbhny5y1lq2x82vfy4b4p1snq1sy9lj82hdq7lkyj03ss"))))
+ (arguments
+ ;; Guix incorrectly assumes the "8" is part of the version
+ ;; number and lobs it off.
+ `(#:asd-systems '("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 sbcl-data-lens
- (let ((commit "801bc1e0331f19fdc38be314c86ccac9362fde78")
+(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-trivial-utilities
+ (let ((commit "279ff255562628196942632c543d91c357067221")
(revision "0"))
(package
- (name "sbcl-data-lens")
- (version (git-version "0.0.0" revision commit))
- (source
+ (name "sbcl-trivial-utilities")
+ (version (git-version "0.4.0" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fiddlerwoaroof/data-lens";)
+ (url "https://gitlab.com/ediethelm/trivial-utilities";)
(commit commit)))
- (file-name (git-file-name "cl-data-lens" version))
+ (file-name (git-file-name "trivial-utilities" version))
(sha256
- (base32 "1w4rvhcnss037q0bb1j70kdlhfh9085hy95d9q56sk519alhzhrp"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-cl-ppcre
- sbcl-alexandria
- sbcl-serapeum))
- (synopsis "Functional utilities for Common Lisp")
- (description
- "The @code{cl-data-lens} library provides a language for expressing data
-manipulations as the composition of more primitive operations.")
- (home-page "https://fiddlerwoaroof.github.io/data-lens/";)
- (license license:asl2.0))))
-
-(define-public cl-data-lens
- (sbcl-package->cl-source-package sbcl-data-lens))
-
-(define-public ecl-data-lens
- (sbcl-package->ecl-package sbcl-data-lens))
-
-(define-public sbcl-ndebug
- (package
- (name "sbcl-ndebug")
- (version "0.2.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/atlas-engineer/ndebug";)
- (commit version)))
- (file-name (git-file-name "cl-ndebug" version))
- (sha256
- (base32 "1sndg4qclkdr53xkxrfjskx8gcqx0bn4r0vslzfx1kgznl4hbf1d"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-dissect
- sbcl-trivial-custom-debugger
- sbcl-bordeaux-threads
- sbcl-trivial-gray-streams))
- (native-inputs
- (list sbcl-lisp-unit2))
- (home-page "https://github.com/atlas-engineer/ndebug/";)
- (synopsis "Toolkit to build UI-aware Common Lisp debugger hooks")
- (description
- "NDebug provides a small set of utilities to make graphical (or, rather
-non-REPL-resident) Common Lisp applications easier to integrate with the
-standard Lisp debugger (@code{*debugger-hook*}, namely) and
-implementation-specific debugger hooks (via @code{trivial-custom-debugger}),
-especially in a multi-threaded context.")
- (license license:bsd-3)))
-
-(define-public cl-ndebug
- (sbcl-package->cl-source-package sbcl-ndebug))
+ (base32 "0k1xmn5f5dik7scadw0vyy67mik4ypnfqbhlv2vsg9afxzbpx2dz"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria sbcl-iterate sbcl-closer-mop))
+ (home-page "https://gitlab.com/ediethelm/trivial-utilities";)
+ (synopsis "Collection of useful types, functions and macros for Common
Lisp")
+ (description
+ "This package provides a collection of types, functions and macros.
Some
+ of the functionality is implemented from Graham's On Lisp and Seibel's
Practical
+ Common Lisp.")
+ (license license:expat))))
-(define-public ecl-ndebug
- (sbcl-package->ecl-package sbcl-ndebug))
+(define-public cl-trivial-utilities
+ (sbcl-package->cl-source-package sbcl-trivial-utilities))
-(define-public sbcl-canonicalized-initargs
- (package
- (name "sbcl-canonicalized-initargs")
- (version "2.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/canonicalized-initargs";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-canonicalized-initargs" version))
- (sha256
- (base32 "0jmmjw86x9mmlfla4kdmdqf1fjrj0p2fmv1lc4k555mcf67mj2fq"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-cesdi
- sbcl-closer-mop
- sbcl-compatible-metaclasses
- sbcl-enhanced-defclass
- sbcl-enhanced-typep))
- (home-page
- "https://www.hexstreamsoft.com/libraries/canonicalized-initargs/";)
- (synopsis "Standard way to canonicalize slot values")
- (description
- "This package provides a standard way to canonicalize slot values.")
- (license license:unlicense)))
+(define-public ecl-trivial-utilities
+ (sbcl-package->ecl-package sbcl-trivial-utilities))
-(define-public cl-canonicalized-initargs
- (sbcl-package->cl-source-package sbcl-canonicalized-initargs))
+(define-public sbcl-trivial-with-current-source-form
+ (let ((commit "9e343e043a77a5478c1f77bb626db22335fbbfb8")
+ (revision "1"))
+ (package
+ (name "sbcl-trivial-with-current-source-form")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url
+ "https://github.com/scymtym/trivial-with-current-source-form";)
+ (commit commit)))
+ (file-name (git-file-name "trivial-with-current-source-form" version))
+ (sha256
+ (base32 "15zs7mc422ycp1cvcxmirif1dq15mlmv8vzd6l6nzn4qgmph9wz0"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria))
+ (home-page "https://github.com/scymtym/trivial-with-current-source-form";)
+ (synopsis "Help producing better errors for macro users")
+ (description
+ "This library allows macro writers to provide better feedback to macro
+users when errors are signaled during macroexpansion. It uses the compiler's
+concept of a source-form to report where the error or warning is located.")
+ (license license:lgpl3))))
-(define-public ecl-canonicalized-initargs
- (sbcl-package->ecl-package sbcl-canonicalized-initargs))
+(define-public cl-trivial-with-current-source-form
+ (sbcl-package->cl-source-package sbcl-trivial-with-current-source-form))
-(define-public sbcl-enhanced-typep
- (package
- (name "sbcl-enhanced-typep")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/enhanced-typep";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-enhanced-typep" version))
- (sha256
- (base32 "0b22gddkbxnhmi71wa2h51495737lrvsqxnri7g1qdsl1hraml21"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-enhanced-boolean sbcl-parachute))
- (home-page "https://www.hexstreamsoft.com/libraries/enhanced-typep/";)
- (synopsis "Enhanced version of typep")
- (description
- "This package provides an enhanced version of @code{typep} that is exactly
-like the one in the Lisp spec, except it can also accept a single type
argument,
-in which case it returns the appropriate closure.")
- (license license:unlicense)))
+(define-public ecl-trivial-with-current-source-form
+ ;; Trivial-with-current-source-form does not give any benefits on ECL.
+ ;; This package is so packages dependent on trivial-with-current-source-form
+ ;; can be loaded on ECL.
+ (sbcl-package->ecl-package sbcl-trivial-with-current-source-form))
-(define-public cl-enhanced-typep
- (sbcl-package->cl-source-package sbcl-enhanced-typep))
+(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";)
+ (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
+ (list sbcl-fiveam))
+ (arguments
+ `(#:asd-systems '("trivialib.type-unify"))))))
-(define-public ecl-enhanced-typep
- (sbcl-package->ecl-package sbcl-enhanced-typep))
+(define-public cl-trivialib-type-unify
+ (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
-(define-public sbcl-enhanced-defclass
- (package
- (name "sbcl-enhanced-defclass")
- (version "2.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/enhanced-defclass";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-enhanced-defclass" version))
- (sha256
- (base32 "142s5c3pl3x7xdawzsj8pdxiqp4wh6fcajf4la5msvnxgf66d8wg"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-cesdi
- sbcl-closer-mop
- sbcl-compatible-metaclasses
- sbcl-enhanced-eval-when
- sbcl-object-class
- sbcl-shared-preferences
- sbcl-simple-guess))
- (home-page "https://www.hexstreamsoft.com/libraries/enhanced-defclass/";)
- (synopsis "Extensible implementation of defclass")
- (description
- "This package provides an extensible implementation of defclass that can
-accurately control the expansion according to the metaclass and automatically
-detect the suitable metaclass by analyzing the @code{defclass} form.")
- (license license:unlicense)))
+(define-public ecl-trivialib-type-unify
+ (sbcl-package->ecl-package sbcl-trivialib-type-unify))
-(define-public cl-enhanced-defclass
- (sbcl-package->cl-source-package sbcl-enhanced-defclass))
+(define-public sbcl-trucler
+ (let ((commit "d40ff965520cbccf4980b7e7e3122912a11f24ad")
+ (revision "1"))
+ (package
+ (name "sbcl-trucler")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/s-expressionists/Trucler";)
+ (commit commit)))
+ (file-name (git-file-name "cl-trucler" commit))
+ (sha256
+ (base32 "0a0zi7q88j31n0b17yfxb66xjvvridgqr4vr6z3pgnm9wha990a6"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-acclimation))
+ (arguments
+ '(#:asd-systems '("trucler"
+ "trucler-base"
+ "trucler-native"
+ "trucler-reference")))
+ (home-page "https://github.com/s-expressionists/Trucler";)
+ (synopsis "Environment protocol for Common Lisp compilers")
+ (description
+ "Trucler defines a CLOS-based protocol to be used by Common Lisp
+compilers for environment query and update. In addition, library authors can
+use the @code{trucler-native} interface to inspect native environments.
+Trucler supports introspection for variables, functions, tags, blocks and
+optimization policies.")
+ (license license:bsd-2))))
-(define-public ecl-enhanced-defclass
- (sbcl-package->ecl-package sbcl-enhanced-defclass))
+(define-public cl-trucler
+ (sbcl-package->cl-source-package sbcl-trucler))
-(define-public sbcl-object-class
- (package
- (name "sbcl-object-class")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/object-class";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-object-class" version))
- (sha256
- (base32 "0qagmd2mxbr8b60l0y3jccj0maxjchds96p935pd3q805ry50683"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-closer-mop
- sbcl-compatible-metaclasses
- sbcl-enhanced-find-class))
- (home-page "https://www.hexstreamsoft.com/libraries/object-class/";)
- (synopsis "Cluster special subclasses of the standard-object")
- (description
- "This package ensures that special subclasses of standard-object cluster
-right in front of standard-object in the class precedence list.")
- (license license:unlicense)))
+(define-public ecl-trucler
+ (sbcl-package->ecl-package sbcl-trucler))
-(define-public cl-object-class
- (sbcl-package->cl-source-package sbcl-object-class))
+(define-public sbcl-type-i
+ (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
+ (revision "2"))
+ (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
+ "12wsga0pwjkkr176lnjwkmmlm3ccp0n310sjj9h20lk53iyd0z69"))))
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("introspect-environment" ,sbcl-introspect-environment)
+ ("trivia.trivial" ,sbcl-trivia.trivial)))
+ (native-inputs
+ (list sbcl-fiveam))
+ (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 ecl-object-class
- (sbcl-package->ecl-package sbcl-object-class))
+(define-public cl-type-i
+ (sbcl-package->cl-source-package sbcl-type-i))
-(define-public sbcl-shared-preferences
+(define-public ecl-type-i
(package
- (name "sbcl-shared-preferences")
- (version "1.1.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/shared-preferences";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-shared-preferences" version))
- (sha256
- (base32 "12m4kaba2lxndkjw30a6y2rq16fflh5016lp74l7pf3v0y3j1ydf"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-inheriting-readers
- sbcl-trivial-garbage))
- (home-page "https://www.hexstreamsoft.com/libraries/shared-preferences/";)
- (synopsis "Flexible specification of package-local preferences")
- (description
- "This package allows flexible specification of package-local
preferences.")
- (license license:unlicense)))
+ (inherit (sbcl-package->ecl-package sbcl-type-i))
+ (arguments
+ ;; The tests get stuck indefinitly
+ '(#:tests? #f))))
+
+(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";)
+ (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
+ (list sbcl-fiveam)))))
-(define-public cl-shared-preferences
- (sbcl-package->cl-source-package sbcl-shared-preferences))
+(define-public cl-type-r
+ (sbcl-package->cl-source-package sbcl-type-r))
-(define-public ecl-shared-preferences
- (sbcl-package->ecl-package sbcl-shared-preferences))
+(define-public ecl-type-r
+ (sbcl-package->ecl-package sbcl-type-r))
-(define-public sbcl-inheriting-readers
- (package
- (name "sbcl-inheriting-readers")
- (version "1.0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/inheriting-readers";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-inheriting-readers" version))
- (sha256
- (base32 "0km3mq6vx1q9qv6j3r4sqqcsdbnb5jar66bl0mzzpaacfvzbx68p"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-class-options
- sbcl-closer-mop
- sbcl-compatible-metaclasses))
- (home-page "https://www.hexstreamsoft.com/libraries/inheriting-readers/";)
- (synopsis "Simple yet powerful value inheritance scheme")
- (description
- "This package provides a simple yet powerful value inheritance scheme.")
- (license license:unlicense)))
+(define-public sbcl-type-templates
+ (let ((commit "5b389ebcff61b81585a64d0b899b69fa12aa5f96")
+ (revision "0"))
+ (package
+ (name "sbcl-type-templates")
+ (version (git-version "4.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/type-templates";)
+ (commit commit)))
+ (file-name (git-file-name "cl-type-templates" version))
+ (sha256
+ (base32 "1zmz3bmwg8ncqbnjwimn8n7q9ik9arnhd5ijd22ap1nwhbnmk1rj"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; No tests
+ (list #:tests? #f))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-documentation-utils
+ sbcl-form-fiddle))
+ (home-page "https://shinmera.github.io/type-templates/";)
+ (synopsis "Library for defining and expanding templated functions")
+ (description
+ "The Type-Templates library allows you to define types and “template
+functions” that can be expanded into various type-specialized versions to
+eliminate runtime dispatch overhead. It was specifically designed to
+implement low-level numerical data types and functionality.")
+ (license license:zlib))))
-(define-public cl-inheriting-readers
- (sbcl-package->cl-source-package sbcl-inheriting-readers))
+(define-public cl-type-templates
+ (sbcl-package->cl-source-package sbcl-type-templates))
-(define-public ecl-inheriting-readers
- (sbcl-package->ecl-package sbcl-inheriting-readers))
+(define-public ecl-type-templates
+ (sbcl-package->ecl-package sbcl-type-templates))
-(define-public sbcl-simple-guess
- (let ((commit "34744e3200a96e6aba285d70f91cdbd6c25508a6")
+(define-public sbcl-typo
+ (let ((commit "0e883490f81edf2a1be4e5b101d1caec78d7853b")
(revision "0"))
(package
- (name "sbcl-simple-guess")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-typo")
+ (version (git-version "0.0.0" revision commit))
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/simple-guess";)
- (commit commit)))
- (file-name (git-file-name "cl-simple-guess" version))
- (sha256
- (base32 "0404vj7ln97x7rn9ypbw4rshs56nnpyjnh1z9k03s039s5q3kpv0"))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/marcoheisig/Typo";)
+ (commit commit)))
+ (file-name (git-file-name "cl-typo" version))
+ (sha256
+ (base32 "08cmkjl3f77rfhxbjyd6f3kinhzak30mdfphnpf73sh1vw4v0vym"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fakenil sbcl-parachute))
(inputs
- (list sbcl-cesdi
+ (list sbcl-alexandria
sbcl-closer-mop
- sbcl-compatible-metaclasses
- sbcl-evaled-when))
- (home-page "https://www.hexstreamsoft.com/libraries/simple-guess/";)
- (synopsis "Extensible protocol for computing a guess using advisors")
+ sbcl-introspect-environment
+ sbcl-trivia
+ sbcl-trivial-arguments
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/marcoheisig/Typo";)
+ (synopsis "Portable type inference library for Common Lisp")
(description
- "This package defines a simple extensible protocol for computing a guess
-using advisors.")
- (license license:unlicense))))
+ "Typo is a portable library for Common Lisp that does approximate
+reasoning about types, but without consing.")
+ (license license:expat))))
-(define-public cl-simple-guess
- (sbcl-package->cl-source-package sbcl-simple-guess))
+(define-public cl-typo
+ (sbcl-package->cl-source-package sbcl-typo))
-(define-public ecl-simple-guess
- (sbcl-package->ecl-package sbcl-simple-guess))
+(define-public ecl-typo
+ (sbcl-package->ecl-package sbcl-typo))
-(define-public sbcl-wild-package-inferred-system
- (let ((commit "800b5f89b61cc4a0a9cf14706fd3f7e7fcd3e539")
- (revision "0"))
+(define-public sbcl-uax-14
+ (let ((commit "0432162525119c401d3d705bb9bcc9580a03914f")
+ (revision "1"))
(package
- (name "sbcl-wild-package-inferred-system")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-uax-14")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url
"https://github.com/privet-kitty/wild-package-inferred-system";)
+ (url "https://github.com/Shinmera/uax-14";)
(commit commit)))
- (file-name (git-file-name "cl-wild-package-inferred-system" version))
+ (file-name (git-file-name "uax-14" version))
(sha256
- (base32 "0sp3j3i83aqyq9bl3djs490nilryi9sh1wjbcqd9z94d9wfbfz80"))))
+ (base32 "1sb2s58k01yjaggaq8i7kbyfsh6mzyqbiz1vm59smxn9qqwd8apm"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (home-page
"https://github.com/privet-kitty/wild-package-inferred-system/";)
- (synopsis "Wildcard for ASDF package-inferred-system")
+ (native-inputs
+ (list sbcl-parachute sbcl-cl-ppcre))
+ (inputs
+ (list sbcl-documentation-utils))
+ (arguments
+ `(#:asd-systems '("uax-14")))
+ (home-page "https://shinmera.github.io/uax-14/";)
+ (synopsis "Unicode Standard Annex #14 for standardised line breaking")
(description
- "@code{wild-package-inferred-system} is an extension of ASDF
-package-inferred-system that interprets star * and globstar ** in package
-or system names.")
- (license license:expat))))
+ "This is an implementation of the Unicode Standards Annex
+#14 (@url{http://www.unicode.org/reports/tr14/}) line breaking algorithm. It
+provides a fast and convenient way to determine line breaking opportunities in
+text.
-(define-public cl-wild-package-inferred-system
- (sbcl-package->cl-source-package sbcl-wild-package-inferred-system))
+Note that this algorithm does not support break opportunities that require
+morphological analysis. In order to handle such cases, please consult a system
+that provides this kind of capability, such as a hyphenation algorithm.
-(define-public ecl-wild-package-inferred-system
- (sbcl-package->ecl-package sbcl-wild-package-inferred-system))
+Also note that this system is completely unaware of layouting decisions. Any
+kind of layouting decisions, such as which breaks to pick, how to space
+between words, how to handle bidirectionality, and what to do in emergency
+situations when there are no breaks on an overfull line are left up to the
+user.")
+ (license license:zlib))))
-(define-public sbcl-fakenil
+(define-public cl-uax-14
+ (sbcl-package->cl-source-package sbcl-uax-14))
+
+(define-public ecl-uax-14
+ (sbcl-package->ecl-package sbcl-uax-14))
+
+(define-public sbcl-uax-15
(package
- (name "sbcl-fakenil")
- (version "1.0")
+ (name "sbcl-uax-15")
+ (version "0.1.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Hexstream/fakenil";)
+ (url "https://github.com/sabracrolleton/uax-15";)
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-fakenil" version))
+ (file-name (git-file-name "uax-15" version))
(sha256
- (base32 "0ipqax3sgcs1dsgxz8d2pmfg324k6l35pn0nz89w5jl02fia61l3"))))
+ (base32 "0p2ckw7mzxhwa9vbwj2q2dzayz9dl94d9yqd2ynp0pc5v8i0n2fr"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:asd-systems
+ '("uax-15")))
(native-inputs
- (list sbcl-parachute))
- (home-page "https://www.hexstreamsoft.com/libraries/fakenil/";)
- (synopsis "Provides a canonical stand-in for NIL")
+ (list sbcl-fiveam))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("split-sequence" ,sbcl-split-sequence)))
+ (home-page "https://github.com/sabracrolleton/uax-15";)
+ (synopsis "Common Lisp implementation of unicode normalization functions")
(description
- "This package provides a canonical stand-in for NIL for contexts where
-NIL means no value.")
- (license license:unlicense)))
+ "This package provides supports for unicode normalization, RFC8264 and
+RFC7564.")
+ (license license:expat)))
+
+(define-public cl-uax-15
+ (sbcl-package->cl-source-package sbcl-uax-15))
+
+(define-public ecl-uax-15
+ (sbcl-package->ecl-package sbcl-uax-15))
+
+(define-public sbcl-ubiquitous
+ (let ((commit "35eb7bd9e1b3daee1705f6b41260775180cce8af")
+ (revision "1"))
+ (package
+ (name "sbcl-ubiquitous")
+ (version (git-version "2.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Shinmera/ubiquitous";)
+ (commit commit)))
+ (file-name (git-file-name "ubiquitous" version))
+ (sha256
+ (base32 "1xlkaqmjcpkiv2xl2s2pvvrv976dlc846wm16s1lj62iy1315i49"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
+ (arguments
+ '(#:asd-systems '("ubiquitous"
+ "ubiquitous-concurrent")))
+ (home-page "https://shinmera.github.io/ubiquitous/";)
+ (synopsis "Application configuration mechanism for Common Lisp")
+ (description
+ "@code{UBIQUITOUS} is a very easy-to-use library for persistent
+configuration storage. It automatically takes care of finding a suitable place
+to save your data, and provides simple functions to access and modify the data
+within.")
+ (license license:zlib))))
-(define-public cl-fakenil
- (sbcl-package->cl-source-package sbcl-fakenil))
+(define-public cl-ubiquitous
+ (sbcl-package->cl-source-package sbcl-ubiquitous))
-(define-public ecl-fakenil
- (sbcl-package->ecl-package sbcl-fakenil))
+(define-public ecl-ubiquitous
+ (sbcl-package->ecl-package sbcl-ubiquitous))
-(define-public sbcl-evaled-when
- (let ((commit "c59f8ab20b846cac81d4be80d056a3d65676e8eb")
+(define-public sbcl-ucons
+ (let ((commit "d976810ef2b12a2caaf55bd0f258272e9b79f3be")
(revision "0"))
(package
- (name "sbcl-evaled-when")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-ucons")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Hexstream/evaled-when";)
+ (url "https://github.com/marcoheisig/ucons";)
(commit commit)))
- (file-name (git-file-name "cl-evaled-when" version))
+ (file-name (git-file-name "cl-ucons" version))
(sha256
- (base32 "07g1a50aairvsj57issb18si5a9r3skpbk05nlixmlj0mva3gkl3"))))
+ (base32 "17aj47pdjiywnf33hl46p27za2q0pq5ar3fpqxaqskggxrfxmijl"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-enhanced-boolean sbcl-parachute))
(inputs
- (list sbcl-trivial-cltl2))
- (home-page "https://www.hexstreamsoft.com/libraries/evaled-when/";)
- (synopsis "Extract and replicate the compile-time side-effects of forms")
- (description
- "This package provides a way of extracting and replicating the
-compile-time side-effects of forms.")
- (license license:unlicense))))
+ (list sbcl-alexandria
+ sbcl-atomics
+ sbcl-bordeaux-threads
+ sbcl-named-readtables
+ sbcl-trivia))
+ (home-page "https://github.com/marcoheisig/ucons";)
+ (synopsis "Unique conses for Common Lisp")
+ (description "UCONS is a Common Lisp library providing unique conses.
+Unique conses are different from regular conses in that, in addition to their
+@code{car} and @code{cdr}, they maintain a table of past users. Also, the
+@code{cdr} of each ucons is restricted to other uconses or @code{nil}.
+Uconses are meant for those situations where even reusing regular conses (to
+avoid consing) is too computationally expensive.")
+ (license license:expat))))
-(define-public cl-evaled-when
- (sbcl-package->cl-source-package sbcl-evaled-when))
+(define-public cl-ucons
+ (sbcl-package->cl-source-package sbcl-ucons))
-(define-public ecl-evaled-when
- (sbcl-package->ecl-package sbcl-evaled-when))
+(define-public ecl-ucons
+ (sbcl-package->ecl-package sbcl-ucons))
-(define-public sbcl-enhanced-eval-when
+(define-public sbcl-uffi
(package
- (name "sbcl-enhanced-eval-when")
- (version "1.0")
+ (name "sbcl-uffi")
+ (version "2.1.2")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Hexstream/enhanced-eval-when";)
+ (url "http://git.kpe.io/uffi.git";)
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-enhanced-eval-when" version))
- (sha256
- (base32 "1ws1v297plcbqmcvckg7vqzzgnrwfyx5kd7281r1wrhc26998rx2"))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1hqszvz0a3wk4s9faa83sc3vjxcb5rxmjclyr17yzwg55z733kry"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; The useless bundled debian folder drags `make' into the closure.
+ `(begin
+ (delete-file-recursively "debian")
+ #t))))
(build-system asdf-build-system/sbcl)
- ;; https://github.com/Hexstream/enhanced-eval-when/issues/1
(arguments
- (list #:tests? #f)) ; There are no tests in version 1.0.
- (home-page "https://www.hexstreamsoft.com/libraries/enhanced-eval-when/";)
- (synopsis "Shortcuts for EVAL-WHEN")
+ `(#:tests? #f ; TODO: Fix use of deprecated ASDF functions
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-permissions
+ (lambda _
+ (make-file-writable "doc/html.tar.gz")
+ #t)))))
+ (synopsis "Universal foreign function library for Common Lisp")
(description
- "This package provides an enhanced @code{EVAL-WHEN} macro that supports a
-shorthand for @code{(eval-when (:compile-toplevel :load-toplevel :execute)
...)},
-addressing concerns about verbosity.")
- (license license:unlicense)))
-
-(define-public cl-enhanced-eval-when
- (sbcl-package->cl-source-package sbcl-enhanced-eval-when))
-
-(define-public ecl-enhanced-eval-when
- (sbcl-package->ecl-package sbcl-enhanced-eval-when))
+ "UFFI provides a universal foreign function interface (FFI)
+ for Common Lisp.")
+ (home-page "https://quickdocs.org/uffi/";)
+ (license license:llgpl)))
-(define-public sbcl-enhanced-boolean
+(define-public cl-uffi
(package
- (name "sbcl-enhanced-boolean")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/enhanced-boolean";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-enhanced-boolean" version))
- (sha256
- (base32 "17l18lz07fk2kg835vs6c3189d230n1rm9vghk3ls4i356gbq0gy"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (home-page "https://www.hexstreamsoft.com/libraries/enhanced-boolean/";)
- (synopsis "Convert generalized booleans to booleans")
- (description
- "This package provides a canonical way of converting generalized booleans
-to booleans.")
- (license license:unlicense)))
-
-(define-public cl-enhanced-boolean
- (sbcl-package->cl-source-package sbcl-enhanced-boolean))
-
-(define-public ecl-enhanced-boolean
- (sbcl-package->ecl-package sbcl-enhanced-boolean))
+ (inherit (sbcl-package->cl-source-package sbcl-uffi))
+ (arguments
+ `(#:phases
+ ;; asdf-build-system/source has its own phases and does not inherit
+ ;; from asdf-build-system/sbcl phases.
+ (modify-phases %standard-phases/source
+ ;; Already done in SBCL package.
+ (delete 'reset-gzip-timestamps))))))
-(define-public sbcl-cesdi
- (package
- (name "sbcl-cesdi")
- (version "1.0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/cesdi";)
- (commit version)))
- (file-name (git-file-name "cl-cesdi" version))
- (sha256
- (base32 "02f2pz5rw79ljkkx1ywh8nkpjj4g3z3s1lyvzqb8krbnx11wl0q9"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-closer-mop))
- (home-page "https://www.hexstreamsoft.com/libraries/cesdi/";)
- (synopsis "Ergonomic initialization of effective slot definition objects")
- (description
- "This package provides a @code{compute-effective-slot-definition-initargs}
-generic function that allows for more ergonomic initialization of effective
slot
-definition objects.")
- (license license:unlicense)))
+(define-public sbcl-umbra
+ (let ((commit "d6ef2f6cbfa26180929061129eaf325bf17f73d8")
+ (revision "1"))
+ (package
+ (name "sbcl-umbra")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://git.mfiano.net/mfiano/umbra";)
+ (commit commit)))
+ (file-name (git-file-name "umbra" version))
+ (sha256
+ (base32 "04vyh2j00zdpb8ryxr8g81wjcmqlz9wrn55r3cypcj4qg970r5wi"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-golden-utils sbcl-shadow sbcl-varjo))
+ (home-page "https://git.mfiano.net/mfiano/umbra";)
+ (synopsis "Common Lisp library of reusable GPU shader functions")
+ (description
+ "This is a Common Lisp library consisting of a collection of useful GPU
+shader functions, written with @code{Shadow}.")
+ (license license:expat))))
-(define-public cl-cesdi
- (sbcl-package->cl-source-package sbcl-cesdi))
+(define-public ecl-umbra
+ (sbcl-package->ecl-package sbcl-umbra))
-(define-public ecl-cesdi
- (sbcl-package->ecl-package sbcl-cesdi))
+(define-public cl-umbra
+ (sbcl-package->cl-source-package sbcl-umbra))
-(define-public sbcl-compatible-metaclasses
- (package
- (name "sbcl-compatible-metaclasses")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/compatible-metaclasses";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-compatible-metaclasses" version))
- (sha256
- (base32 "17cf74j400cl6sjslfhkv13lir85k705v63mx3dd4y6dl5hvsdh6"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-class-options
- sbcl-closer-mop
- sbcl-enhanced-find-class))
- (home-page
"https://www.hexstreamsoft.com/libraries/compatible-metaclasses/";)
- (synopsis "Simplifies class mixins by validating superclasses")
- (description
- "This library validates superclasses according to a simple substitution
-model, thereby greatly simplifying the definition of class mixins.")
- (license license:unlicense)))
+(define-public sbcl-unix-opts
+ (let ((commit "0e61f34b2ecf62288437810d4abb31e572048b04")
+ (revision "1"))
+ (package
+ (name "sbcl-unix-opts")
+ (version (git-version "0.1.7" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/libre-man/unix-opts";)
+ (commit commit)))
+ (file-name (git-file-name "unix-opts" version))
+ (sha256
+ (base32 "16mcqpzwrz808p9n3wwl99ckg3hg7yihw08y1i4l7c92aldbkasq"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/hankhero/cl-json";)
+ (synopsis "Unix-style command line options parser")
+ (description
+ "This is a minimalistic parser of command line options. The main
+advantage of the library is the ability to concisely define command line
+options once and then use this definition for parsing and extraction of
+command line arguments, as well as printing description of command line
+options (you get --help for free). This way you don't need to repeat
+yourself. Also, @command{unix-opts} doesn't depend on anything and
+precisely controls the behavior of the parser via Common Lisp restarts.")
+ (license license:expat))))
-(define-public cl-compatible-metaclasses
- (sbcl-package->cl-source-package sbcl-compatible-metaclasses))
+(define-public cl-unix-opts
+ (sbcl-package->cl-source-package sbcl-unix-opts))
-(define-public ecl-compatible-metaclasses
- (sbcl-package->ecl-package sbcl-compatible-metaclasses))
+(define-public ecl-unix-opts
+ (sbcl-package->ecl-package sbcl-unix-opts))
-(define-public sbcl-class-options
+(define-public sbcl-usocket
(package
- (name "sbcl-class-options")
- (version "1.0.1")
+ (name "sbcl-usocket")
+ (version "0.8.6")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Hexstream/class-options";)
+ (url "https://github.com/usocket/usocket/";)
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-class-options" version))
+ (file-name (git-file-name "cl-usocket" version))
(sha256
- (base32 "1dkgr1vbrsra44jznzz2bvdf8nlpdrrkjcqrfs8aa7axksda3bqk"))))
+ (base32 "0by8hhg6gijdbq5vjykd374rmvqyikp4synpyk0wjcl7rk3r0vgn"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-enhanced-boolean sbcl-parachute))
+ (list sbcl-rt))
(inputs
- (list sbcl-closer-mop sbcl-enhanced-find-class))
- (home-page "https://www.hexstreamsoft.com/libraries/class-options/";)
- (synopsis "Accessing defining class and its options during modification")
+ (list sbcl-bordeaux-threads sbcl-split-sequence))
+ (arguments
+ `(#:tests? #f ; FIXME: Tests need network access?
+ #:asd-systems '("usocket"
+ "usocket-server")))
+ (home-page "https://common-lisp.net/project/usocket/";)
+ (synopsis "Universal socket library for Common Lisp")
(description
- "This package provides easy access to the defining class and its options
-during initialization or reinitialization of its subcomponents.")
- (license license:unlicense)))
+ "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)))
-(define-public cl-class-options
- (sbcl-package->cl-source-package sbcl-class-options))
+(define-public cl-usocket
+ (sbcl-package->cl-source-package sbcl-usocket))
-(define-public ecl-class-options
- (sbcl-package->ecl-package sbcl-class-options))
+(define-public ecl-usocket
+ (sbcl-package->ecl-package sbcl-usocket))
-(define-public sbcl-enhanced-find-class
- (package
- (name "sbcl-enhanced-find-class")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/enhanced-find-class";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-enhanced-find-class" version))
- (sha256
- (base32 "1pf1mxb238zrmvgm9s0456s1x0m317ls23ls1d987riw69y3w9vx"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-closer-mop))
- (home-page "https://www.hexstreamsoft.com/libraries/enhanced-find-class/";)
- (synopsis "Canonical way of converting class designators to classes")
- (description
- "This package provides a canonical way of converting class designators
-to classes.")
- (license license:unlicense)))
+(define-public sbcl-utils-kt
+ (let ((commit "4adfe2889036ab5ffdd3cc2182ca2cc692bf11ff"))
+ (package
+ (name "sbcl-utils-kt")
+ (version (git-version "2007-12-02" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/kennytilton/utils-kt";)
+ (commit commit)))
+ (file-name (git-file-name "cl-utils-kt" version))
+ (sha256
+ (base32 "016x3w034brz02z9mrsrkhk2djizg3yqsvhl9k62xqcnpy3b87dn"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/kennytilton/utils-kt";)
+ (synopsis "Kenny's utilities for Common Lisp")
+ (description
+ "This library contains generic hacks meant to be used in any project.
+It was originally developed for the Cells library.")
+ (license license:expat))))
-(define-public cl-enhanced-find-class
- (sbcl-package->cl-source-package sbcl-enhanced-find-class))
+(define-public cl-utils-kt
+ (sbcl-package->cl-source-package sbcl-utils-kt))
-(define-public ecl-enhanced-find-class
- (sbcl-package->ecl-package sbcl-enhanced-find-class))
+(define-public ecl-utils-kt
+ (sbcl-package->ecl-package sbcl-utils-kt))
-(define-public sbcl-definitions-systems
- (package
- (name "sbcl-definitions-systems")
- (version "2.0.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/definitions-systems";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-definitions-systems" version))
- (sha256
- (base32 "009392mj0qdq4jy0dw5r41schnygwj286759yvyg7xja30a0psfq"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-canonicalized-initargs
- sbcl-enhanced-defclass
- sbcl-enhanced-find-class
- sbcl-shared-preferences))
- (home-page "https://www.hexstreamsoft.com/libraries/definitions-systems/";)
- (synopsis "Unified extensible way of processing named definitions")
- (description
- "@code{definitions-systems} provides a simple unified extensible way of
-processing named definitions.")
- (license license:unlicense)))
+(define-public sbcl-utm-ups
+ (let ((commit "f1e6fd469871051470dfaabdf199afb75f2fa302")
+ (revision "0"))
+ (package
+ (name "sbcl-utm-ups")
+ (version (git-version "1.2" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://codeberg.org/glv/utm-ups";)
+ (commit commit)))
+ (file-name (git-file-name "cl-utm-ups" version))
+ (sha256
+ (base32 "19nnnqagfg1c1vzwlqpp8mq2d0hrk8r6r07a46nvdyzmwbnmbwyr"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis
+ "Convert coordinates between latitude/longitude and UTM or UPS")
+ (description
+ "This a Common Lisp library to convert geographic coordinates between
+latitude/longitude and UTM (Universal Transverse Mercator) or UPS (Universal
+Polar Stereographic).")
+ (home-page "https://codeberg.org/glv/utm-ups";)
+ (license license:gpl3+))))
+
+(define-public cl-utm-ups
+ (sbcl-package->cl-source-package sbcl-utm-ups))
+
+(define-public ecl-utm-ups
+ (sbcl-package->ecl-package sbcl-utm-ups))
+
+(define-public sbcl-uuid
+ (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
+ (package
+ (name "sbcl-uuid")
+ (version (git-version "2012.12.26" "1" commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/dardoria/uuid";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32
+ "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-ironclad sbcl-trivial-utf-8))
+ (home-page "https://github.com/dardoria/uuid";)
+ (synopsis
+ "Common Lisp implementation of UUIDs according to RFC4122")
+ (description
+ "Common Lisp implementation of UUIDs according to RFC4122.")
+ (license license:llgpl))))
+
+(define-public cl-uuid
+ (sbcl-package->cl-source-package sbcl-uuid))
+
+(define-public ecl-uuid
+ (sbcl-package->ecl-package sbcl-uuid))
+
+(define-public sbcl-varjo
+ (let ((commit "9e77f30220053155d2ef8870ceba157f75e538d4")
+ (revision "1"))
+ (package
+ (name "sbcl-varjo")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cbaggers/varjo";)
+ (commit commit)))
+ (file-name (git-file-name "varjo" version))
+ (sha256
+ (base32 "1p9x1wj576x5d31yvls9r1avkjkyhri7kyxbjfkg9z93a1w18j9z"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cl-ppcre
+ sbcl-documentation-utils
+ sbcl-fn
+ sbcl-glsl-spec
+ sbcl-named-readtables
+ sbcl-parse-float
+ sbcl-vas-string-metrics))
+ (home-page "https://github.com/cbaggers/varjo";)
+ (synopsis "Lisp to GLSL Language Translator")
+ (description
+ "Varjo is a Lisp to GLSL compiler. Vari is the dialect of lisp Varjo
+compiles. It aims to be as close to Common Lisp as possible, but naturally it
+is statically typed so there are differences.")
+ (license license:bsd-2))))
+
+(define-public cl-varjo
+ (sbcl-package->cl-source-package sbcl-varjo))
+
+(define-public ecl-varjo
+ (sbcl-package->ecl-package sbcl-varjo))
+
+(define-public sbcl-vas-string-metrics
+ (let ((commit "f2e4500b180316123fbd549bd51c751ee2d6ba0f")
+ (revision "1"))
+ (package
+ (name "sbcl-vas-string-metrics")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/vsedach/vas-string-metrics";)
+ (commit commit)))
+ (file-name (git-file-name "vas-string-metrics" version))
+ (sha256
+ (base32 "11fcnd03ybzz37rkg3z0wsb727yqgcd9gn70sccfb34l89ia279k"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-test-systems '("test.vas-string-metrics")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-test-asd
+ (lambda _
+ (substitute* "test.vas-string-metrics.asd"
+ ((":depends-on")
+ (string-append
+ ":perform (test-op (op c) (symbol-call :vas-string-metrics
:run-tests))"
+ "\n"
+ " :depends-on"))))))))
+ (home-page "https://github.com/vsedach/vas-string-metrics";)
+ (synopsis "String distance algorithms for Common Lisp")
+ (description
+ "VAS-STRING-METRICS provides the Jaro, Jaro-Winkler, Soerensen-Dice,
+Levenshtein, and normalized Levenshtein string distance/similarity metrics
+algorithms.")
+ (license license:lgpl3+))))
-(define-public cl-definitions-systems
- (sbcl-package->cl-source-package sbcl-definitions-systems))
+(define-public cl-vas-string-metrics
+ (sbcl-package->cl-source-package sbcl-vas-string-metrics))
-(define-public ecl-definitions-systems
- (sbcl-package->ecl-package sbcl-definitions-systems))
+(define-public ecl-vas-string-metrics
+ (sbcl-package->ecl-package sbcl-vas-string-metrics))
-(define-public sbcl-numerical-utilities
- (let ((commit "44f45ba952b35675640630e40cf90df6f8279746")
- (revision "0"))
+(define-public sbcl-verbose
+ (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174")
+ (revision "1"))
(package
- (name "sbcl-numerical-utilities")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-verbose")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/numerical-utilities";)
+ (url "https://github.com/Shinmera/verbose/";)
(commit commit)))
- (file-name (git-file-name "cl-numerical-utilities" version))
+ (file-name (git-file-name "verbose" version))
(sha256
- (base32 "1dwz8zxhqzi31qp863zj1cn1lgljny14snycb9nk871qs121kmsd"))))
+ (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("num-utils" "num-utils/tests")))
(inputs
- (list sbcl-alexandria
- sbcl-alexandria-plus
- sbcl-anaphora
- sbcl-array-operations
- sbcl-let-plus
- sbcl-select))
- (native-inputs
- (list sbcl-fiveam))
- (home-page "https://lisp-stat.github.io/numerical-utilities";)
- (synopsis "Utilities for numerical programming")
+ (list sbcl-bordeaux-threads sbcl-dissect sbcl-documentation-utils
+ sbcl-local-time sbcl-piping))
+ (home-page "https://shinmera.github.io/verbose/";)
+ (synopsis "Logging framework using the piping library")
(description
- "@code{cl-numerical-utilities} is a collection of packages useful in
-numerical applications, each big enough to be its own package, but too small
-to split out into a separate ASDF system.")
- (license license:ms-pl))))
+ "This is a Common Lisp library providing logging faciltiy similar to
+@code{CL-LOG} and @code{LOG4CL}.")
+ (license license:zlib))))
-(define-public cl-numerical-utilities
- (sbcl-package->cl-source-package sbcl-numerical-utilities))
+(define-public cl-verbose
+ (sbcl-package->cl-source-package sbcl-verbose))
-(define-public ecl-numerical-utilities
- (sbcl-package->ecl-package sbcl-numerical-utilities))
+(define-public ecl-verbose
+ (sbcl-package->ecl-package sbcl-verbose))
-(define-public sbcl-zr-utils
- (let ((commit "e7eaffcb71811f6e1ab85fb15a079bcac4038eeb")
- (revision "0"))
+(define-public sbcl-vernacular
+ ;; No release.
+ (let ((commit "79be179e9ada423b3ec41d2a1ea6f6e0266ed21f"))
(package
- (name "sbcl-zr-utils")
- (version (git-version "0.0.0.0" revision commit))
+ (name "sbcl-vernacular")
+ (version (git-version "0.8.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/zombie-raptor/zr-utils.git";)
+ (url "https://github.com/ruricolist/vernacular/";)
(commit commit)))
- (file-name (git-file-name "cl-zr-utils" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1nx388974wdc49h3simr1jnv4rw1mcs2llv4xai88qwjf4y66hsy"))))
+ (base32 "19vzn28hw4is4sgmvzqin18ds89s0pai21vcm0ky10vmfv6wg745"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; The demo depends on cl-js, which we don't have at this point.
+ (delete-file-recursively "demo")
+ #t))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-parachute))
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-closer-mop
- sbcl-cl-unicode
- sbcl-trivial-gray-streams))
+ `(("overlord" ,sbcl-overlord)
+ ("trivial-macroexpand-all" ,sbcl-trivial-macroexpand-all)
+ ("local-time" ,sbcl-local-time)
+ ("parse-js" ,sbcl-parse-js)
+ ("trivia" ,sbcl-trivia)
+ ("trivial-garbage" ,sbcl-trivial-garbage)
+ ("named-readtables" ,sbcl-named-readtables)
+ ("alexandria" ,sbcl-alexandria)
+ ("serapeum" ,sbcl-serapeum)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)))
(arguments
- (list #:tests? #f ; FIXME: Failing with new parachute.
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "zr-utils.asd"
- (("\\(:parachute")
- "(:parachute :zr-utils/tests/all")))))))
- (synopsis "Common Lisp utilities library")
+ ;; Circular dependency: Tests depend on core-lisp
+ ;; (http://github.com/ruricolist/core-lisp) which depends on
+ ;; Vernacular.
+ '(#:tests? #f))
+ (home-page "https://github.com/ruricolist/vernacular";)
+ (synopsis "Module system for languages that compile to Common Lisp")
(description
- "This is a Common Lisp utilities library originating from the
-Zombie Raptor game engine project.")
- (home-page "https://gitlab.com/zombie-raptor/zr-utils";)
- (license license:expat))))
+ "Vernacular is a build and module system for languages that compile to
+Common Lisp. It allows languages to compile to Lisp while remaining part of
+the Common Lisp ecosystem. Vernacular languages interoperate with Common Lisp
+and one another.
-(define-public cl-zr-utils
- (sbcl-package->cl-source-package sbcl-zr-utils))
+Vernacular handles locating files, compiling files into FASLs, tracking
+dependencies and rebuilding, and export and import between your new language,
+Lisp, and any other language Vernacular supports.
-(define-public ecl-zr-utils
- (sbcl-package->ecl-package sbcl-zr-utils))
+Vernacular builds on Overlord and is inspired by Racket.")
+ (license license:expat))))
-(define-public sbcl-draw-cons-tree
- (let ((commit "04334f5885a85cd7127db8dda3f6d6686a0438b1")
+(define-public cl-vernacular
+ (sbcl-package->cl-source-package sbcl-vernacular))
+
+(define-public sbcl-vgplot
+ (let ((commit "76329928a3709387c0779175af56ec49d16bcd35")
(revision "0"))
(package
- (name "sbcl-draw-cons-tree")
- (version (git-version "1.0" revision commit))
- ;; https://github.com/quicklisp/quicklisp-projects/issues/2149
+ (name "sbcl-vgplot")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/draw-cons-tree";)
+ (url "https://github.com/volkers/vgplot";)
(commit commit)))
- (file-name (git-file-name "cl-draw-cons-tree" version))
+ (file-name (git-file-name "vgplot" version))
(sha256
- (base32 "1523bdkq8a5qn0qp9q7r16w47y6jb0hkfj7hbjfj6mg3xv001s3x"))))
+ (base32 "1vc5fd787xa8831wjbmwrpg17f9isi5k8dmb85fsysz47plbvi1y"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam sbcl-split-sequence))
+ (list sbcl-lisp-unit))
(inputs
- (list sbcl-alexandria))
- (synopsis "Draw an ascii picture of a cons tree")
+ (list sbcl-cl-fad sbcl-cl-ppcre sbcl-ltk))
+ (home-page "https://github.com/volkers/vgplot";)
+ (synopsis "Common lisp library interfacing to the gnuplot utility")
(description
- "@code{cl-draw-cons-tree} draws a cons tree in ASCII-art style.")
- (home-page "https://github.com/phoe/draw-cons-tree/";)
- (license license:unlicense))))
+ "This package provides an interface to the @code{gnuplot} plotting
+utility. The intention of the API is to resemble to some of the plot commands
+of octave or matlab.")
+ (license license:gpl3+))))
-(define-public cl-draw-cons-tree
- (sbcl-package->cl-source-package sbcl-draw-cons-tree))
+(define-public cl-vgplot
+ (sbcl-package->cl-source-package sbcl-vgplot))
-(define-public ecl-draw-cons-tree
- (sbcl-package->ecl-package sbcl-draw-cons-tree))
+(define-public ecl-vgplot
+ (sbcl-package->ecl-package sbcl-vgplot))
-(define-public sbcl-triads
- (let ((commit "840b025bf3d65cc5eaead4542a02a3ca6d77c2b6")
- (revision "0"))
+(define-public sbcl-virality
+ (let ((commit "cdc19cca9b028f0c30d14ed8b3e51359dd46069a")
+ (revision "1"))
(package
- (name "sbcl-triads")
- (version (git-version "0" revision commit))
+ (name "sbcl-virality")
+ (version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charJe/triads";)
+ (url "https://github.com/bufferswap/ViralityEngine";)
(commit commit)))
- (file-name (git-file-name "cl-triads" version))
+ (file-name (git-file-name "cl-virality" version))
(sha256
- (base32 "146mwshynhdw82m2nxrcjvf1nk0z3fn6ywcd2vqxkly5qricc53w"))))
+ (base32 "1s25aapkqcr8fxi0i9wjw0n4jax7r4a9d9wflpr3sqz2vgrg2lz6"))))
(build-system asdf-build-system/sbcl)
- (outputs '("out" "bin"))
(arguments
- '(#:asd-systems '("charje.triads")
- #:phases
- (modify-phases %standard-phases
- (add-after 'create-asdf-configuration 'build-binary
- (lambda* (#:key outputs #:allow-other-keys)
- (setenv "HOME" (getcwd))
- (invoke
- "sbcl" "--eval" "(require :asdf)" "--eval"
- (format
- #f "~S"
- `(progn
- (require "charje.triads"
- ,(string-append (getcwd) "/charje.triads.asd"))
- (asdf:make "charje.triads"))))
- (install-file
- (string-append (getcwd) "/triads")
- (string-append (assoc-ref outputs "bin") "/bin")))))))
+ `(#:asd-systems '("virality"
+ "vorigin"
+ "vorigin.test"
+ "vshadow"
+ "vumbra"
+ "vutils")
+ #:phases (modify-phases %standard-phases
+ (add-after 'unpack 'delete-examples
+ (lambda _
+ ;; Don't install the big "examples" directory.
+ (delete-file-recursively "examples")
+ ;; Remove example asd files that cause issues during
+ ;; the 'copy-source' phase because they have the same
+ ;; names.
+ (for-each
+ delete-file
+ (find-files "."
+ "^xXx-SYSTEM-NAME-xXx\\.asd$")))))))
(inputs
- (list sbcl-cl-str
- sbcl-serapeum
- sbcl-trivia))
- (home-page "https://github.com/charJe/triads";)
- (synopsis "Music composition tool to convert roman numerals into triads")
- (description "Triads is a simple command line tool that reads roman
-numeral notation from standard input (or a file) and an musical key and outputs
-the roman numeral in addition to the notes of the triad associated with that
-roman numeral given in the key.")
- (license license:gpl3))))
+ (list sbcl-3b-bmfont
+ sbcl-babel
+ sbcl-cl-cpus
+ sbcl-cl-graph
+ sbcl-cl-opengl
+ sbcl-cl-ppcre
+ sbcl-cl-slug
+ sbcl-closer-mop
+ sbcl-fast-io
+ sbcl-global-vars
+ sbcl-glsl-packing
+ sbcl-jsown
+ sbcl-lparallel
+ sbcl-pngload
+ sbcl-printv
+ sbcl-queues
+ sbcl-sdl2
+ sbcl-serapeum
+ sbcl-split-sequence
+ sbcl-static-vectors
+ sbcl-trivial-features
+ sbcl-varjo))
+ (home-page "https://github.com/bufferswap/ViralityEngine";)
+ (synopsis "Component-based game engine written in Common Lisp")
+ (description
+ "Virality Engine provides a system and workflow that helps describe the
+elements needed to write 2D or 3D games. It was designed with several domain
+specific languages that make it easier to describe, manipulate, and use assets
+commonly found in game making. Such assets include (but are not limited to)
+textures, materials, shader programs, and scene trees of actors that are
+available for instantiation. Virality Engine also knows how to accept input
+from keyboards and most joysticks and gamepads.
-(define-public cl-triads
- (sbcl-package->cl-source-package sbcl-triads))
+The component system is a hybrid model between an ECS and an object model. The
+components are defined similar to CLOS defclass, and regular generic methods
+can be used with them. Components are added to Actors which represent game
+concepts like players, scenery, effects, etc. We define a component protocol
+invoked by Virality Engine to move your components to the next state and
+render them each frame.")
+ (license license:expat))))
-(define-public ecl-triads
- (let ((ecl-package (sbcl-package->ecl-package sbcl-triads)))
- (package
- (inherit ecl-package)
- (outputs '("out"))
- (arguments
- (substitute-keyword-arguments (package-arguments ecl-package)
- ((#:phases phases)
- `(modify-phases ,phases
- (delete 'build-binary))))))))
+(define-public cl-virality
+ (sbcl-package->cl-source-package sbcl-virality))
-(define-public sbcl-music-spelling
- (let ((commit "a2d492af440ad30a21042140cf8ffce4b73fbd42")
- (revision "0"))
+(define-public sbcl-vom
+ (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
+ (revision "1"))
(package
- (name "sbcl-music-spelling")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-vom")
+ (version (git-version "0.1.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ntrocado/music-spelling";)
+ (url "https://github.com/orthecreedence/vom";)
(commit commit)))
- (file-name (git-file-name "cl-music-spelling" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0fgahb0jjr4sp2739d55gylmx8alsghnx3spyaqfqci4cxfrys52"))))
+ (base32
+ "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
(build-system asdf-build-system/sbcl)
- (inputs (list sbcl-alexandria))
- (home-page "https://github.com/ntrocado/music-spelling/";)
- (synopsis "Automatically spell musical pitches and rhythms")
- (description "This package implements an algorithm for the spelling
-of enharmonics and dealing with ties and dots in rhythm notation.")
- (license license:asl2.0))))
+ (synopsis "Tiny logging utility for Common Lisp")
+ (description
+ "Vom is a logging library for Common Lisp. It's goal is to be useful
+and small. It does not provide a lot of features as other loggers do, but
+has a small codebase that's easy to understand and use.")
+ (home-page "https://github.com/orthecreedence/vom";)
+ (license license:expat))))
-(define-public cl-music-spelling
- (sbcl-package->cl-source-package sbcl-music-spelling))
+(define-public cl-vom
+ (sbcl-package->cl-source-package sbcl-vom))
-(define-public ecl-music-spelling
- (sbcl-package->ecl-package sbcl-music-spelling))
+(define-public ecl-vom
+ (sbcl-package->ecl-package sbcl-vom))
-(define-public sbcl-closure-template
- ;; There are no releases since 2015.
- (let ((commit "f1983aa525045691e128027d2a2d74831c873d6e")
+(define-public sbcl-websocket-driver
+ (let ((commit "df94496ecb525d086eeada4f5875975515b7212e")
(revision "0"))
(package
- (name "sbcl-closure-template")
- (version (git-version "0.2.1" revision commit))
+ (name "sbcl-websocket-driver")
+ (version (git-version "0.2.0" revision commit))
+ (home-page "https://github.com/fukamachi/websocket-driver";)
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/websocket-driver";)
+ (commit commit)))
+ (file-name (git-file-name "cl-websocket-driver" version))
+ (sha256
+ (base32 "0y852sqdnxfma6kw833by4wkgbgbv4ppzawjk8pk3y1pmh6is83y"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-babel
+ sbcl-clack
+ sbcl-fast-http
+ sbcl-fast-io
+ sbcl-fast-websocket
+ sbcl-event-emitter
+ sbcl-sha1
+ sbcl-cl-base64
+ sbcl-split-sequence
+ sbcl-bordeaux-threads
+ sbcl-quri))
+ (synopsis "WebSocket server/client for Common Lisp")
+ (description "This library provides a WebSocket server and client
+implementation for Common Lisp.")
+ (license license:bsd-2))))
+
+(define-public cl-websocket-driver
+ (sbcl-package->cl-source-package sbcl-websocket-driver))
+
+(define-public ecl-websocket-driver
+ (sbcl-package->ecl-package sbcl-websocket-driver))
+
+(define-public sbcl-which
+ (let ((commit "b2333e4fcacab6e5d85eecd28b5ef4944bda1448")
+ (revision "1"))
+ (package
+ (name "sbcl-which")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/cl-closure-template";)
+ (url "https://github.com/eudoxia0/which";)
(commit commit)))
- (file-name (git-file-name "cl-closure-template" version))
+ (file-name (git-file-name "cl-which" version))
(sha256
- (base32 "16h0fs6bjjd4n9pbkwcprpgyj26vsw2akk3q08m7xmsmqi05dppv"))))
+ (base32 "127pm9h4rm4w9aadw5yvamnfzhk2rr69kchx10rf9k7sk7izqqfk"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-lift))
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-closer-mop
- sbcl-esrap
- sbcl-iterate
- sbcl-parse-number
- sbcl-split-sequence))
- (synopsis "Lisp implementation of Google Closure Templates")
+ (list sbcl-cl-fad sbcl-path-parse))
+ (native-inputs
+ (list sbcl-fiveam))
+ (home-page "https://github.com/eudoxia0/which";)
+ (synopsis "The which command in Common Lisp")
(description
- "This package provides a Common Lisp implementation of Google
-Closure Templates.")
- (home-page "https://github.com/archimag/cl-closure-template/";)
- (license license:llgpl))))
-
-(define-public cl-closure-template
- (sbcl-package->cl-source-package sbcl-closure-template))
-
-(define-public ecl-closure-template
- (sbcl-package->ecl-package sbcl-closure-template))
-
-(define-public sbcl-cl-morse
- (package
- (name "sbcl-cl-morse")
- (version "1.0.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/em7/cl-morse";)
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-morse" version))
- (sha256
- (base32 "01sh34nhbsx2dsrb2r1vkd4j8lzm9gjd5jfi8a4cs4m3djjwhh5i"))))
- (build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cl-ppcre))
- (native-inputs (list sbcl-fiveam))
- (home-page "https://github.com/em7/cl-morse";)
- (synopsis "Morse code translation library for Common Lisp")
- (description
- "@code{cl-morse} is a Morse code translation library for Common Lisp.")
- (license license:bsd-3)))
+ "This package provides an implementation of the @code{which} UNIX
+command in Common Lisp.")
+ (license license:expat))))
-(define-public cl-morse
- (sbcl-package->cl-source-package sbcl-cl-morse))
+(define-public cl-which
+ (sbcl-package->cl-source-package sbcl-which))
-(define-public ecl-cl-morse
- (sbcl-package->ecl-package sbcl-cl-morse))
+(define-public ecl-which
+ (sbcl-package->ecl-package sbcl-which))
-(define-public sbcl-smug
- (let ((commit "647a2428df297e1dd183ba7c19574bdb1320ae79")
+(define-public sbcl-wild-package-inferred-system
+ (let ((commit "800b5f89b61cc4a0a9cf14706fd3f7e7fcd3e539")
(revision "0"))
(package
- (name "sbcl-smug")
- (version (git-version "0.0.0" revision commit))
- (source
+ (name "sbcl-wild-package-inferred-system")
+ (version (git-version "0.2.0" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/drewc/smug";)
+ (url
"https://github.com/privet-kitty/wild-package-inferred-system";)
(commit commit)))
- (file-name (git-file-name "cl-smug" version))
+ (file-name (git-file-name "cl-wild-package-inferred-system" version))
(sha256
- (base32 "13gzkj9skya2ziwclk041v7sif392ydbvhvikhg2raa3qjcxb3rq"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- `(#:tests? #f)) ; There are no tests.
- (synopsis "Parser combinators for Common Lisp")
- (description
- "@code{cl-smug} is a library for parsing text, based on monadic parser
-combinators. Using a simple technique from the functional programming
-camp, @code{cl-smug} makes it simple to create quick extensible recursive
-descent parsers without funky syntax or impenetrable macrology.")
- (home-page "https://smug.drewc.ca/";)
- (license license:expat))))
+ (base32 "0sp3j3i83aqyq9bl3djs490nilryi9sh1wjbcqd9z94d9wfbfz80"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-fiveam))
+ (home-page
"https://github.com/privet-kitty/wild-package-inferred-system/";)
+ (synopsis "Wildcard for ASDF package-inferred-system")
+ (description
+ "@code{wild-package-inferred-system} is an extension of ASDF
+package-inferred-system that interprets star * and globstar ** in package
+or system names.")
+ (license license:expat))))
-(define-public cl-smug
- (sbcl-package->cl-source-package sbcl-smug))
+(define-public cl-wild-package-inferred-system
+ (sbcl-package->cl-source-package sbcl-wild-package-inferred-system))
-(define-public ecl-smug
- (sbcl-package->ecl-package sbcl-smug))
+(define-public ecl-wild-package-inferred-system
+ (sbcl-package->ecl-package sbcl-wild-package-inferred-system))
-(define-public sbcl-cl-variates
- (let ((commit "4e7548754d8a8731a42487fae31174db4bf36d47")
+(define-public sbcl-with-user-abort
+ (let ((commit "60693b4a1354faf17107ad6003b0b870cca37081")
(revision "0"))
(package
- (name "sbcl-cl-variates")
- (version "0.9.0")
+ (name "sbcl-with-user-abort")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-variates/cl-variates";)
+ (url "https://github.com/compufox/with-user-abort";)
(commit commit)))
- (file-name (git-file-name "cl-variates" version))
+ (file-name (git-file-name "cl-with-user-abort" version))
(sha256
- (base32 "03wnvfi3yfflpvi0mr732r834msij4vrwdbgf6csh0b8kqxl47zn"))))
+ (base32 "0k1xxfvncdw4fx8nncis1ma128bqq05zky1mrzak5rjbivzjm8j1"))))
(build-system asdf-build-system/sbcl)
- ;; USE-PACKAGE #<PACKAGE "CL-VARIATES"> causes name-conflicts in
- ;; #<PACKAGE "CL-VARIATES-TEST"> between the following symbols:
- ;; CL-VARIATES:RANDOM-ELEMENT, LIFT:RANDOM-ELEMENT
- (arguments (list #:tests? #f))
- (native-inputs (list sbcl-lift))
- (home-page "https://gitlab.common-lisp.net/cl-variates/cl-variates";)
- (synopsis "Portable Common Lisp Random Number Generation")
- (description "The variates package provides portable random number
-generation as well as numerous distributions.")
- (license license:expat))))
+ (home-page "https://github.com/compufox/with-user-abort";)
+ (synopsis "Portability library for catching SIGINT from Common Lisp")
+ (description
+ "@code{with-user-abort} is a Common Lisp portability library providing a
+like-named macro that catches the SIGINT signal.")
+ (license license:bsd-3))))
-(define-public cl-variates
- (sbcl-package->cl-source-package sbcl-cl-variates))
+(define-public cl-with-user-abort
+ (sbcl-package->cl-source-package sbcl-with-user-abort))
-(define-public ecl-cl-variates
- (sbcl-package->ecl-package sbcl-cl-variates))
+(define-public ecl-with-user-abort
+ (sbcl-package->ecl-package sbcl-with-user-abort))
-(define-public sbcl-cl-vorbis
- (let ((commit "c5835cd7091aea9e2e389ad359d244542d637758")
- (revision "0"))
+(define-public sbcl-woo
+ (let ((commit "fba3567be95ed6e782d98a4c1477d3a74b8ad124")
+ (revision "1"))
(package
- (name "sbcl-cl-vorbis")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-woo")
+ (version (git-version "0.12.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-vorbis";)
+ (url "https://github.com/fukamachi/woo";)
(commit commit)))
- (file-name (git-file-name "cl-vorbis" version))
+ (file-name (git-file-name "woo" version))
(sha256
- (base32 "0713pl5c2khfpf8m3h1l2y0ilack7akf580h70jq6qcrnq3h4b40"))
- (modules '((guix build utils)))
- (snippet
- ;; Delete bundled libraries, GlibC and Vorbis sources.
- `(begin
- (delete-file-recursively "static")
- (for-each delete-file '("glibc-2.13.h"
- "stb_vorbis.c"
- "stb_vorbis_patch.c"))))))
+ (base32 "06f95x8s8v523gxmrkn9wwgw2pvc3bc66znbgrzhqb30y4aar5v5"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "low-level.lisp"
- (("libvorbis-lin-amd64.so")
- (search-input-file inputs "/lib/libvorbis.so"))))))))
+ ;; FIXME: Tests fail because they try to compile clack-test:
+ ;;
+ ;; Error opening #P"/gnu/store/...-sbcl-clack-2.0.0-1.e3e0328/
+ ;; lib/common-lisp/sbcl/clack/src/test-tmpGHU3ALSV.fasl":
+ ;;
+ ;; Permission denied
+ ;;
+ ;; clack-test should be compiled when building the sbcl-clack package,
+ ;; but it isn't right now because of the circular dependency between
+ ;; clack-test and dexador.
+ `(#:tests? #f))
+ (native-inputs
+ (list sbcl-clack sbcl-rove))
(inputs
- (list libvorbis
+ (list sbcl-alexandria
+ sbcl-bordeaux-threads
sbcl-cffi
- sbcl-documentation-utils
+ sbcl-cl-speedy-queue ;; Required for ecl build
+ sbcl-clack
+ sbcl-fast-http
+ sbcl-fast-io
+ sbcl-lev
+ sbcl-quri
+ sbcl-rove
+ sbcl-smart-buffer
sbcl-static-vectors
- sbcl-trivial-features
- sbcl-trivial-garbage))
- (home-page "https://shirakumo.github.io/cl-vorbis/";)
- (synopsis "OGG/Vorbis decoding using stb_vorbis for Common Lisp")
- (description "This package provides CFFI bindings for the
-@code{stb_vorbis} audio library to Common Lisp.")
- (license license:zlib))))
+ sbcl-swap-bytes
+ sbcl-trivial-utf-8
+ sbcl-vom))
+ (home-page "https://github.com/fukamachi/woo";)
+ (synopsis "Non-blocking HTTP server based on libev")
+ (description
+ "This package provides the Common Lisp HTTP server @code{WOO}, which
+is built on top of the @code{libev} event library.")
+ (license license:expat))))
-(define-public ecl-cl-vorbis
- (sbcl-package->ecl-package sbcl-cl-vorbis))
+(define-public cl-woo
+ (sbcl-package->cl-source-package sbcl-woo))
-(define-public cl-vorbis
- (sbcl-package->cl-source-package sbcl-cl-vorbis))
+(define-public ecl-woo
+ (sbcl-package->ecl-package sbcl-woo))
-(define-public sbcl-cephes
- (let ((commit "d87146fa38c8425ffb5fe425eee5eb3e818bacd4")
+(define-public sbcl-wordnet
+ (let ((commit "8cd0db8f5e84e7a930fa74e590ecddf75cd8e5d6")
(revision "0"))
(package
- (name "sbcl-cephes")
- (version (git-version "1.2" revision commit))
+ (name "sbcl-wordnet")
+ (version (git-version "0.0.1" revision commit))
(source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Lisp-Stat/cephes.cl";)
- (commit commit)))
- (file-name (git-file-name "cl-cephes" version))
- (sha256
- (base32 "09adls1lwwzwm1jmvhf11arwlsy5w0bi2rmniahas824mysv77lr"))))
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phoe/wordnet";)
+ (commit commit)))
+ (sha256
+ (base32 "07p60k295fsfcp0gmkqhrxd68hb38aqva8f4k8xk8bqqxxf42vkq"))
+ (file-name (git-file-name "cl-wordnet" commit))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cffi))
(arguments
- (list #:phases
- #~(modify-phases %standard-phases
- ;; ECL has issues making the shared library automatically,
- ;; so we make it explicitly.
- (add-before 'build 'build-shared-library
- (lambda _
- (with-directory-excursion
- (string-append #$output "/share/common-lisp/"
- (%lisp-type) "/cephes/scipy-cephes")
- (invoke "make")
- ;; Remove temporary object files.
- (for-each delete-file (find-files "." "\\.o$"))))))))
- (home-page "https://lisp-stat.github.io/cephes.cl/";)
- (synopsis "Common Lisp wrapper for the Cephes Mathematical Library")
+ `(#:tests? #f)) ; There are no tests.
+ (inputs
+ (list sbcl-split-sequence))
+ (home-page "https://github.com/phoe/wordnet";)
+ (synopsis "Common Lisp interface to WordNet")
(description
- "This package provides a common lisp CFFI wrapper for the SciPy version
-of Cephes special functions.")
- (license license:ms-pl))))
+ "This software provides an interface by which Common Lisp programs can
+access lexicographic data from WordNet.")
+ (license license:expat))))
-(define-public cl-cephes
- (sbcl-package->cl-source-package sbcl-cephes))
+(define-public cl-wordnet
+ (sbcl-package->cl-source-package sbcl-wordnet))
-(define-public ecl-cephes
- (sbcl-package->ecl-package sbcl-cephes))
+(define-public ecl-wordnet
+ (sbcl-package->ecl-package sbcl-wordnet))
-(define-public sbcl-special-functions
- (let ((commit "f3ca2792ff3f8351839c366413da6b1bb2965a58")
+(define-public sbcl-wu-decimal
+ (let ((commit "5b348bdb32a0f83e80e17aa68cd51787ae8c8a45")
(revision "0"))
(package
- (name "sbcl-special-functions")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-wu-decimal")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/special-functions";)
+ (url "https://github.com/Wukix/wu-decimal";)
(commit commit)))
- (file-name (git-file-name "cl-special-functions" version))
+ (file-name (git-file-name "cl-wu-decimal" version))
(sha256
- (base32 "092szffy7zfxgrvfck11wnj8l0mgcym13yiafj01ad02lbj1fnnv"))))
+ (base32 "1p7na4hic7297amwm4idfwkyx664ny8cdssncyra37pmv4wzp8dm"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam
- sbcl-select
- sbcl-cl-variates))
- (inputs
- (list sbcl-alexandria-plus
- sbcl-float-features
- sbcl-let-plus
- sbcl-numerical-utilities))
- (home-page "https://lisp-stat.dev/docs/resources/special-functions/";)
- (synopsis "Special functions in Common Lisp")
- (description "This library implements
-@url{http://specialfunctionswiki.org/index.php/Main_Page, special
-functions} and has a focus on high accuracy double-float calculations
-using the latest algorithms.")
- (license license:ms-pl))))
+ (home-page "https://github.com/Wukix/wu-decimal";)
+ (synopsis "Arbitrary-precision decimal arithmetic")
+ (description
+ "Wu-Decimal enables convenient, arbitrary-precision decimal arithmetic
+through a reader macro, @code{#$}, and an update to the @code{pprint} dispatch
+table. Wu-Decimal uses the CL rational type to store decimals, which enables
+numeric functions such as @code{+}, @code{-}, etc., to operate on decimal
+numbers in a natural way.")
+ (license license:bsd-2))))
-(define-public cl-special-functions
- (sbcl-package->cl-source-package sbcl-special-functions))
+(define-public cl-wu-decimal
+ (sbcl-package->cl-source-package sbcl-wu-decimal))
-(define-public ecl-special-functions
- (package
- (inherit (sbcl-package->ecl-package sbcl-special-functions))
- ;; https://github.com/Lisp-Stat/special-functions/issues/4
- (arguments (list #:tests? #f))))
+(define-public ecl-wu-decimal
+ (sbcl-package->ecl-package sbcl-wu-decimal))
-(define-public sbcl-distributions
- (let ((commit "ea72622073ee7e005dfdc621ce1e5a83b22bb39e")
+(define-public sbcl-xhtmlambda
+ (let ((commit "c86376bccebf77ca428e8033df2ba7d8450ea1e8")
(revision "0"))
(package
- (name "sbcl-distributions")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-xhtmlambda")
+ (version
+ ;; The source repository doesn't provide any version nor revision, but
+ ;; a timestamp
+ (git-version "2022-01-21" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/distributions";)
+ (url "https://gitlab.common-lisp.net/xhtmlambda/XHTMLambda";)
(commit commit)))
- (file-name (git-file-name "cl-distributions" version))
+ (file-name (git-file-name "cl-xhtmlambda" version))
(sha256
- (base32 "1fkzigd0s0s0mvszgmv04yc8jp9gm4812445hfh6kpz6cjy5zpsk"))))
+ (base32 "0narbzz06ry1wn048avm1fwihvnjvvc4wfcv5hmdazkilpvnqz2y"))))
(build-system asdf-build-system/sbcl)
- ;; https://github.com/Lisp-Stat/distributions/issues/1
- (arguments (list #:tests? #f))
- (native-inputs (list sbcl-fiveam))
- (inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-array-operations
- sbcl-cephes
- sbcl-float-features
- sbcl-let-plus
- sbcl-numerical-utilities
- sbcl-special-functions))
- (home-page "https://lisp-stat.dev/docs/manuals/distributions/";)
- (synopsis "Statistical distributions for Common Lisp")
- (description "The Distributions package provides a collection of
-probabilistic distributions and related functions")
- (license license:ms-pl))))
-
-(define-public cl-distributions
- (sbcl-package->cl-source-package sbcl-distributions))
-
-(define-public ecl-distributions
- (sbcl-package->ecl-package sbcl-distributions))
+ (inputs (list sbcl-cl-unicode))
+ (synopsis "(X)HTML library for Common Lisp")
+ (description
+ "(X)HTMLambda is yet another (X)HTML library which
+emphasizes programmability and user-friendliness. Each (X)HTML element is a
+structured object and pretty-printing of (X)HTML trees is well defined to
+provide properly indented human-readable output even for complex recursive
+arrangements.")
+ (home-page "https://xhtmlambda.common-lisp.dev/";)
+ (license license:expat))))
-(define-public sbcl-statistics
- (let ((commit "94fc87a2bf81355a40ce3730b4ed77710ecfabaf")
+(define-public cl-xhtmlambda
+ (sbcl-package->cl-source-package sbcl-xhtmlambda))
+
+(define-public sbcl-xkbcommon
+ (let ((commit "aa9513d93f42d7816f88dd1bd8bd21375e7d7512")
(revision "0"))
(package
- (name "sbcl-statistics")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-xkbcommon")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/statistics";)
+ (url "https://github.com/sdilts/cl-xkbcommon";)
(commit commit)))
- (file-name (git-file-name "cl-statistics" version))
+ (file-name (git-file-name "cl-xkbcommon" version))
(sha256
- (base32 "0is69w6iwh4hyzc5ndgb3i2331f677sa7kw5wy8pmx6hawbkgyir"))))
+ (base32 "02zdbkh7yliw9vg8i8wx2xgcpfni0fr4z0w19kkxvaib8xm9rx1q"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-clunit2))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "xkbcommon.lisp"
+ (("libxkbcommon.so.0")
+ (search-input-file inputs
"/lib/libxkbcommon.so"))))))))
+ (native-inputs
+ (list pkg-config))
(inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-conduit-packages
- sbcl-distributions
- sbcl-let-plus
- sbcl-numerical-utilities))
- (home-page "https://lisp-stat.dev/docs/";)
- (synopsis "Statistical functions in Common Lisp")
- (description "This package provides a consolidation of Common Lisp
-statistics libraries.")
- (license (list license:expat license:ms-pl)))))
+ (list libxkbcommon
+ sbcl-cffi))
+ (home-page "https://github.com/sdilts/cl-xkbcommon";)
+ (synopsis "Common Lisp FFI bindings for xkbcommon")
+ (description
+ "This package provides Common Lisp FFI bindings for xkbcommon
+(libxkbcommon) using cffi-grovel.")
+ (license license:expat))))
-(define-public cl-statistics
- (sbcl-package->cl-source-package sbcl-statistics))
+(define-public cl-xkbcommon
+ (sbcl-package->cl-source-package sbcl-xkbcommon))
-(define-public ecl-statistics
- (sbcl-package->ecl-package sbcl-statistics))
+(define-public ecl-xkbcommon
+ (sbcl-package->ecl-package sbcl-xkbcommon))
-(define-public sbcl-data-frame
- (let ((commit "6f02e58312654ddf19d686f234dcf699fc4cd0f5")
- (revision "0"))
- (package
- (name "sbcl-data-frame")
- (version (git-version "1.1.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Lisp-Stat/data-frame";)
- (commit commit)))
- (file-name (git-file-name "cl-data-frame" version))
- (sha256
- (base32 "0bs1jh66bml25bj1lxdzz8cjhj3g060yyd5ggqsnsr4l2j0zyszv"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-clunit2))
- (inputs
- (list sbcl-alexandria
- sbcl-alexandria-plus
- sbcl-anaphora
- sbcl-array-operations
- sbcl-duologue
- sbcl-let-plus
- sbcl-numerical-utilities
- sbcl-select
- sbcl-serapeum
- sbcl-statistics))
- (home-page "https://lisp-stat.dev/docs/manuals/data-frame/";)
- (synopsis "Data frames for Common Lisp")
- (description "This package provides data frames for Common Lisp, a
-two-dimensional array-like structure in which each column contains values
-of one variable and each row contains one set of values from each column.")
- (license license:ms-pl))))
+(define-public sbcl-xml-emitter
+ (package
+ (name "sbcl-xml-emitter")
+ (version "1.1.0")
+ (source (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/VitoVan/xml-emitter";)
+ (commit version)))
+ (file-name (git-file-name "cl-xml-emitter" version))
+ (sha256
+ (base32
+ "1w9yx8gc4imimvjqkhq8yzpg3kjrp2y37rjix5c1lnz4s7bxvhk9"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs (list sbcl-1am))
+ (inputs (list sbcl-cl-utilities))
+ (synopsis "Common lisp library for emitting XML output")
+ (description
+ "This package provides functions to emit XML, with some complexity for
+handling indentation. It can be used to produce all sorts of useful XML
+output; it has an RSS 2.0 emitter built in, so you can make RSS feeds
+trivially.")
+ (home-page "https://www.cliki.net/xml-emitter";)
+ (license license:expat)))
-(define-public cl-data-frame
- (sbcl-package->cl-source-package sbcl-data-frame))
+(define-public cl-xml-emitter
+ (sbcl-package->cl-source-package sbcl-xml-emitter))
-;; The data-frame system depends on the sb-cltl2 system, which is only
-;; available with SBCL.
-;; (define-public ecl-data-frame
-;; (sbcl-package->ecl-package sbcl-data-frame))
+(define-public ecl-xml-emitter
+ (sbcl-package->ecl-package sbcl-xml-emitter))
-(define-public sbcl-dfio
- (let ((commit "5caf473acb9bc464839e87395724cbd941167915")
- (revision "0"))
+(define-public sbcl-xmls
+ (package
+ (name "sbcl-xmls")
+ (version "3.2.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rpgoldman/xmls";)
+ (commit version)))
+ (file-name (git-file-name "cl-xmls" version))
+ (sha256
+ (base32 "10406sgap9kdaip7blxldnv6kabiczd6890jgic4pacsrfx6jypk"))))
+ (native-inputs
+ (list sbcl-fiveam))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/rpgoldman/xmls";)
+ (synopsis "Non-validating XML parser for Common Lisp")
+ (description "Xmls is a self-contained, easily embedded parser that
+recognizes a useful subset of the XML spec. It provides a simple mapping from
+XML to Lisp structures or s-expressions and back.")
+ (license license:bsd-2)))
+
+(define-public cl-xmls
+ (sbcl-package->cl-source-package sbcl-xmls))
+
+(define-public ecl-xmls
+ (sbcl-package->ecl-package sbcl-xmls))
+
+(define-public sbcl-xpath
+ ;; No release.
+ (let ((commit "d364da693a534e23bd5eb3a85420e9c25e6c75b3"))
(package
- (name "sbcl-dfio")
- (version (git-version "1.0.2" revision commit))
+ (name "sbcl-xpath")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/dfio";)
+ (url "https://github.com/sharplispers/xpath/";)
(commit commit)))
- (file-name (git-file-name "cl-dfio" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1p53r7773939jnap518xp4b4wfvc1kbrz9jp6yd40xq0jpf9pbqg"))))
+ (base32 "1fb03fgnzrvh22lw1jdg04pmyja5fib5n42rzwp5mhr829yvxkvp"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-data-frame
- sbcl-dexador
- sbcl-fare-csv
- sbcl-let-plus
- sbcl-yason))
- (native-inputs
- (list sbcl-clunit2))
- (home-page "https://lisp-stat.dev/docs/manuals/data-frame/";)
- (synopsis "Read data to and from data frames")
- (description "This package provides tools for manipulating data
-in files using data frames.")
- (license license:ms-pl))))
+ (list sbcl-cxml sbcl-parse-number sbcl-cl-ppcre sbcl-cl-yacc))
+ (home-page "https://github.com/sharplispers/xpath/";)
+ (synopsis "Implementation of the XML Path Language (XPath) Version 1.0")
+ (description
+ "This library is an implementation of the XML Path Language (XPath)
+Version 1.0.")
+ (license license:bsd-2))))
-(define-public cl-dfio
- (sbcl-package->cl-source-package sbcl-dfio))
+;; According to
+;; https://github.com/sharplispers/xpath/blob/master/doc/index.xml ECL is not
+;; supported.
+(define-public cl-xpath
+ (sbcl-package->cl-source-package sbcl-xpath))
-;; This depends on ecl-data-frame, which doesn't work yet.
-;; (define-public ecl-dfio
-;; (sbcl-package->ecl-package sbcl-dfio))
+(define-public sbcl-xsubseq
+ (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b")
+ (revision "1"))
+ (package
+ (name "sbcl-xsubseq")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/xsubseq";)
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1xz79q0p2mclf3sqjiwf6izdpb6xrsr350bv4mlmdlm6rg5r99px"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("xsubseq-test" "xsubseq")))
+ (native-inputs
+ (list sbcl-prove))
+ (home-page "https://github.com/fukamachi/xsubseq";)
+ (synopsis "Efficient way to use \"subseq\"s in Common Lisp")
+ (description
+ "XSubseq provides functions to be able to handle \"subseq\"s more
+effieiently.")
+ (license license:bsd-2))))
+
+(define-public cl-xsubseq
+ (sbcl-package->cl-source-package sbcl-xsubseq))
+
+(define-public ecl-xsubseq
+ (sbcl-package->ecl-package sbcl-xsubseq))
+
+(define-public sbcl-yason
+ (package
+ (name "sbcl-yason")
+ (version "0.8.4")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/phmarek/yason";)
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-yason" version))
+ (sha256
+ (base32 "0d22sw7nf2ygqm56ilybg7bza63cv43pc4184r8rvsjz2in37n51"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria sbcl-trivial-gray-streams))
+ (synopsis "Common Lisp JSON parser/encoder")
+ (description
+ "YASON is a Common Lisp library for encoding and decoding data in the
+JSON interchange format.")
+ (home-page "https://github.com/phmarek/yason";)
+ (license license:bsd-3)))
+
+(define-public cl-yason
+ (sbcl-package->cl-source-package sbcl-yason))
+
+(define-public ecl-yason
+ (sbcl-package->ecl-package sbcl-yason))
-(define-public sbcl-lisp-stat
- (let ((commit "357a0d2b5f68a5ff925776235c2b7455e12b78ba")
- (revision "0"))
+(define-public sbcl-yxorp
+ (let ((commit "c306898a467995e123a22316c9b79fcac442415b")
+ (revision "4"))
(package
- (name "sbcl-lisp-stat")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-yxorp")
+ (version (git-version "0.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Lisp-Stat/lisp-stat";)
+ (url "https://github.com/charJe/cl-yxorp";)
(commit commit)))
- (file-name (git-file-name "cl-lisp-stat" version))
+ (file-name (git-file-name "cl-yxorp" version))
(sha256
- (base32 "0qwlxrbwj884mr67sf6aj0zwrndv33aiiid4bqrkji41kjhqfcz5"))))
+ (base32 "0ll1s9w29yhhgqssgiw58fcapw4n040gkvpz4sxwv3q2v60rbidj"))))
(build-system asdf-build-system/sbcl)
- ;; https://github.com/Lisp-Stat/lisp-stat/issues/22
- (arguments (list #:tests? #f))
- (native-inputs (list sbcl-parachute))
(inputs
- (list sbcl-alexandria
- sbcl-alexandria-plus
- sbcl-array-operations
- sbcl-conduit-packages
- sbcl-data-frame
- sbcl-dexador
- sbcl-dfio
- sbcl-distributions
- sbcl-numerical-utilities
- sbcl-select
- sbcl-statistics))
- (home-page "https://lisp-stat.github.io/lisp-stat/";)
- (synopsis "Statistical Computing in Common Lisp")
- (description "This package provides a statistical computing
-environment for Common Lisp.")
- (license license:ms-pl))))
+ (list sbcl-chipz
+ sbcl-chunga
+ sbcl-cl+ssl
+ sbcl-binding-arrows
+ sbcl-cl-str
+ sbcl-usocket
+ sbcl-flexi-streams
+ sbcl-rutils
+ sbcl-salza2
+ sbcl-trivial-garbage))
+ (home-page "https://github.com/charje/cl-yxorp";)
+ (synopsis
+ "Reverse proxy server written in and configurable in Common Lisp")
+ (description
+ "This is a reverse proxy server written in and configurable in
+Common Lisp. It supports WebSocket, HTTP, HTTPS, HTTP to HTTPS
+redirecting, port and host forwarding configuration using a real programming
+language, HTTP header and body manipulation (also using a real programming
+language).")
+ (license license:agpl3))))
-(define-public cl-lisp-stat
- (sbcl-package->cl-source-package sbcl-lisp-stat))
+(define-public cl-yxorp
+ (sbcl-package->cl-source-package sbcl-yxorp))
-;; This depends on ecl-data-frame and ecl-dfio, which don't work yet.
-;; (define-public ecl-lisp-stat
-;; (sbcl-package->ecl-package sbcl-lisp-stat))
+(define-public ecl-yxorp
+ ;; Note that due to a bug in ECL this package does not build.
+ ;; The bug has already been fixed on the development branch,
+ ;; so this package will work work in the version after 21.2.1.
+ (sbcl-package->ecl-package sbcl-yxorp))
-(define-public sbcl-cl-modio
- (let ((commit "2fd288af27b574f448357fa6de4b42acf44e2f11")
+(define-public cl-yxorp-cli
+ (package
+ (inherit sbcl-yxorp)
+ (name "cl-yxorp-cli")
+ (build-system gnu-build-system)
+ (arguments
+ '(#:tests? #f
+ #:strip-binaries? #f
+ #:phases
+ (modify-phases %standard-phases
+ (delete 'configure)
+ (add-after 'unpack 'set-home
+ (lambda _
+ (setenv "HOME" "/tmp")))
+ (replace 'build
+ (lambda _
+ (invoke
+ "sbcl" "--noinform"
+ "--non-interactive"
+ "--no-userinit"
+ "--eval" "(require :asdf)"
+ "--eval" "(pushnew (uiop:getcwd) asdf:*central-registry*)"
+ "--load" "build.lisp")))
+ (replace 'install
+ (lambda* (#:key outputs #:allow-other-keys)
+ (let ((bin (string-append (assoc-ref outputs "out") "/bin")))
+ (mkdir-p bin)
+ (install-file "cl-yxorp" bin)))))))
+ (inputs (cons (list "sbcl" sbcl) (package-inputs sbcl-yxorp)))))
+
+(define-public sbcl-zip
+ ;; named branch is outdated
+ (let ((commit "688b1545dd7a4fe355556768bb03f8bd9b847a87")
(revision "1"))
(package
- (name "sbcl-cl-modio")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-zip")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/cl-modio/";)
+ (url "https://github.com/bluelisp/zip";)
(commit commit)))
(sha256
- (base32 "0hz87v81pi8kr2c7az30czpdf7v757lkzlsmdcc59p94pipca7m9"))
- (file-name (git-file-name "cl-modio" version))))
+ (base32 "0s08a6fq182fzsbfyvihqbdllq6gxcwkvphxnrd9wwz65dhg5y66"))
+ (file-name (git-file-name "cl-zip" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-zippy
- sbcl-jzon
- sbcl-cl-ppcre
- sbcl-drakma
- sbcl-documentation-utils
- sbcl-language-codes))
- (synopsis "Client library for the mod.io API")
- (description "This is a client library to interact with the
-\"mod.io\" (@url{https://mod.io}) platform to manage \"mods\" or extensions
-for games and other applications. It covers the full v1 API and includes
-convenience methods to make interacting with the API as well as syncing mods
-and so on easy.")
- (home-page "https://shinmera.github.io/cl-modio/";)
- (license license:zlib))))
+ (list sbcl-babel
+ sbcl-cl-fad
+ sbcl-salza2
+ sbcl-trivial-gray-streams))
+ (synopsis "Zip library written in Common Lisp")
+ (description "This package provide a Common Lisp library for .zip-file
+reading and writing.")
+ (home-page "https://zip.common-lisp.dev";)
+ (license (list license:bsd-2 license:llgpl)))))
-(define-public cl-modio
- (sbcl-package->cl-source-package sbcl-cl-modio))
+(define-public cl-zip
+ (sbcl-package->cl-source-package sbcl-zip))
-(define-public ecl-cl-modio
- (sbcl-package->ecl-package sbcl-cl-modio))
+(define-public ecl-zip
+ (sbcl-package->ecl-package sbcl-zip))
-(define-public sbcl-cl-steamworks
- (let ((commit "9d6a4de653a8cc256ae35e0298912b518aa92ba3")
+(define-public sbcl-zippy
+ (let ((commit "ed9bca591ded2ff27a9ac95d9a60827773a0e707")
(revision "1"))
(package
- (name "sbcl-cl-steamworks")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-zippy")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/cl-steamworks/";)
+ (url "https://github.com/Shinmera/zippy/";)
(commit commit)))
(sha256
- (base32 "1fzj3rlqw1kwdlmh0ga0y71p2n1adflcamzx4yp9kga552c1db5j"))
- (file-name (git-file-name "cl-steamworks" version))))
+ (base32 "16cvyyf2nzd9r3fcy4w6d5wh8n3x833wldmrxmnzd3k2xrkhzfl9"))
+ (file-name (git-file-name "zippy" version))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
+ (list sbcl-documentation-utils
+ sbcl-file-attributes
+ sbcl-pathname-utils
+ sbcl-alexandria
+ sbcl-nibbles
sbcl-babel
- sbcl-cffi
- sbcl-documentation-utils
- sbcl-float-features
- sbcl-trivial-features
- sbcl-trivial-garbage
- sbcl-trivial-gray-streams))
- (synopsis "Wrapper for the Valve SteamWorks API")
- (description "This is a wrapper library to allow you to interface with
-the Valve SteamWorks API.")
- (home-page "https://shinmera.github.io/cl-steamworks/";)
+ sbcl-3bz
+ sbcl-salza2))
+ (synopsis "Fast zip archive library")
+ (description "Zippy is a library for the PKWARE Zip archive format. It
+can read and write zip files. It features:
+
+@itemize
+@item archive inspection without extraction;
+@item Zip64 support;
+@item split archive support;
+@item PKWARE decryption;
+@item fast deflate decompression thanks to 3bz;
+@item operates on streams and vectors;
+@item can compress stream->stream;
+@item extensible for other encryption and compression mechanisms.
+@end itemize\n")
+ (home-page "https://shinmera.github.io/zippy/";)
(license license:zlib))))
-(define-public cl-steamworks
- (sbcl-package->cl-source-package sbcl-cl-steamworks))
+(define-public cl-zippy
+ (sbcl-package->cl-source-package sbcl-zippy))
+
+(define-public ecl-zippy
+ (sbcl-package->ecl-package sbcl-zippy))
+
+(define-public sbcl-zpb-exif
+ (package
+ (name "sbcl-zpb-exif")
+ (version "1.2.5")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/zpb-exif";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name "cl-zpb-exif" version))
+ (sha256
+ (base32 "0h1n36lfl8xn8rfyl5jxz9m8zlg0if2avmryas79f684yczrvdnd"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://xach.com/lisp/zpb-exif/";)
+ (synopsis "EXIF information extractor for Common Lisp")
+ (description
+ "This is a Common Lisp library to extract EXIF information from image
+files.")
+ (license license:bsd-2)))
+
+(define-public cl-zpb-exif
+ (sbcl-package->cl-source-package sbcl-zpb-exif))
+
+(define-public ecl-zpb-exif
+ (sbcl-package->ecl-package sbcl-zpb-exif))
+
+(define-public sbcl-zpb-ttf
+ (package
+ (name "sbcl-zpb-ttf")
+ (version "1.0.6")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/xach/zpb-ttf";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name "cl-zpb-ttf" version))
+ (sha256
+ (base32 "043xga76jms7dipcwnyh8lkj3gx66cvrkwhc728hjaf7axarvcmv"))))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/xach/zpb-ttf";)
+ (synopsis "TrueType font file access for Common Lisp")
+ (description
+ "ZPB-TTF is a TrueType font file parser that provides an interface for
+reading typographic metrics, glyph outlines, and other information from the
+file.")
+ (license license:bsd-2)))
+
+(define-public cl-zpb-ttf
+ (sbcl-package->cl-source-package sbcl-zpb-ttf))
+
+(define-public ecl-zpb-ttf
+ (sbcl-package->ecl-package sbcl-zpb-ttf))
+
+(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";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list 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-cl-steamworks
- (sbcl-package->ecl-package sbcl-cl-steamworks))
+(define-public ecl-zpng
+ (sbcl-package->ecl-package sbcl-zpng))
-(define-public sbcl-forge
- (let ((commit "012324e251d91436f4a610e2fe2eb50674c3c3ce")
- (revision "1"))
+(define-public sbcl-zr-utils
+ (let ((commit "e7eaffcb71811f6e1ab85fb15a079bcac4038eeb")
+ (revision "0"))
(package
- (name "sbcl-forge")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-zr-utils")
+ (version (git-version "0.0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/forge/";)
+ (url "https://gitlab.com/zombie-raptor/zr-utils.git";)
(commit commit)))
+ (file-name (git-file-name "cl-zr-utils" version))
(sha256
- (base32 "006vi2ihrn28pzrwa8b7axmv98bdaxzx7lacnh9pbacbjg3b7hb0"))
- (file-name (git-file-name "forge" version))))
+ (base32 "1nx388974wdc49h3simr1jnv4rw1mcs2llv4xai88qwjf4y66hsy"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("forge-support"
- "forge-communication"
- "forge")))
+ (native-inputs (list sbcl-parachute))
(inputs
- (list sbcl-alexandria
- sbcl-bordeaux-threads
- sbcl-cffi
- sbcl-cl-ppcre
- sbcl-closer-mop
- sbcl-documentation-utils
- sbcl-ironclad
- sbcl-pathname-utils
- sbcl-promise
- sbcl-usocket
- sbcl-verbose))
- (synopsis "General, modular build system")
- (description "Forge is a generic build system. Refer to documentation
-for the specific kind of project you're building to get the full picture.")
- (home-page "https://github.com/shinmera/forge";)
- (license license:zlib))))
+ (list sbcl-alexandria
+ sbcl-babel
+ sbcl-closer-mop
+ sbcl-cl-unicode
+ sbcl-trivial-gray-streams))
+ (arguments
+ (list #:tests? #f ; FIXME: Failing with new parachute.
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "zr-utils.asd"
+ (("\\(:parachute")
+ "(:parachute :zr-utils/tests/all")))))))
+ (synopsis "Common Lisp utilities library")
+ (description
+ "This is a Common Lisp utilities library originating from the
+Zombie Raptor game engine project.")
+ (home-page "https://gitlab.com/zombie-raptor/zr-utils";)
+ (license license:expat))))
-(define-public forge
- (sbcl-package->cl-source-package sbcl-forge))
+(define-public cl-zr-utils
+ (sbcl-package->cl-source-package sbcl-zr-utils))
-(define-public sbcl-maiden
- (let ((commit "164e8df1b513fcbf097315b51242d337c183a5ef")
+(define-public ecl-zr-utils
+ (sbcl-package->ecl-package sbcl-zr-utils))
+
+(define-public sbcl-zs3
+ (package
+ (name "sbcl-zs3")
+ (version "1.3.3")
+ (source
+ (origin
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/xach/zs3";)
+ (commit (string-append "release-" version))))
+ (file-name (git-file-name "zs3" version))
+ (sha256
+ (base32 "186v95wgsj2hkxdw2jl9x1w4fddjclp7arp0rrd9vf5ly8h8sbf3"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-drakma
+ sbcl-alexandria
+ sbcl-cxml
+ sbcl-ironclad
+ sbcl-puri
+ sbcl-cl-base64))
+ (synopsis "Work with Amazon S3 and Amazon CloudFront from Common Lisp")
+ (description "This is ZS3, a library for working with Amazon's Simple
Storage
+Service (S3) and CloudFront service from Common Lisp.")
+ (home-page "https://github.com/xach/zs3";)
+ (license license:bsd-2)))
+
+(define-public cl-zs3
+ (sbcl-package->cl-source-package sbcl-zs3))
+
+(define-public ecl-zs3
+ (sbcl-package->ecl-package sbcl-zs3))
+
+(define-public sbcl-zsort
+ (let ((commit "f6724a6fff7662a942195cedb0d7f00da59c74ed")
(revision "1"))
(package
- (name "sbcl-maiden")
- (version (git-version "3.1.0" revision commit))
+ (name "sbcl-zsort")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/maiden/";)
+ (url "https://github.com/jorgetavares/zsort";)
(commit commit)))
+ (file-name (git-file-name "cl-zsort" version))
(sha256
- (base32 "1m16qi019cmfpfs6538hc4qsplpb8nl9ly1qlckgfxgjag0z3wdr"))
- (file-name (git-file-name "maiden" version))))
+ (base32 "1vyklyh99712zsll4qi0m4mm8yb1nz04403vl8i57bjv5p5max49"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("maiden"
- "maiden-commands"
- "maiden-networking"
- "maiden-client-entities"
- "maiden-irc"
- "maiden-silly")))
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-bordeaux-threads
- sbcl-cl-base64
- sbcl-cl+ssl
- sbcl-closer-mop
- sbcl-deeds
- sbcl-documentation-utils
- sbcl-drakma
- sbcl-form-fiddle
- sbcl-jsown
- sbcl-lambda-fiddle
- sbcl-lquery
- sbcl-pathname-utils
- sbcl-trivial-garbage
- sbcl-trivial-indent
- sbcl-ubiquitous
- sbcl-usocket
- sbcl-uuid
- sbcl-verbose))
- (synopsis "Modern and extensible chat bot framework")
- (description "Maiden is a collection of systems to help you build
-applications and libraries that interact with chat servers. It can help you
-build a chat bot, or a general chat client. It also offers a variety of parts
-that should make it much easier to write a client for a new chat protocol.")
- (home-page "http://shirakumo.github.io/maiden/";)
- (license license:zlib))))
+ (list sbcl-alexandria))
+ (home-page "https://github.com/jorgetavares/zsort";)
+ (synopsis "Collection of portable sorting algorithms in Common Lisp")
+ (description
+ "@code{zsort} is a collection of portable sorting algorithms. Common
+Lisp provides the @code{sort} and @code{stable-sort} functions but these can
+have different algorithms implemented according to each implementation. Also,
+the standard sorting functions might not be the best for a certain situations.
+This library aims to provide developers with more options.")
+ (license license:expat))))
-(define-public maiden
- (sbcl-package->cl-source-package sbcl-maiden))
+(define-public cl-zsort
+ (sbcl-package->cl-source-package sbcl-zsort))
-(define-public sbcl-speechless
- (let ((commit "50e9b03bdfc8a3bc0836a650d92de47b51c39834")
+(define-public ecl-zsort
+ (sbcl-package->ecl-package sbcl-zsort))
+
+(define-public sbcl-zstd
+ (let ((commit "134f058eee11512cf772a8d5b64364acf56a10b8")
(revision "1"))
(package
- (name "sbcl-speechless")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-zstd")
+ (version (git-version "2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/speechless/";)
+ (url "https://codeberg.org/glv/cl-zstd";)
(commit commit)))
+ (file-name (git-file-name "cl-zstd" version))
(sha256
- (base32 "1k0kc2l98jyv04l48xnj38qwpddan80c7m41srjld64jkna0fhas"))
- (file-name (git-file-name "speechless" version))))
+ (base32 "1iqpi5v6fdm6xxc9l8zhk6kcgl8hgxiwk1ki2yx2j3j4kfvqv8j9"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- (list sbcl-cl-markless
- sbcl-documentation-utils))
- (synopsis "Dialogue system language implementation")
- (description "This is a system implementing an advanced dialogue system
-that is capable of complex dialogue flow including choice trees and
-conditional branching. Speechless was first developed for the
-\"Kandria\" (@url{https://kandria.com}) game, and has since been separated and
-made public in the hopes that it may find use elsewhere or inspire other
-developers to build similar systems.
-
-Speechless is based on the
-\"Markless\" (@url{https://shirakumo.github.io/markless}) document standard
-for its syntax and makes use of Markless' ability to be extended to add
-additional constructs useful for dialogue systems.
-
-Speechless can compile dialogue from its base textual form into an efficient
-instruction set, which is then executed when the game is run. Execution of the
-dialogue is completely engine-agnostic, and only requires some simple
-integration with a client protocol to run.
-
-Thanks to Markless' extensibility, Speechless can also be further extended to
-include additional syntax and constructs that may be useful for your
-particular game.")
- (home-page "http://shirakumo.github.io/speechless/";)
- (license license:zlib))))
-
-(define-public speechless
- (sbcl-package->cl-source-package sbcl-speechless))
+ (list sbcl-cffi
+ sbcl-cl-octet-streams
+ (list zstd "lib")))
+ (arguments
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/libzstd.lisp"
+ (("libzstd\\.so")
+ (search-input-file inputs "/lib/libzstd.so"))))))))
+ (synopsis "Common Lisp library for Zstandard (de)compression")
+ (description
+ "This Common Lisp library provides functions for Zstandard
+compression/decompression using bindings to the libzstd C library.")
+ (home-page "https://codeberg.org/glv/cl-zstd";)
+ (license license:gpl3+))))
-(define-public ecl-speechless
- (sbcl-package->ecl-package sbcl-speechless))
+(define-public cl-zstd
+ (sbcl-package->cl-source-package sbcl-zstd))
-;;;
-;;; Avoid adding new packages to the end of this file. To reduce the chances
-;;; of a merge conflict, place them above by existing packages with similar
-;;; functionality or similar names.
-;;;
+(define-public ecl-zstd
+ (sbcl-package->ecl-package sbcl-zstd))