From 51966d1bae8d9c2d0e8cd4a9dfbc8b7cf7af18d9 Mon Sep 17 00:00:00 2001 From: Guillaume Le Vaillant Date: Sat, 25 May 2024 11:48:09 +0200 Subject: [PATCH] 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 | 55150 ++++++++++++++++++------------------ 1 file changed, 27574 insertions(+), 27576 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,6 +137,787 @@ #:use-module (srfi srfi-1) #:use-module (srfi srfi-19)) +(define-public sbcl-3b-bmfont + (let ((commit "332c2262705f161627fc18add0310451a42799af") + (revision "3")) + (package + (name "sbcl-3b-bmfont") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/3b/3b-bmfont/") + (commit commit))) + (file-name (git-file-name "cl-3b-bmfont" version)) + (sha256 + (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6")))) + (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") + (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)) + +(define-public cl-3b-bmfont + (sbcl-package->cl-source-package sbcl-3b-bmfont)) + +(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-3bmd") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/3b/3bmd") + (commit commit))) + (sha256 + (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-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 + "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-3bmd + (sbcl-package->cl-source-package sbcl-3bmd)) + +(define-public ecl-3bmd + (sbcl-package->ecl-package sbcl-3bmd)) + +(define-public sbcl-3bz + (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad") + (revision "1")) + (package + (name "sbcl-3bz") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/3b/3bz") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4")))) + (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") + (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.") + (license license:expat)))) + +(define-public cl-3bz + (sbcl-package->cl-source-package sbcl-3bz)) + +(define-public ecl-3bz + (sbcl-package->ecl-package sbcl-3bz)) + +(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-matrices + (let ((commit "b4f5a58299f8437fad2d77f0879c374e3430f4b5") + (revision "2")) + (package + (name "sbcl-3d-matrices") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/3d-matrices") + (commit commit))) + (file-name (git-file-name "cl-3d-matrices" version)) + (sha256 + (base32 "1s8b4zlmqwyplghs73riz1khf0c5sk64w6b12jd599091d5nr6sr")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) + (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") + (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)))) + +(define-public cl-3d-matrices + (sbcl-package->cl-source-package sbcl-3d-matrices)) + +(define-public ecl-3d-matrices + (sbcl-package->ecl-package sbcl-3d-matrices)) + +(define-public sbcl-3d-quaternions + (let ((commit "b79c15cca8d9c409216a6cee8ec9e182dcdec9e2") + (revision "0")) + (package + (name "sbcl-3d-quaternions") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/3d-quaternions") + (commit commit))) + (file-name (git-file-name "cl-3d-quaternions" version)) + (sha256 + (base32 "1mrq6yhb90mhvxdkg3fx58ci5yj5xlixbbzf1q6p76wyq40qjv76")))) + (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") + (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-3d-quaternions + (sbcl-package->cl-source-package sbcl-3d-quaternions)) + +;; 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-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 cl-3d-spaces + (sbcl-package->cl-source-package sbcl-3d-spaces)) + +(define-public ecl-3d-spaces + (sbcl-package->ecl-package sbcl-3d-spaces)) + +(define-public sbcl-3d-transforms + (let ((commit "1d44509387d0747cd0351e95a533eca609058632") + (revision "0")) + (package + (name "sbcl-3d-transforms") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/3d-transforms") + (commit commit))) + (file-name (git-file-name "cl-3d-transforms" version)) + (sha256 + (base32 "03pmv7dh1j6kl16ch6lnvxzjrld4jbr3jx8slzkiipgzdxg74pcx")))) + (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") + (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-3d-transforms + (sbcl-package->cl-source-package sbcl-3d-transforms)) + +;; 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-3d-vectors + (let ((commit "257969402864ac3859d77b981abf0aa5373c4e78") + (revision "2")) + (package + (name "sbcl-3d-vectors") + (version (git-version "3.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/3d-vectors") + (commit commit))) + (file-name (git-file-name "cl-3d-vectors" version)) + (sha256 + (base32 "0vmf7nycc49ydcy0dfs25cgs655kwjc6jcjvpwxw61jq4gl2fh7x")))) + (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") + (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)))) + +(define-public cl-3d-vectors + (sbcl-package->cl-source-package sbcl-3d-vectors)) + +(define-public ecl-3d-vectors + (sbcl-package->ecl-package sbcl-3d-vectors)) + +(define-public sbcl-40ants-doc + (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b") + (revision "0")) + (package + (name "sbcl-40ants-doc") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/40ants/doc") + (commit commit))) + (sha256 + (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 + 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 + "@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)))) + +(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-abstract-classes") + (version (git-version "1.7.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://bitbucket.org/eeeickythump/cl-abstract-classes") + (commit commit))) + (file-name (git-file-name "cl-abstract-classes" version)) + (sha256 + (base32 "06lby4i6xbbgs7kgb0f3fqybvyskyg6djhrf967lnysv7hn3zpg9")))) + (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") + (description + "This package provides Common Lisp extension to the MOP to allow +abstract, final and singleton classes.") + (license license:public-domain)))) + +(define-public ecl-abstract-classes + (sbcl-package->ecl-package sbcl-abstract-classes)) + +(define-public cl-abstract-classes + (sbcl-package->cl-source-package sbcl-abstract-classes)) + +(define-public sbcl-access + (let ((commit "a4f87fc1007f5c9a0a2abfddc1c23a77e87096f8") + (revision "1")) + (package + (name "sbcl-access") + (version (git-version "1.6.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AccelerationNet/access") + (commit commit))) + (file-name (git-file-name "cl-access" version)) + (sha256 + (base32 "0zdjqhb9rvnlq6nzmsp7372gi91k1rq9bz510m6hcki7g3r01iv5")))) + (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") + (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 ecl-access + (sbcl-package->ecl-package sbcl-access)) + +(define-public cl-access + (sbcl-package->cl-source-package sbcl-access)) + +(define-public sbcl-acclimation + (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5")) + (package + (name "sbcl-acclimation") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/robert-strandh/Acclimation") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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. + +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-acclimation + (sbcl-package->cl-source-package sbcl-acclimation)) + +(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-acl-compat") + (version (git-version "0.1.1" "1" 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)) + (sha256 + (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 + `(("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 + "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 cl-acl-compat + (sbcl-package->cl-source-package sbcl-acl-compat)) + +(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-adopt + (sbcl-package->cl-source-package sbcl-adopt)) + +(define-public ecl-adopt + (sbcl-package->ecl-package sbcl-adopt)) + +(define-public sbcl-agnostic-lizard + (let ((commit "fe1a1d7d80c8b56163754e0e5b3653fd750ad298") + (revision "2")) + (package + (name "sbcl-agnostic-lizard") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/mraskin/agnostic-lizard") + (commit commit))) + (file-name (git-file-name "cl-agnostic-lizard" version)) + (sha256 + (base32 "0amzshh6v3mp24j0h2cinv4zvdlg4kih04md5biakwhnmcw4j4pr")))) + (build-system asdf-build-system/sbcl) + (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. + +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-agnostic-lizard + (sbcl-package->cl-source-package sbcl-agnostic-lizard)) + +(define-public ecl-agnostic-lizard + (sbcl-package->ecl-package sbcl-agnostic-lizard)) + +(define-public sbcl-agutil + (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68")) + (package + (name "sbcl-agutil") + (version (git-version "0.0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/alex-gutev/agutil/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf")))) + (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)))) + +(define-public cl-agutil + (sbcl-package->cl-source-package sbcl-agutil)) + +(define-public ecl-agutil + (sbcl-package->ecl-package sbcl-agutil)) + +(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-alexandria") + (version (git-version "1.4" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/alexandria/alexandria.git") + (commit commit))) + (file-name (git-file-name "cl-alexandria" version)) + (sha256 + (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-rt)) + (synopsis "Collection of portable utilities for Common Lisp") + (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-alexandria-plus (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5") (revision "0")) @@ -171,414 +954,1203 @@ (define-public ecl-alexandria-plus (sbcl-package->ecl-package sbcl-alexandria-plus)) -(define-public sbcl-alexandria - (let ((commit "009b7e532071d9777bdbd63b82d776555da95916") - (revision "0")) +(define-public sbcl-alloy + (let ((commit "628974de537affb5b44ad548347f67c16efffcfc") + (revision "3")) (package - (name "sbcl-alexandria") - (version (git-version "1.4" revision commit)) + (name "sbcl-alloy") + (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/Shirakumo/alloy") (commit commit))) - (file-name (git-file-name "cl-alexandria" version)) + (file-name (git-file-name "cl-alloy" version)) (sha256 - (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9")))) + (base32 "0fx294qwxshgijss000pbjbnbwxqvxyw6p3mva36qljhbbkw2fxy")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-rt)) - (synopsis "Collection of portable utilities for Common Lisp") + (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 - "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))) - -(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-st-json - (let ((commit "4a0025bcc5b6921454822f1b9f38f697b4eeaf43") - (revision "0")) - (package - (name "sbcl-st-json") - (version (git-version "0.0.0" revision commit)) - (source - (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) - (home-page "https://marijnhaverbeke.nl/st-json/") - (synopsis "JSON 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).") + "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 cl-st-json - (sbcl-package->cl-source-package sbcl-st-json)) +(define-public cl-alloy + (sbcl-package->cl-source-package sbcl-alloy)) -(define-public ecl-st-json - (sbcl-package->ecl-package sbcl-st-json)) +(define-public ecl-alloy + (sbcl-package->ecl-package sbcl-alloy)) -(define-public sbcl-stdutils - (let ((commit "4a4e5a4036b815318282da5dee2a22825369137b") +(define-public sbcl-amb + (let ((commit "884bef69a1ea02f3b9deae0341e1a038ff31b896") (revision "0")) (package - (name "sbcl-stdutils") - (version (git-version "1.0" revision commit)) - (source + (name "sbcl-amb") + (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/phoe/amb") (commit commit))) - (file-name (git-file-name "cl-stdutils" version)) + (file-name (git-file-name "cl-amb" 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)))) + (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-stdutils - (sbcl-package->cl-source-package sbcl-stdutils)) +(define-public cl-amb + (sbcl-package->cl-source-package sbcl-amb)) -(define-public ecl-stdutils - (sbcl-package->ecl-package sbcl-stdutils)) +(define-public ecl-amb + (sbcl-package->ecl-package sbcl-amb)) -(define-public sbcl-langutils - (let ((commit "38beec7a82eeb35b0bfb0824a41d13ed94fc648b") - (revision "0")) - (package - (name "sbcl-langutils") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eslick/cl-langutils") - (commit commit))) - (file-name (git-file-name "cl-langutils" version)) - (sha256 - (base32 "15y9x5wkg3fqndc04w2sc650fnwimxp4gjgpv9xvvdm9x4v433x6")))) - (build-system asdf-build-system/sbcl) - (arguments '(#:tests? #f)) ; There are no tests. - (inputs - (list sbcl-stdutils - sbcl-s-xml-rpc)) - (home-page "https://langutils.common-lisp.dev/") - (synopsis "Common Lisp natural language processing toolkit") - (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)))) - -(define-public cl-langutils - (sbcl-package->cl-source-package sbcl-langutils)) - -(define-public ecl-langutils - (sbcl-package->ecl-package sbcl-langutils)) - -(define-public sbcl-hash-set - (let ((commit "6feb20de457f14e24a83815be1097aa02cca5986") - (revision "0")) - (package - (name "sbcl-hash-set") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/samebchase/hash-set") - (commit commit))) - (file-name (git-file-name "cl-hash-set" version)) - (sha256 - (base32 "0a966y9yfarhmki4wwzg371ziaygnp13yc6r13w9zz327fkhz8na")))) - (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)))) - -(define-public cl-hash-set - (sbcl-package->cl-source-package sbcl-hash-set)) - -(define-public ecl-hash-set - (sbcl-package->ecl-package sbcl-hash-set)) - -(define-public sbcl-duologue - (let ((commit "ea1ada244a81da65f85b548823c9a6d7c9c145e1") - (revision "0")) - (package - (name "sbcl-duologue") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/duologue") - (commit commit))) - (file-name (git-file-name "cl-duologue" version)) - (sha256 - (base32 "1yg7f27im9h0m6jihcay1p7alfhzm9hafwm5dw5hsyacy8f2cwk2")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-stefil)) - (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") - (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 +(define-public sbcl-anaphora (package - (name "sbcl-alea") - (version "1.0") + (name "sbcl-anaphora") + (version "0.9.8") (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)) + (url "https://github.com/tokenrove/anaphora") + (commit version))) (sha256 - (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz")))) + (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b")) + (file-name (git-file-name "cl-anaphora" version)))) (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-fiveam)) - (synopsis "Dice rolling library") + (native-inputs + (list sbcl-rt)) + (synopsis "The anaphoric macro collection from Hell") (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))) + "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-alea - (sbcl-package->cl-source-package sbcl-alea)) +(define-public cl-anaphora + (sbcl-package->cl-source-package sbcl-anaphora)) -(define-public ecl-alea - (sbcl-package->ecl-package sbcl-alea)) +(define-public ecl-anaphora + (sbcl-package->ecl-package sbcl-anaphora)) -(define-public sbcl-cf - (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e") - (revision "2")) +;;; 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-cf") + (name "sbcl-antik-base") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/antik/antik.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km")))) + (build-system asdf-build-system/sbcl) + (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 cl-antik-base + (sbcl-package->cl-source-package sbcl-antik-base)) + +(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-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-antik + (sbcl-package->cl-source-package sbcl-antik)) + +(define-public sbcl-april + (let ((commit "bdd74f168ec82f28fe4ab692f2c0af39441a5701") + (revision "3")) + (package + (name "sbcl-april") (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/cl-cf") + (url "https://github.com/phantomics/april") (commit commit))) - (file-name (git-file-name "cl-cf" version)) + (file-name (git-file-name "cl-april" version)) (sha256 - (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig")))) + (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-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+)))) + (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") + (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)))) -(define-public cl-cf - (sbcl-package->cl-source-package sbcl-cf)) +(define-public cl-april + (sbcl-package->cl-source-package sbcl-april)) -(define-public ecl-cf - (sbcl-package->ecl-package sbcl-cf)) +(define-public ecl-april + (sbcl-package->ecl-package sbcl-april)) -(define-public sbcl-bubble-operator-upwards - (let ((commit "846275a318b960de81b62caecb1e31930f70aef6") +(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-archive + (sbcl-package->cl-source-package sbcl-archive)) + +(define-public ecl-archive + (sbcl-package->ecl-package sbcl-archive)) + +(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 + ;; #: + ;; Sorry, No walker for the special operater DECLARE defined. + ;; + ;; Backtrace for: # + ;; 0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK # # :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 ecl-arnesi + (sbcl-package->ecl-package sbcl-arnesi)) + +(define-public cl-arnesi + (sbcl-package->cl-source-package sbcl-arnesi)) + +(define-public sbcl-array-operations + (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b") (revision "0")) (package - (name "sbcl-bubble-operator-upwards") - (version (git-version "1.0" 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/Hexstream/bubble-operator-upwards") + (url "https://github.com/bendudson/array-operations") (commit commit))) - (file-name (git-file-name "cl-bubble-operator-upwards" version)) + (file-name (git-file-name "array-operations" version)) (sha256 - (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi")))) + (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 cl-array-operations + (sbcl-package->cl-source-package sbcl-array-operations)) + +(define-public ecl-array-operations + (sbcl-package->ecl-package sbcl-array-operations)) + +(define-public sbcl-array-utils + (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834") + (revision "0")) + (package + (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/array-utils") + (commit commit))) + (file-name (git-file-name "cl-array-utils" version)) + (sha256 + (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az")))) (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)) + (synopsis "Tiny collection of array and vector utilities for Common Lisp") (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)))) + "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-bubble-operator-upwards - (sbcl-package->cl-source-package sbcl-bubble-operator-upwards)) +(define-public cl-array-utils + (sbcl-package->cl-source-package sbcl-array-utils)) -(define-public ecl-bubble-operator-upwards - (sbcl-package->ecl-package sbcl-bubble-operator-upwards)) +(define-public ecl-array-utils + (sbcl-package->ecl-package sbcl-array-utils)) -(define-public sbcl-map-bind - (let ((commit "532d55d93540c632e22b2cd264b5daa5f9d3d900") +(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-map-bind") + (name "sbcl-arrow-macros") + (version (git-version "0.2.7" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hipeta/arrow-macros") + (commit commit))) + (file-name (git-file-name "arrow-macros" version)) + (sha256 + (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4")))) + (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") + (description + "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and diamond wands +in swiss-arrows.") + (license license:expat)))) + +(define-public cl-arrow-macros + (sbcl-package->cl-source-package sbcl-arrow-macros)) + +(define-public ecl-arrow-macros + (sbcl-package->ecl-package sbcl-arrow-macros)) + +(define-public sbcl-arrows + (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382") + (revision "0")) + (package + (name "sbcl-arrows") + (version (git-version "0.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.com/Harleqin/arrows.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy")))) + (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)))) + +(define-public cl-arrows + (sbcl-package->cl-source-package sbcl-arrows)) + +(define-public ecl-arrows + (sbcl-package->ecl-package sbcl-arrows)) + +(define-public sbcl-asdf-finalizers + (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0") + (revision "1")) + (package + (name "sbcl-asdf-finalizers") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public cl-asdf-finalizers + (sbcl-package->cl-source-package sbcl-asdf-finalizers)) + +(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-asd-generator") (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Hexstream/map-bind") + (url "https://github.com/phoe/asd-generator") (commit commit))) - (file-name (git-file-name "cl-map-bind" version)) (sha256 - (base32 "0hfy65xyqc4zqfncn11pp3hjjkdz7m91cynnv91s3lgcl3kffva0")))) + (base32 "0yiybl7b9x1f85v0drj0yw9821y3yfhya4n6gycnv5vvx6jp9by4")) + (file-name (git-file-name "cl-asd-generator" commit)))) (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") + (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 - "@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)))) + "This package provides an automatic generator for ASDF's .asd files.") + (license license:gpl3+)))) -(define-public cl-map-bind - (sbcl-package->cl-source-package sbcl-map-bind)) +(define-public cl-asd-generator + (sbcl-package->cl-source-package sbcl-asd-generator)) -(define-public ecl-cl-map-bind - (sbcl-package->ecl-package sbcl-map-bind)) +(define-public ecl-asd-generator + (sbcl-package->ecl-package sbcl-asd-generator)) -(define-public sbcl-positional-lambda - (let ((commit "a43a7bb4ef6faa277e6a7440ec9839711c4b9d28") +(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/gwkkwg/asdf-system-connections") + (commit commit))) + (file-name (git-file-name "cl-asdf-system-connections" version)) + (sha256 + (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y")))) + (build-system asdf-build-system/sbcl) + (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-asdf-system-connections + (sbcl-package->cl-source-package sbcl-asdf-system-connections)) + +(define-public ecl-asdf-system-connections + (sbcl-package->ecl-package sbcl-asdf-system-connections)) + +(define-public sbcl-aserve + ;; There does not seem to be proper releases. + (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5") + (revision "2")) + (package + (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 cl-aserve + (sbcl-package->cl-source-package sbcl-aserve)) + +(define-public sbcl-assoc-utils + (let ((commit "74af16a3c0f10ad35e406167de02984744fc7854") + (revision "1")) + (package + (name "sbcl-assoc-utils") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/assoc-utils") + (commit commit))) + (file-name (git-file-name "cl-assoc-utils" version)) + (sha256 + (base32 "1yac1v7zmdxj0p6rvwrrhyqvy7yjfhmqbchkwqhhr89gpjvvaick")))) + (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") + (description + "@code{assoc-utils} provides utilities for manipulating association +lists in Common Lisp.") + (license license:public-domain)))) + +(define-public cl-assoc-utils + (sbcl-package->cl-source-package sbcl-assoc-utils)) + +(define-public ecl-assoc-utils + (sbcl-package->ecl-package sbcl-assoc-utils)) + +(define-public sbcl-atomichron + (let ((commit "5b3578bbad8c37ab559e56924d98c373efe11de5") (revision "0")) (package - (name "sbcl-positional-lambda") - (version (git-version "2.0" revision commit)) + (name "sbcl-atomichron") + (version (git-version "0.0.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")))) + (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 cl-atomichron + (sbcl-package->cl-source-package sbcl-atomichron)) + +(define-public ecl-atomichron + (sbcl-package->ecl-package sbcl-atomichron)) + +(define-public sbcl-atomics + ;; No release in years. + (let ((commit "b7477024894e322bff9c85e6d81e5e8d1d4eae59") + (revision "2")) + (package + (name "sbcl-atomics") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/atomics") + (commit commit))) + (file-name (git-file-name "cl-atomics" version)) + (sha256 + (base32 "1ah6fgvfva0axnhj4sp1qy6gjyw41fkhpnv998di0wbp6hls8j39")))) + (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") + (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)))) + +(define-public cl-atomics + (sbcl-package->cl-source-package sbcl-atomics)) + +(define-public ecl-atomics + (sbcl-package->ecl-package sbcl-atomics)) + +(define-public sbcl-authentic + (let ((commit "4e9194dda227b98f56dda1c2a2480efcc2d1f973") + (revision "2")) + (package + (name "sbcl-authentic") + (version (git-version "0.1.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/charje/cl-authentic") + (commit commit))) + (file-name (git-file-name "cl-authentic" version)) + (sha256 + (base32 "0ncsxrybnx0pjsndv3j8w4lphlpcsld8sxg3c5b46fb3a8nd4ssf")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-parachute)) + (list sbcl-fiveam)) (inputs - (list sbcl-map-bind)) - (home-page "https://www.hexstreamsoft.com/libraries/positional-lambda/") - (synopsis "Macro favouring positional references over naming") + (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 ecl-authentic + (sbcl-package->ecl-package sbcl-authentic)) + +(define-public cl-authentic + (sbcl-package->cl-source-package sbcl-authentic)) + +(define-public sbcl-babel + ;; No release since 2014. + (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9") + (revision "3")) + (package + (name "sbcl-babel") + (version (git-version "0.5.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/cl-babel/babel") + (commit commit))) + (file-name (git-file-name "cl-babel" version)) + (sha256 + (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380")))) + (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-binary-types + (let ((commit "9ec42042a50403961c08179a892ae3de725b1d7a")) + (package + (name "sbcl-binary-types") + (version (git-version "1.2" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/frodef/binary-types/") + (commit commit))) + (file-name (git-file-name "binary-types" version)) + (sha256 + (base32 "0kp4xwblfxh7gmgqc38k9xzrqlcr0q1jm5167ma1pajdxd3182j8")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/frodef/binary-types/") + (synopsis "Read and write binary records for Common Lisp") (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)))) + "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-positional-lambda - (sbcl-package->cl-source-package sbcl-positional-lambda)) +(define-public cl-binary-types + (sbcl-package->cl-source-package sbcl-binary-types)) -(define-public ecl-cl-positional-lambda - (sbcl-package->ecl-package sbcl-positional-lambda)) +(define-public ecl-binary-types + (sbcl-package->ecl-package sbcl-binary-types)) + +(define-public sbcl-binascii + (let ((commit "0fb0a9e5773148fd04d50efef08c1cc10f6fc487") + (revision "1")) + (package + (name "sbcl-binascii") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/binascii") + (commit commit))) + (file-name (git-file-name "cl-binascii" 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\")")))))) + (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") + (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)))) + +(define-public cl-binascii + (sbcl-package->cl-source-package sbcl-binascii)) + +(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 + (method git-fetch) + (uri (git-reference + (url "https://github.com/phoe/binding-arrows") + (commit commit))) + (file-name (git-file-name "cl-binding-arrows" 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)))) + +(define-public ecl-binding-arrows + (sbcl-package->ecl-package sbcl-binding-arrows)) + +(define-public cl-binding-arrows + (sbcl-package->cl-source-package sbcl-binding-arrows)) + +(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 cl-binpack + (sbcl-package->cl-source-package sbcl-binpack)) + +(define-public ecl-binpack + (sbcl-package->ecl-package sbcl-binpack)) + +(define-public sbcl-bit-smasher + ;; No release. + (let ((commit "c2dcb3b5ec0e485484be681fe17c4e81e58790d9")) + (package + (name "sbcl-bit-smasher") + (version (git-version "1.0.2" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/thephoeron/bit-smasher/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0wjmwn06fjpw0rlpaksf3ab727p8fnzj58z7jajl3m0wqd4ii74w")))) + (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") + (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 cl-bit-smasher + (sbcl-package->cl-source-package sbcl-bit-smasher)) + +(define-public ecl-bit-smasher + (sbcl-package->ecl-package sbcl-bit-smasher)) + +(define-public sbcl-bknr-datastore + (let ((commit "c98d44f47cc88d19ff91ca3eefbd9719a8ace022") + (revision "1")) + (package + (name "sbcl-bknr-datastore") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hanshuebner/bknr-datastore") + (commit commit))) + (file-name (git-file-name "bknr-datastore" version)) + (sha256 + (base32 "1vi3w65fnczqvswkm381n6liqfrzjrg40y698qvj7skj28dm5vrm")))) + (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") + (description + "BKNR.DATASTORE is an in-memory CLOS based database with transactions +for Common Lisp.") + (license license:bsd-0)))) + +(define-public cl-bknr-datastore + (sbcl-package->cl-source-package sbcl-bknr-datastore)) + +;; 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-blackbird + (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8") + (revision "1")) + (package + (name "sbcl-blackbird") + (version (git-version "0.5.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/orthecreedence/blackbird") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c")))) + (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/") + (license license:expat)))) + +(define-public cl-blackbird + (sbcl-package->cl-source-package sbcl-blackbird)) + +(define-public ecl-blackbird + (sbcl-package->ecl-package sbcl-blackbird)) + +(define-public sbcl-bobbin + (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce") + (revision "0")) + (package + (name "sbcl-bobbin") + (version (git-version "1.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sjl/bobbin") + (commit commit))) + (file-name (git-file-name "cl-bobbin" version)) + (sha256 + (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm")))) + (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") + (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)))) + +(define-public cl-bobbin + (sbcl-package->cl-source-package sbcl-bobbin)) + +(define-public ecl-bobbin + (sbcl-package->ecl-package sbcl-bobbin)) + +(define-public sbcl-bodge-blobs-support + (let ((commit "c5034ca5f4fc3a44dbadeba215a09afd59a404b0") + (revision "1")) + (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-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)))) + +(define-public ecl-bodge-math + (sbcl-package->ecl-package sbcl-bodge-math)) + +(define-public cl-bodge-math + (sbcl-package->cl-source-package sbcl-bodge-math)) + +(define-public sbcl-bodge-queue + (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a") + (revision "0")) + (package + (name "sbcl-bodge-queue") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/borodust/bodge-queue") + (commit commit))) + (file-name (git-file-name "bodge-queue" version)) + (sha256 + (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr")))) + (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)))) + +(define-public cl-bodge-queue + (sbcl-package->cl-source-package sbcl-bodge-queue)) + +(define-public ecl-bodge-queue + (sbcl-package->ecl-package sbcl-bodge-queue)) (define-public sbcl-bodge-utilities (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f") @@ -613,1146 +2185,11 @@ are provided.") 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") - (revision "0")) - (package - (name "sbcl-meta") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/frideau/meta") - (commit commit))) - (file-name (git-file-name "cl-meta" version)) - (sha256 - (base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy")))) - (build-system asdf-build-system/sbcl) - (inputs - (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 recursive-descent parser DSL for Common Lisp. -It's intended as a simpler alternative to parser generators.") - (license license:bsd-2)))) - -(define-public cl-meta - (sbcl-package->cl-source-package sbcl-meta)) - -(define-public ecl-meta - (sbcl-package->ecl-package sbcl-meta)) - -(define-public sbcl-cl-smtp - (let ((commit "ed47d326fad867ee11323fa3a0f307b5d40e8f2b") - (revision "0")) - (package - (name "sbcl-cl-smtp") - (version (git-version "20191031.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp") - (commit commit))) - (file-name (git-file-name "cl-smtp" version)) - (sha256 - (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0")))) - (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)))) - -(define-public cl-smtp - (sbcl-package->cl-source-package sbcl-cl-smtp)) - -(define-public ecl-cl-smtp - (sbcl-package->ecl-package sbcl-cl-smtp)) - -(define-public sbcl-clavier - (let ((commit "9b1424eaad131e114a45b400784079124b5e2321") - (revision "1")) - (package - (name "sbcl-clavier") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/clavier") - (commit commit))) - (file-name (git-file-name "cl-clavier" version)) - (sha256 - (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y")))) - (build-system asdf-build-system/sbcl) - (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-clavier - (sbcl-package->cl-source-package sbcl-clavier)) - -(define-public ecl-clavier - (sbcl-package->ecl-package sbcl-clavier)) - -(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-inotify - (sbcl-package->cl-source-package sbcl-cl-inotify)) - -(define-public ecl-cl-inotify - (sbcl-package->ecl-package sbcl-cl-inotify)) - -(define-public sbcl-file-notify - (let ((commit "f12dc2f2aae5fee13355cd93a8cae0c4c412b76d") - (revision "0")) - (package - (name "sbcl-file-notify") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/file-notify") - (commit commit))) - (file-name (git-file-name "cl-file-notify" version)) - (sha256 - (base32 "0788d98rqm1krl8nbfh8qshvyf6g336i9bqrdhkx06cfvbh0wcny")))) - (build-system asdf-build-system/sbcl) - (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-file-notify - (sbcl-package->cl-source-package sbcl-file-notify)) - -(define-public ecl-file-notify - (sbcl-package->ecl-package sbcl-file-notify)) - -(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 cl-file-select - (sbcl-package->cl-source-package sbcl-file-select)) - -(define-public ecl-file-select - (sbcl-package->ecl-package sbcl-file-select)) - -(define-public sbcl-bodge-queue - (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a") - (revision "0")) - (package - (name "sbcl-bodge-queue") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/borodust/bodge-queue") - (commit commit))) - (file-name (git-file-name "bodge-queue" version)) - (sha256 - (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr")))) - (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)))) - -(define-public cl-bodge-queue - (sbcl-package->cl-source-package sbcl-bodge-queue)) - -(define-public ecl-bodge-queue - (sbcl-package->ecl-package sbcl-bodge-queue)) - -(define-public sbcl-list-named-class - (let ((commit "2955791a7469131bcab42d800883f27993ee1d62") - (revision "0")) - (package - (name "sbcl-list-named-class") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/phoe/list-named-class") - (commit commit))) - (file-name (git-file-name "cl-list-named-class" version)) - (sha256 - (base32 "1bdi9q9wvfj66jji3n9hpjrj9271ial2awsb0xw80bmy6wqbg8kq")))) - (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.") - (license license:expat)))) - -(define-public cl-list-named-class - (sbcl-package->cl-source-package sbcl-list-named-class)) - -(define-public ecl-list-named-class - (sbcl-package->ecl-package sbcl-list-named-class)) - -(define-public sbcl-golden-utils - (let ((commit "e43914ad2bdb0c8e1b1f10ef591aafc3c55b89e7") - (revision "4")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name "cl-golden-utils" version)) - (sha256 - (base32 "09vq29wjr3x7h3fshwxg8h1psy4p73yl61cjljarpqjhsgz7lmbp")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria)) - (synopsis "Common Lisp utility library") - (description - "This is a Common Lisp library providing various utilities.") - (license license:expat)))) - -(define-public ecl-golden-utils - (sbcl-package->ecl-package sbcl-golden-utils)) - -(define-public cl-golden-utils - (sbcl-package->cl-source-package sbcl-golden-utils)) - -(define-public sbcl-asdf-finalizers - (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0") - (revision "1")) - (package - (name "sbcl-asdf-finalizers") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public ecl-asdf-finalizers - (sbcl-package->ecl-package sbcl-asdf-finalizers)) - -(define-public cl-asdf-finalizers - (sbcl-package->cl-source-package sbcl-asdf-finalizers)) - -(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/gwkkwg/asdf-system-connections") - (commit commit))) - (file-name (git-file-name "cl-asdf-system-connections" version)) - (sha256 - (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y")))) - (build-system asdf-build-system/sbcl) - (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 ecl-asdf-system-connections - (sbcl-package->ecl-package sbcl-asdf-system-connections)) - -(define-public cl-asdf-system-connections - (sbcl-package->cl-source-package sbcl-asdf-system-connections)) - -(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. - -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 ecl-net.didierverna.asdf-flv - (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv)) - -(define-public sbcl-command-line-arguments - (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe") - (revision "1")) - (package - (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/fare/command-line-arguments") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq")))) - (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)))) - -(define-public ecl-command-line-arguments - (sbcl-package->ecl-package sbcl-command-line-arguments)) - -(define-public cl-command-line-arguments - (sbcl-package->cl-source-package sbcl-command-line-arguments)) - -(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 ecl-adopt - (sbcl-package->ecl-package sbcl-adopt)) - -(define-public cl-adopt - (sbcl-package->cl-source-package sbcl-adopt)) - -(define-public sbcl-clingon - (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d") - (revision "0")) - (package - (name "sbcl-clingon") - (version (git-version "0.5.0" revision commit)) - (source - (origin - (method git-fetch) - (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) - (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") - (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)))) - -(define-public cl-clingon - (sbcl-package->cl-source-package sbcl-clingon)) - -(define-public ecl-clingon - (sbcl-package->ecl-package sbcl-clingon)) - -(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 cl-command-line-args - (sbcl-package->cl-source-package sbcl-command-line-args)) - -(define-public ecl-command-line-args - (sbcl-package->ecl-package sbcl-command-line-args)) - -(define-public sbcl-cl-irc - (let ((commit "963823537c7bfcda2edd4c44d172192da6722175") - (revision "0")) - (package - (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). - -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-irc - (sbcl-package->cl-source-package sbcl-cl-irc)) - -(define-public ecl-cl-irc - (sbcl-package->ecl-package sbcl-cl-irc)) - -(define-public sbcl-coleslaw - (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40") - (revision "0")) - (package - (name "sbcl-coleslaw") - (version (git-version "0.9.7" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/coleslaw-org/coleslaw") - (commit commit))) - (file-name (git-file-name "cl-coleslaw" version)) - (sha256 - (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws")))) - (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)) - (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 - "Coleslaw is a static site generator written in Common Lisp.") - (license license:bsd-2)))) - -(define-public cl-coleslaw - (sbcl-package->cl-source-package sbcl-coleslaw)) - -(define-public ecl-coleslaw - (sbcl-package->ecl-package sbcl-coleslaw)) - -(define-public sbcl-cl-all - (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace") - (revision "0")) - (package - (name "sbcl-cl-all") - (version (git-version "1.0.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)) - (sha256 - (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp")))) - (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.") - (license license:zlib)))) - -(define-public cl-all - (sbcl-package->cl-source-package sbcl-cl-all)) - -(define-public sbcl-tripod - (let ((commit "b019a27cd7eb895870f84b0eb6c3edc5d7b05928") - (revision "1")) - (package - (name "sbcl-tripod") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/aartaka/tripod") - (commit commit))) - (file-name (git-file-name "cl-tripod" version)) - (sha256 - (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-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 - "Tripod is a Common Lisp web server aiming to ease plain text, HTML, -and Gopher website hosting.") - (license license:bsd-2)))) - -(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-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-trivial-timeout - (let ((commit "e70d9b4f7caeab83ea6ac50d724470fe49561e66") - (revision "2")) - (package - (name "sbcl-trivial-timeout") - (version (git-version "0.1.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/trivial-timeout") - (commit commit))) - (file-name (git-file-name "trivial-timeout" version)) - (sha256 - (base32 "0s8z9aj6b3kv21yiyk13cjylzf5zlnw9v86vcff477m1gk9yddjs")))) - (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") - (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))) - -(define-public cl-bordeaux-threads - (sbcl-package->cl-source-package sbcl-bordeaux-threads)) - -(define-public ecl-bordeaux-threads - (sbcl-package->ecl-package sbcl-bordeaux-threads)) - -(define-public sbcl-trivial-gray-streams - (let ((revision "1") - (commit "2b3823edbc78a450db4891fd2b566ca0316a7876")) - (package - (name "sbcl-trivial-gray-streams") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/trivial-gray-streams/trivial-gray-streams") - (commit commit))) - (sha256 - (base32 "1hipqwwd5ylskybd173rvlsk7ds4w4nq1cmh9952ivm6dgh7pwzn")) - (file-name (git-file-name "cl-trivial-gray-streams" version)))) - (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)))) - -(define-public cl-trivial-gray-streams - (sbcl-package->cl-source-package sbcl-trivial-gray-streams)) - -(define-public ecl-trivial-gray-streams - (sbcl-package->ecl-package sbcl-trivial-gray-streams)) - -(define-public sbcl-flexi-streams - (let ((commit "74a1027311371a57258eba1bc908e050f5702277") - (revision "0")) - (package - (name "sbcl-flexi-streams") - (version (git-version "1.0.19" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/flexi-streams") - (commit commit))) - (file-name (git-file-name "cl-flexi-streams" version)) - (sha256 - (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-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-flexi-streams - (sbcl-package->cl-source-package sbcl-flexi-streams)) - -(define-public ecl-flexi-streams - (sbcl-package->ecl-package sbcl-flexi-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-select - (let ((commit "df7920fc451b6d15345040ce4a3ee1ea2818ab1a") - (revision "0")) - (package - (name "sbcl-select") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/select") - (commit commit))) - (file-name (git-file-name "cl-select" version)) - (sha256 - (base32 "0bhpvfqp7n33pia4y62qi31bx86gjl2nxjy529rfawac57c9rxv3")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-anaphora - sbcl-let-plus)) - (native-inputs - (list sbcl-fiveam)) - (home-page "https://lisp-stat.github.io/select/") - (synopsis "Library for taking slices from array-like objects") - (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))) - -(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-one-more-re-nightmare - (let ((commit "5b0b02e59f90964baf5737abd13300fa82f27667") - (revision "1")) - (package - (name "sbcl-one-more-re-nightmare") - (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") - (commit commit))) - (file-name (git-file-name "cl-one-more-re-nightmare" version)) - (sha256 - (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-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-parse - (let ((commit "2351ee78acac065fcf10b8713d3f404e2e910786") - (revision "1")) - (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 ecl-bodge-utilities + (sbcl-package->ecl-package sbcl-bodge-utilities)) (define-public sbcl-boost-json (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47") @@ -1790,6 +2227,37 @@ expression library for Common Lisp. It is a non-recursive, backtracing VM.") (define-public ecl-boost-json (sbcl-package->ecl-package sbcl-boost-json)) +(define-public sbcl-boost-lexer + (let ((commit "139ca9e9580f890698deec05061e495376b7735a") + (revision "0")) + (package + (name "sbcl-boost-lexer") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/cl-boost/lexer") + (commit commit))) + (file-name (git-file-name "cl-boost-lexer" version)) + (sha256 + (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4")))) + (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") + (description + "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of +BOOST-RE.") + (license license:asl2.0)))) + +(define-public cl-boost-lexer + (sbcl-package->cl-source-package sbcl-boost-lexer)) + +(define-public ecl-boost-lexer + (sbcl-package->ecl-package sbcl-boost-lexer)) + (define-public sbcl-boost-parse (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50") (revision "0")) @@ -1849,1472 +2317,238 @@ expression library for Common Lisp. It is a non-recursive, backtracking VM.") (define-public ecl-boost-re (sbcl-package->ecl-package sbcl-boost-re)) -(define-public sbcl-boost-lexer - (let ((commit "139ca9e9580f890698deec05061e495376b7735a") +(define-public sbcl-bordeaux-fft + (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e") (revision "0")) (package - (name "sbcl-boost-lexer") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cl-boost/lexer") - (commit commit))) - (file-name (git-file-name "cl-boost-lexer" version)) - (sha256 - (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4")))) - (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") - (description - "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of -BOOST-RE.") - (license license:asl2.0)))) - -(define-public cl-boost-lexer - (sbcl-package->cl-source-package sbcl-boost-lexer)) - -(define-public ecl-boost-lexer - (sbcl-package->ecl-package sbcl-boost-lexer)) - -(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 ecl-ubiquitous - (sbcl-package->ecl-package sbcl-ubiquitous)) - -(define-public cl-ubiquitous - (sbcl-package->cl-source-package sbcl-ubiquitous)) - -(define-public sbcl-uax-14 - (let ((commit "0432162525119c401d3d705bb9bcc9580a03914f") - (revision "1")) - (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 - (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)) - (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)) - -(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-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 ecl-zpb-ttf - (sbcl-package->ecl-package sbcl-zpb-ttf)) - -(define-public cl-zpb-ttf - (sbcl-package->cl-source-package sbcl-zpb-ttf)) - -(define-public sbcl-zip - ;; named branch is outdated - (let ((commit "688b1545dd7a4fe355556768bb03f8bd9b847a87") - (revision "1")) - (package - (name "sbcl-zip") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/bluelisp/zip") - (commit commit))) - (sha256 - (base32 "0s08a6fq182fzsbfyvihqbdllq6gxcwkvphxnrd9wwz65dhg5y66")) - (file-name (git-file-name "cl-zip" version)))) - (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))))) - -(define-public ecl-zip - (sbcl-package->ecl-package sbcl-zip)) - -(define-public cl-zip - (sbcl-package->cl-source-package sbcl-zip)) - -(define-public sbcl-zippy - (let ((commit "ed9bca591ded2ff27a9ac95d9a60827773a0e707") - (revision "1")) - (package - (name "sbcl-zippy") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/zippy/") - (commit commit))) - (sha256 - (base32 "16cvyyf2nzd9r3fcy4w6d5wh8n3x833wldmrxmnzd3k2xrkhzfl9")) - (file-name (git-file-name "zippy" version)))) - (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))) - -(define-public ecl-cl-vectors - (sbcl-package->ecl-package sbcl-cl-vectors)) - -(define-public cl-vectors - (sbcl-package->cl-source-package sbcl-cl-vectors)) - -(define-public sbcl-spatial-trees - ;; There have been no releases. - (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba") - (revision "1")) - (package - (name "sbcl-spatial-trees") - (version (git-version "0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/spatial-trees") - (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-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 - "Spatial-trees is a set of dynamic index data structures for -spatially-extended data.") - (license license:bsd-3)))) - -(define-public ecl-spatial-trees - (sbcl-package->ecl-package sbcl-spatial-trees)) - -(define-public cl-spatial-trees - (sbcl-package->cl-source-package sbcl-spatial-trees)) - -(define-public sbcl-flexichain - ;; There are no releases. - (let ((commit "9af644a6323f303a936a391b956babcbfe7b0c67") - (revision "2")) - (package - (name "sbcl-flexichain") - (version (git-version "1.5.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/robert-strandh/Flexichain") - (commit commit))) - (file-name (git-file-name "cl-flexichain" version)) - (sha256 - (base32 "1ivkffnkc1iqmpl1p1rgyfbbgjmjcid4iszvdql1jjz324lq94g6")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-trivial-garbage)) - (home-page "https://github.com/robert-strandh/Flexichain.git") - (synopsis "Dynamically add elements to or remove them from sequences") - (description - "This package provides an implementation of the flexichain protocol, -allowing client code to dynamically add elements to, and delete elements from -a sequence (or chain) of such elements.") - (license license:lgpl2.1+)))) - -(define-public ecl-flexichain - (sbcl-package->ecl-package sbcl-flexichain)) - -(define-public cl-flexichain - (sbcl-package->cl-source-package sbcl-flexichain)) - -(define-public sbcl-cl-pdf - (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213") - (revision "3")) - (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)))) - -(define-public ecl-cl-pdf - (sbcl-package->ecl-package sbcl-cl-pdf)) - -(define-public cl-pdf - (sbcl-package->cl-source-package sbcl-cl-pdf)) - -(define-public sbcl-clx - (let ((commit "38400456d66823e417d1d27d339b09885e25eb59") - (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)))) - -(define-public cl-clx - (sbcl-package->cl-source-package sbcl-clx)) - -(define-public ecl-clx - (sbcl-package->ecl-package sbcl-clx)) - -(define-public sbcl-cl-wayland - (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae") - (revision "0")) - (package - (name "sbcl-cl-wayland") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sdilts/cl-wayland") - (commit commit))) - (file-name (git-file-name "cl-wayland" version)) - (sha256 - (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf")))) - (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)))) - -(define-public cl-wayland - (sbcl-package->cl-source-package sbcl-cl-wayland)) - -(define-public ecl-cl-wayland - (sbcl-package->ecl-package sbcl-cl-wayland)) - -(define-public sbcl-clx-truetype - (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8") - (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)))) - -(define-public cl-clx-truetype - (sbcl-package->cl-source-package sbcl-clx-truetype)) - -(define-public ecl-clx-truetype - (sbcl-package->ecl-package sbcl-clx-truetype)) - -(define-public sbcl-slynk - ;; Update together with emacs-sly. - (let ((commit "9c43bf65b967e12cef1996f1af5f0671d8aecbf4") - (revision "9")) - (package - (name "sbcl-slynk") - (version (git-version "1.0.43" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/joaotavora/sly") - (commit commit))) - (sha256 - (base32 "15nyr02ykkws4q79jcmxcawddg8sgq9v5l8k7jv7gg3hnpzxjlb2")) - (file-name (git-file-name "cl-slynk" version)))) - (build-system asdf-build-system/sbcl) - (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-slynk - (sbcl-package->cl-source-package sbcl-slynk)) - -(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-parse-js - (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6") - (revision "1")) - (package - (name "sbcl-parse-js") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://marijn.haverbeke.nl/git/parse-js") - (commit commit))) - (file-name (git-file-name "cl-parse-js" version)) - (sha256 - (base32 - "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39")))) - (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+))) - -(define-public cl-charje.loop - (sbcl-package->cl-source-package sbcl-charje.loop)) - -(define-public ecl-charje.loop - (sbcl-package->ecl-package sbcl-charje.loop)) - -(define-public sbcl-cl-uglify-js - ;; There have been many bug fixes since the 2010 release. - (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5") - (revision "1")) - (package - (name "sbcl-cl-uglify-js") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mishoo/cl-uglify-js") - (commit commit))) - (file-name (git-file-name "cl-uglify-js" version)) - (sha256 - (base32 - "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a")))) - (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)) - -(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-strings - (let ((revision "1") - (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140")) - (package - (name "sbcl-cl-strings") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/diogoalexandrefranco/cl-strings") - (commit commit))) - (sha256 - (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj")) - (file-name (git-file-name "cl-strings" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Set of utilities to manipulate strings in 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)) - -(define-public ecl-cl-strings - (sbcl-package->ecl-package sbcl-cl-strings)) - -(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-harmony - (let ((commit "0b57483cc0341936c201b620f82a8542c606991f") - (revision "0")) - (package - (name "sbcl-harmony") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/harmony") - (commit commit))) - (file-name (git-file-name "cl-harmony" version)) - (sha256 - (base32 "0pqmfi3yi3gi7b7dyayrb621hp60rn7hasq0cl0fis3vg0fp5dja")))) - (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") - (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)))) - -(define-public ecl-harmony - (sbcl-package->ecl-package sbcl-harmony)) - -(define-public cl-harmony - (sbcl-package->cl-source-package sbcl-harmony)) - -(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 cl-hu.dwim.asdf - (sbcl-package->cl-source-package sbcl-hu.dwim.asdf)) - -(define-public ecl-hu.dwim.asdf - (sbcl-package->ecl-package sbcl-hu.dwim.asdf)) - -(define-public sbcl-hu.dwim.graphviz - (let ((commit "31522ca8b9a04d535b7cec20ef24d8bf3b26d52b") - (revision "1")) - (package - (name "sbcl-hu.dwim.graphviz") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.graphviz") - (commit commit))) - (file-name (git-file-name "cl-hu.dwim.graphviz" version)) - (sha256 - (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-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 package provides CFFI bindings to the Graphviz library in Common -Lisp.") - (license license:public-domain)))) - -(define-public cl-hu.dwim.graphviz - (sbcl-package->cl-source-package sbcl-hu.dwim.graphviz)) - -(define-public ecl-hu.dwim.graphviz - (sbcl-package->ecl-package sbcl-hu.dwim.graphviz)) - -(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/michaelw/cl-dot") - (commit commit))) - (file-name (git-file-name "cl-dot" version)) - (sha256 - (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/michaelw/cl-dot") - (synopsis "Generate Graphviz dot output from arbitrary Lisp data") - (description - "CL-DOT is a Common Lisp library for generating Graphviz dot output from -arbitrary Lisp data.") - (license license:expat)))) - -(define-public cl-dot - (sbcl-package->cl-source-package sbcl-cl-dot)) - -(define-public ecl-cl-dot - (sbcl-package->ecl-package sbcl-cl-dot)) - -(define-public sbcl-cl-graph - (let ((commit "c617de35390cb02db88bc5b5febffafdb8947ae8") - (revision "2")) - (package - (name "sbcl-cl-graph") - (version (git-version "0.10.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/cl-graph") - (commit commit))) - (file-name (git-file-name "cl-graph" version)) - (sha256 - (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf")))) - (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)))) - -;; NOTE: (Sharlatan-20221118T214734+0000): No ECL supoort -;; -;; ecl-cl-graph - -(define-public cl-cl-graph - (sbcl-package->cl-source-package sbcl-cl-graph)) - -(define-public sbcl-babel - ;; No release since 2014. - (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9") - (revision "3")) - (package - (name "sbcl-babel") - (version (git-version "0.5.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cl-babel/babel") - (commit commit))) - (file-name (git-file-name "cl-babel" version)) - (sha256 - (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380")))) - (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))) - -(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-eager-future2 - (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30")) - (package - (name "sbcl-eager-future2") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-bordeaux-threads sbcl-trivial-garbage)) - (synopsis "Futures promises synchronization mechanism for 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+)))) - -(define-public cl-eager-future2 - (sbcl-package->cl-source-package sbcl-eager-future2)) - -(define-public ecl-eager-future2 - (sbcl-package->ecl-package sbcl-eager-future2)) - -(define-public sbcl-easy-routes - (let ((commit "7832f8bf3d07825b5eb967a2ef04da7c40c18248") - (revision "0")) - (package - (name "sbcl-easy-routes") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/easy-routes") - (commit commit))) - (file-name (git-file-name "cl-easy-routes" version)) - (sha256 - (base32 "1banw54kz2llzb9h5sm47ckfc9l348m7qncm0npsy0w837rxkyzx")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("easy-routes" - "easy-routes+djula" - "easy-routes+errors"))) - (native-inputs - (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 - "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 - -This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS -systems.") - (license license:expat)))) - -(define-public cl-easy-routes - (sbcl-package->cl-source-package sbcl-easy-routes)) - -(define-public ecl-easy-routes - (sbcl-package->ecl-package sbcl-easy-routes)) - -(define-public sbcl-jpl-util - (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62")) - (package - (name "sbcl-jpl-util") - (version "20151005") - (source - (origin - (method git-fetch) - (uri (git-reference - ;; Quicklisp uses this fork. - (url "https://github.com/hawkir/cl-jpl-util") - (commit commit))) - (file-name - (git-file-name "jpl-util" version)) - (sha256 - (base32 - "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz")))) - (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)))) - -(define-public cl-jpl-util - (sbcl-package->cl-source-package sbcl-jpl-util)) - -(define-public ecl-jpl-util - (sbcl-package->ecl-package sbcl-jpl-util)) - -(define-public sbcl-piping - (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656") - (revision "1")) - (package - (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-piping - (sbcl-package->ecl-package sbcl-piping)) - -(define-public cl-piping - (sbcl-package->cl-source-package sbcl-piping)) - -(define-public sbcl-bobbin - (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce") - (revision "0")) - (package - (name "sbcl-bobbin") + (name "sbcl-bordeaux-fft") (version (git-version "1.0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sjl/bobbin") + (url "https://github.com/ahefner/bordeaux-fft") (commit commit))) - (file-name (git-file-name "cl-bobbin" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm")))) + (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf")))) (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") + (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/") + (synopsis "Fast Fourier Transform for Common Lisp") (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)))) + "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 cl-bobbin - (sbcl-package->cl-source-package sbcl-bobbin)) +(define-public cl-bordeaux-fft + (sbcl-package->cl-source-package sbcl-bordeaux-fft)) -(define-public ecl-bobbin - (sbcl-package->ecl-package sbcl-bobbin)) +(define-public ecl-bordeaux-fft + (sbcl-package->ecl-package sbcl-bordeaux-fft)) -(define-public sbcl-cl-pcg - (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f") - (revision "1")) +(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-bordeaux-threads + (sbcl-package->cl-source-package sbcl-bordeaux-threads)) + +(define-public ecl-bordeaux-threads + (sbcl-package->ecl-package sbcl-bordeaux-threads)) + +(define-public sbcl-bst + (let ((commit "8545aed0d504df2829ad139566feeabe22305388") + (revision "0")) (package - (name "sbcl-cl-pcg") - (version (git-version "1.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/sjl/cl-pcg") + (url "https://codeberg.org/glv/bst") (commit commit))) - (file-name (git-file-name "cl-pcg" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4")))) + (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8")))) (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") + (list sbcl-alexandria sbcl-fiveam)) + (synopsis "Binary search tree for Common Lisp") (description - "This is a bare-bones Permuted Congruential Generator implementation in -pure Common Lisp.") - (license license:expat)))) + "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 ecl-cl-pcg - (let ((pkg (sbcl-package->ecl-package sbcl-cl-pcg))) +(define-public cl-bst + (sbcl-package->cl-source-package sbcl-bst)) + +(define-public ecl-bst + (sbcl-package->ecl-package sbcl-bst)) + +(define-public sbcl-bubble-operator-upwards + (let ((commit "846275a318b960de81b62caecb1e31930f70aef6") + (revision "0")) (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-bubble-operator-upwards") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Hexstream/bubble-operator-upwards") + (commit commit))) + (file-name (git-file-name "cl-bubble-operator-upwards" version)) + (sha256 + (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi")))) + (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") + (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)))) -(define-public cl-pcg - (sbcl-package->cl-source-package sbcl-cl-pcg)) +(define-public cl-bubble-operator-upwards + (sbcl-package->cl-source-package sbcl-bubble-operator-upwards)) -(define-public sbcl-seedable-rng - (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15") - (revision "1")) +(define-public ecl-bubble-operator-upwards + (sbcl-package->ecl-package sbcl-bubble-operator-upwards)) + +(define-public sbcl-burgled-batteries3 + (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760") + (revision "2")) (package - (name "sbcl-seedable-rng") + (name "sbcl-burgled-batteries3") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://git.mfiano.net/mfiano/seedable-rng") + (url "https://github.com/snmsts/burgled-batteries3") (commit commit))) - (file-name (git-file-name "seedable-rng" version)) + (file-name (git-file-name "cl-burgled-batteries3" version)) (sha256 - (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5")))) + (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) + #: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 sbcl-cl-pcg sbcl-golden-utils sbcl-ironclad)) - (home-page "https://git.mfiano.net/mfiano/seedable-rng") - (synopsis "Common Lisp random number generator") + (list python + sbcl-alexandria + sbcl-cffi + sbcl-parse-declarations + sbcl-trivial-garbage)) + (synopsis "Bridge between Python and Lisp (FFI bindings, etc.)") (description - "SEEDABLE-RNG provides a convenient means of generating random numbers -that are seedable with deterministic results across hardware and Common Lisp -implementations.") + "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)))) -(define-public ecl-seedable-rng - (sbcl-package->ecl-package sbcl-seedable-rng)) +(define-public cl-burgled-batteries3 + (sbcl-package->cl-source-package sbcl-burgled-batteries3)) -(define-public cl-seedable-rng - (sbcl-package->cl-source-package sbcl-seedable-rng)) +(define-public ecl-burgled-batteries3 + (sbcl-package->ecl-package sbcl-burgled-batteries3)) -(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-cache-while + (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7") + (revision "1")) + (package + (name "sbcl-cache-while") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/charje/cache-while") + (commit commit))) + (file-name (git-file-name "cache-while" version)) + (sha256 + (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3")))) + (build-system asdf-build-system/sbcl) + (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)))) -@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 +(define-public cl-cache-while + (sbcl-package->cl-source-package sbcl-cache-while)) -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 ecl-cache-while + (sbcl-package->ecl-package sbcl-cache-while)) (define-public sbcl-calispel (let ((commit "e9f2f9c1af97f4d7bb4c8ac25fb2a8f3e8fada7a")) @@ -3405,1340 +2639,338 @@ Lisp.") (define-public ecl-calm (sbcl-package->ecl-package sbcl-calm)) -(define-public sbcl-esrap - (let ((commit "d806138342a6b27327649fd5f36e0fe2e0966867") - (revision "4")) +(define-public sbcl-cambl + (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636") + (revision "1")) (package - (name "sbcl-esrap") - (version (git-version "0.18" 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/scymtym/esrap") + (url "https://github.com/jwiegley/cambl") (commit commit))) - (file-name (git-file-name "cl-esrap" version)) + (file-name (git-file-name "cambl" version)) (sha256 - (base32 "0gs0mfamldhaihnlk0qxg2q4bl8bamq68dif9js9fkl8apg3iykl")))) + (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) + (list sbcl-xlunit)) (inputs - (list sbcl-alexandria sbcl-trivial-with-current-source-form)) - (synopsis "Common Lisp packrat parser") + `(("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 - "This is a packrat parser for Common Lisp. -In addition to regular Packrat / Parsing Grammar / TDPL features ESRAP supports: + "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)))) + +(define-public cl-cambl + (sbcl-package->cl-source-package sbcl-cambl)) + +(define-public ecl-cambl + (sbcl-package->ecl-package sbcl-cambl)) + +(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 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-caveman") + (version (git-version "2.4.0" revision commit)) + (home-page "https://8arrow.org/caveman/") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/caveman/") + (commit commit))) + (file-name (git-file-name "cl-caveman" version)) + (sha256 + (base32 "1wvjm9m1fnapg0r9imhhcwgnhhqkkccnj3c0iw9yg1f72d7zhm2w")))) + (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 #: + ;; 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: @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 +@item Be extensible. +@item Be practical. +@item Don't force anything. @end itemize\n") - (home-page "https://scymtym.github.io/esrap/") - (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-colorize - (sbcl-package->cl-source-package sbcl-colorize)) - -(define-public ecl-colorize - (sbcl-package->ecl-package sbcl-colorize)) - -(define-public sbcl-3bmd - (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5") - (revision "4")) - (package - (name "sbcl-3bmd") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/3b/3bmd") - (commit commit))) - (sha256 - (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-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 - "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-3bmd - (sbcl-package->cl-source-package sbcl-3bmd)) - -(define-public ecl-3bmd - (sbcl-package->ecl-package sbcl-3bmd)) - -(define-public sbcl-cl-fad - ;; No release since 2019 - (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535") - (revision "1")) - (package - (name "sbcl-cl-fad") - (version (git-version "0.7.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-fad/") - (commit commit))) - (sha256 - (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)) - (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)))) - -(define-public cl-fad - (sbcl-package->cl-source-package sbcl-cl-fad)) - -(define-public ecl-cl-fad - (sbcl-package->ecl-package sbcl-cl-fad)) - -(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 cl-nibbles - (sbcl-package->cl-source-package sbcl-nibbles)) - -(define-public ecl-nibbles - (sbcl-package->ecl-package sbcl-nibbles)) - -(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-ironclad - (sbcl-package->cl-source-package sbcl-ironclad)) - -(define-public ecl-ironclad - (sbcl-package->ecl-package sbcl-ironclad)) - -(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 cl-named-readtables - (sbcl-package->cl-source-package sbcl-named-readtables)) - -(define-public ecl-named-readtables - (sbcl-package->ecl-package sbcl-named-readtables)) - -(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-cl-ini - (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7") - (revision "0")) - (package - (name "sbcl-cl-ini") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/compufox/cl-ini") - (commit commit))) - (file-name (git-file-name "sbcl-cl-ini" version)) - (sha256 - (base32 - "12vy3gspqn0wmkyz5id1xrgv1scgb16m7pkvmbmi19vlpj2iyq7p")))) - (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") - (description - "Parse INI formatted files into a Common Lisp list structure.") - (license license:expat)))) - -(define-public cl-ini - (sbcl-package->cl-source-package sbcl-cl-ini)) - -(define-public ecl-cl-ini - (sbcl-package->ecl-package sbcl-cl-ini)) - -(define-public sbcl-pythonic-string-reader - (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a")) - (package - (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/smithzvk/pythonic-string-reader/") - (commit commit))) - (sha256 - (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j")) - (file-name (git-file-name "pythonic-string-reader" version)))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-pythonic-string-reader - (sbcl-package->cl-source-package sbcl-pythonic-string-reader)) - -(define-public ecl-pythonic-string-reader - (sbcl-package->ecl-package sbcl-pythonic-string-reader)) - -(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-slime-swank - (sbcl-package->cl-source-package sbcl-slime-swank)) - -(define-public ecl-slime-swank - (sbcl-package->ecl-package sbcl-slime-swank)) - -(define-public sbcl-mgl-pax - (let ((commit "6782eb041c152721972420dfafa192692d16b7ce") - (revision "1")) - (package - (name "sbcl-mgl-pax") - (version (git-version "0.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/melisgl/mgl-pax") - (commit commit))) - (sha256 - (base32 "0fjbzc2fn17m80lfsc8121sa0bk7fg42fqlwhm01sk1fj4s48pma")) - (file-name (git-file-name "cl-mgl-pax" version)))) - (build-system asdf-build-system/sbcl) - ;; (native-inputs - ;; (list sbcl-try)) - (inputs - (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 - "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/") - (license license:expat)))) - -(define-public cl-mgl-pax - (sbcl-package->cl-source-package sbcl-mgl-pax)) - -(define-public ecl-mgl-pax - (sbcl-package->ecl-package sbcl-mgl-pax)) - -(define-public sbcl-40ants-doc - (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b") - (revision "0")) - (package - (name "sbcl-40ants-doc") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/40ants/doc") - (commit commit))) - (sha256 - (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 - 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 - "@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)))) - -(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-mssql - (let ((commit "045602a19a32254108f2b75871049293f49731eb") - (revision "1")) - (package - (name "sbcl-mssql") - (version (git-version "0.0.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/archimag/cl-mssql") - (commit commit))) - (file-name (git-file-name "cl-mssql" version)) - (sha256 - (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm")))) - (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))) - (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 +(define-public cl-caveman (package - (name "sbcl-anaphora") - (version "0.9.8") + (inherit + (sbcl-package->cl-source-package sbcl-caveman)) + (propagated-inputs + `(("ningle" ,cl-ningle))))) + +(define-public ecl-caveman + (sbcl-package->ecl-package sbcl-caveman)) + +(define-public sbcl-cells + (let ((commit "e8542b17fddd6340c1e237ce482a52327c8ead8e")) + (package + (name "sbcl-cells") + (version (git-version "3.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/kennytilton/cells") + (commit commit))) + (file-name (git-file-name "cl-cells" version)) + (sha256 + (base32 "0rkzvwq38lwb1045w54kw020pb9i63hxiawwhqkf8k1inhak3fdk")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-utils-kt)) + (arguments + ;; Tests fail with #. + '(#:tests? #f)) + (home-page "https://github.com/kennytilton/cells") + (synopsis "Common Lisp implementation of the dataflow programming paradigm") + (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)))) + +(define-public cl-cells + (sbcl-package->cl-source-package sbcl-cells)) + +(define-public ecl-cells + (sbcl-package->ecl-package sbcl-cells)) + +(define-public sbcl-cephes + (let ((commit "d87146fa38c8425ffb5fe425eee5eb3e818bacd4") + (revision "0")) + (package + (name "sbcl-cephes") + (version (git-version "1.2" 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")))) + (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") + (description + "This package provides a common lisp CFFI wrapper for the SciPy version +of Cephes special functions.") + (license license:ms-pl)))) + +(define-public cl-cephes + (sbcl-package->cl-source-package sbcl-cephes)) + +(define-public ecl-cephes + (sbcl-package->ecl-package sbcl-cephes)) + +(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)))) + +(define-public cl-cepl + (sbcl-package->cl-source-package sbcl-cepl)) + +(define-public ecl-cepl + (sbcl-package->ecl-package sbcl-cepl)) + +(define-public sbcl-cesdi + (package + (name "sbcl-cesdi") + (version "1.0.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/tokenrove/anaphora") + (url "https://github.com/Hexstream/cesdi") (commit version))) + (file-name (git-file-name "cl-cesdi" version)) (sha256 - (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b")) - (file-name (git-file-name "cl-anaphora" version)))) + (base32 "02f2pz5rw79ljkkx1ywh8nkpjj4g3z3s1lyvzqb8krbnx11wl0q9")))) (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)) - -(define-public ecl-anaphora - (sbcl-package->ecl-package sbcl-anaphora)) - -(define-public sbcl-let-plus - (let ((commit "455e657e077235829b197f7ccafd596fcda69e30") - (revision "2")) - (package - (name "sbcl-let-plus") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/let-plus") - (commit commit))) - (sha256 - (base32 "00c0nq6l4zb692rzsc9aliqzj3avrssfyz4bhxzl7f1jsz3m29jb")) - (file-name (git-file-name "cl-let-plus" version)))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria sbcl-anaphora)) - (native-inputs - (list sbcl-lift)) - (synopsis "Destructuring extension of let*") - (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)) - -(define-public ecl-let-plus - (sbcl-package->ecl-package sbcl-let-plus)) - -(define-public sbcl-cl-cairo2 - (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b") - (revision "1")) - (package - (name "sbcl-cl-cairo2") - (version (git-version "0.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/cl-cairo2") - (commit commit))) - (file-name (git-file-name "cl-cairo2" version)) - (sha256 - (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 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 package provides CFFI bindings for Common Lisp to the Cairo -C library.") - (license license:boost1.0)))) - -(define-public ecl-cl-cairo2 - (sbcl-package->ecl-package sbcl-cl-cairo2)) - -(define-public cl-cairo2 - (sbcl-package->cl-source-package sbcl-cl-cairo2)) - -(define-public sbcl-cl-colors - (let ((commit "827410584553f5c717eec6182343b7605f707f75")) - (package - (name "sbcl-cl-colors") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/cl-colors") - (commit commit))) - (sha256 - (base32 - "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a")) - (file-name (git-file-name "cl-colors" version)))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria sbcl-let-plus)) - (synopsis "Simple color library for Common Lisp") - (description - "This is a very simple color library for Common Lisp, providing - -@itemize -@item Types for representing colors in HSV and RGB spaces. -@item Simple conversion functions between the above types (and also -hexadecimal representation for RGB). -@item Some predefined colors (currently X11 color names – of course the -library does not depend on X11).Because color in your terminal is nice. -@end itemize - -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 ecl-cl-colors - (sbcl-package->ecl-package sbcl-cl-colors)) - -(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-format-colors - (sbcl-package->cl-source-package sbcl-format-colors)) - -(define-public ecl-format-colors - (sbcl-package->ecl-package sbcl-format-colors)) - -(define-public sbcl-cl-ansi-text - (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c")) - (package - (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/pnathan/cl-ansi-text") - (commit commit))) - (sha256 - (base32 - "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14")) - (file-name (git-file-name "cl-ansi-text" version)))) - (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") - (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)))) - -(define-public cl-ansi-text - (sbcl-package->cl-source-package sbcl-cl-ansi-text)) - -(define-public ecl-cl-ansi-text - (sbcl-package->ecl-package sbcl-cl-ansi-text)) - -(define-public sbcl-proc-parse - (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd")) - (package - (name "sbcl-proc-parse") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/proc-parse") - (commit commit))) - (sha256 - (base32 - "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh")) - (file-name (git-file-name "proc-parse" version)))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("babel" ,sbcl-babel))) - (native-inputs - (list sbcl-prove)) - (arguments - '(#:asd-systems '("proc-parse-test" - "proc-parse"))) - (synopsis "Procedural vector parser") - (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)))) - -(define-public cl-proc-parse - (sbcl-package->cl-source-package sbcl-proc-parse)) - -(define-public ecl-proc-parse - (sbcl-package->ecl-package sbcl-proc-parse)) - -(define-public sbcl-parse-float - (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c") - (revision "2")) - (package - (name "sbcl-parse-float") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/soemraws/parse-float") - (commit commit))) - (sha256 - (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr")) - (file-name (git-file-name "proc-parse" version)))) - (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)) - (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)))) - -(define-public cl-parse-float - (sbcl-package->cl-source-package sbcl-parse-float)) - -(define-public ecl-parse-float - (sbcl-package->ecl-package sbcl-parse-float)) - -(define-public sbcl-cl-string-match - (let ((revision "1") - (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97")) - (package - (name "sbcl-cl-string-match") - (version (git-version "0" revision changeset)) - (source - (origin - (method hg-fetch) - (uri (hg-reference - (url "https://github.com/vityok/cl-string-match") - (changeset changeset))) - (sha256 - (base32 - "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y")) - (file-name (git-file-name "cl-string-match" version)))) - (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") - (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)))) - -(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)) + (list sbcl-parachute)) (inputs - (list sbcl-cl-syntax)) - (home-page "https://github.com/windymelt/cl-punch") - (synopsis "Anonymous lambda literal in Common Lisp, respecting Scala") + (list sbcl-closer-mop)) + (home-page "https://www.hexstreamsoft.com/libraries/cesdi/") + (synopsis "Ergonomic initialization of effective slot definition objects") (description - "CL-PUNCH is a Scala-like anonymous lambda literal.") - (license license:expat ))) + "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-punch - (sbcl-package->cl-source-package sbcl-cl-punch)) +(define-public cl-cesdi + (sbcl-package->cl-source-package sbcl-cesdi)) -(define-public ecl-cl-punch - (sbcl-package->ecl-package sbcl-cl-punch)) +(define-public ecl-cesdi + (sbcl-package->ecl-package sbcl-cesdi)) -(define-public sbcl-puri - (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b") +(define-public sbcl-cf + (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e") (revision "2")) (package - (name "sbcl-puri") - (version (git-version "1.5.7" revision commit)) + (name "sbcl-cf") + (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "http://git.kpe.io/puri.git") + (url "https://codeberg.org/glv/cl-cf") (commit commit))) - (file-name (git-file-name "puri" version)) + (file-name (git-file-name "cl-cf" 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 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-ptester)) - (home-page "http://puri.kpe.io/") - (synopsis "Portable URI Library") - (description - "This is a portable Universal Resource Identifier library for Common -Lisp programs. It parses URI according to the RFC 2396 specification.") - (license license:llgpl)))) + (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-puri - (sbcl-package->cl-source-package sbcl-puri)) +(define-public cl-cf + (sbcl-package->cl-source-package sbcl-cf)) -(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.") - (license license:expat)))) - -(define-public ecl-qmynd - (sbcl-package->ecl-package sbcl-qmynd)) - -(define-public cl-qmynd - (sbcl-package->cl-source-package sbcl-qmynd)) - -(define-public sbcl-queues - (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94")) - (package - (name "sbcl-queues") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/oconnore/queues") - (commit commit))) - (file-name (git-file-name "queues" version)) - (sha256 - (base32 - "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv")))) - (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") - (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)))) - -(define-public cl-queues - (sbcl-package->cl-source-package sbcl-queues)) - -(define-public ecl-queues - (sbcl-package->ecl-package sbcl-queues)) - -(define-public sbcl-glsl-packing - (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a") - (revision "1")) - (package - (name "sbcl-glsl-packing") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/3b/glsl-packing/") - (commit commit))) - (file-name (git-file-name "glsl-packing" version)) - (sha256 - (base32 "0k2f1771wd9kdrcasldy1r00k5bdgi9fd07in52zmjggc0i7dd80")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria)) - (home-page "https://github.com/3b/glsl-packing/") - (synopsis "Common Lisp utilities to calculate OpenGL layouts") - (description - "This is a Common Lisp library to calculate std140 or std430 layouts for -a glsl UBO/SSBO.") - (license license:expat)))) - -(define-public ecl-glsl-packing - (sbcl-package->ecl-package sbcl-glsl-packing)) - -(define-public cl-glsl-packing - (sbcl-package->cl-source-package sbcl-glsl-packing)) - -(define-public sbcl-glsl-spec - (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d") - (revision "1")) - (package - (name "sbcl-glsl-spec") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cbaggers/glsl-spec") - (commit commit))) - (file-name (git-file-name "glsl-spec" version)) - (sha256 - (base32 "01ipspr22fgfj3w8wq2y81lzrjc4vpfiwnr3dqhjlpzzra46am8c")))) - (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") - (description - "This package contains the specification of all functions and variables -from GLSL as data.") - (license license:unlicense)))) - -(define-public ecl-glsl-spec - (sbcl-package->ecl-package sbcl-glsl-spec)) - -(define-public cl-glsl-spec - (sbcl-package->cl-source-package sbcl-glsl-spec)) - -(define-public sbcl-rtg-math - (let ((commit "29fc5b3d0028a4a11a82355ecc8cca62662c69e0") - (revision "1")) - (package - (name "sbcl-rtg-math") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cbaggers/rtg-math") - (commit commit))) - (file-name (git-file-name "rtg-math" version)) - (sha256 - (base32 "0bhxxnv7ldkkb18zdxyz2rj2a3iawzq2kcp7cn5i91iby7n0082x")))) - (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") - (description - "RTG-MATH provides a selection of the math routines most commonly needed -for making realtime graphics in Lisp.") - (license license:bsd-2)))) - -(define-public ecl-rtg-math - (sbcl-package->ecl-package sbcl-rtg-math)) - -(define-public cl-rtg-math - (sbcl-package->cl-source-package sbcl-rtg-math)) - -(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 ecl-varjo - (sbcl-package->ecl-package sbcl-varjo)) - -(define-public cl-varjo - (sbcl-package->cl-source-package sbcl-varjo)) +(define-public ecl-cf + (sbcl-package->ecl-package sbcl-cf)) (define-public sbcl-cffi (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112") @@ -4799,6 +3031,7 @@ package.") (define-public ecl-cffi (sbcl-package->ecl-package sbcl-cffi)) + (define-public sbcl-cffi-c-ref (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce") (revision "0")) @@ -4829,1484 +3062,196 @@ package.") (define-public ecl-cffi-c-ref (sbcl-package->ecl-package sbcl-cffi-c-ref)) -(define-public sbcl-ffa - (let ((commit "b7012f51c4c37d1e759ff9cf78cea178504d8e07") +(define-public sbcl-chanl + (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c") (revision "1")) (package - (name "sbcl-ffa") - (version (git-version "0.0.0" 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/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)))) - -(define-public cl-ffa - (sbcl-package->cl-source-package sbcl-ffa)) - -(define-public ecl-ffa - (sbcl-package->ecl-package sbcl-ffa)) - -(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 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-raylib - (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d") - (revision "0")) - (package - (name "sbcl-cl-raylib") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/longlene/cl-raylib") - (commit commit))) - (file-name (git-file-name "cl-raylib" version)) - (sha256 - (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 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-raylib - (sbcl-package->cl-source-package sbcl-cl-raylib)) - -(define-public ecl-cl-raylib - (sbcl-package->ecl-package sbcl-cl-raylib)) - -(define-public sbcl-cl-redis - (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d") - (revision "0")) - (package - (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) - (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-parenscript - ;; Source archives are overwritten on every release, we use the Git repo instead. - (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766")) - (package - (name "sbcl-parenscript") - (version (git-version "2.7.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/parenscript/parenscript") - (commit commit))) - (file-name (git-file-name "parenscript" version)) - (sha256 - (base32 - "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf")))) - (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") - (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)))) - -(define-public cl-parenscript - (sbcl-package->cl-source-package sbcl-parenscript)) - -(define-public ecl-parenscript - (sbcl-package->ecl-package sbcl-parenscript)) - -(define-public sbcl-cl-json - (package - (name "sbcl-cl-json") - (version "0.6.0") - (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")))) - (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))) - -(define-public cl-json - (sbcl-package->cl-source-package sbcl-cl-json)) - -(define-public ecl-cl-json - (sbcl-package->ecl-package sbcl-cl-json)) - -(define-public sbcl-cl-json-pointer - (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c") - (revision "0")) - (package - (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-json-pointer - (sbcl-package->cl-source-package sbcl-cl-json-pointer)) - -(define-public ecl-cl-json-pointer - (sbcl-package->ecl-package sbcl-cl-json-pointer)) - -(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-unix-opts - (sbcl-package->cl-source-package sbcl-unix-opts)) - -(define-public ecl-unix-opts - (sbcl-package->ecl-package sbcl-unix-opts)) - -(define-public sbcl-trivial-garbage - (let ((commit "3474f6414b73d4e3aa2d5c53080f4247a34f6380") - (revision "0")) - (package - (name "sbcl-trivial-garbage") - (version (git-version "0.21" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/trivial-garbage/trivial-garbage") - (commit commit))) - (file-name (git-file-name "cl-trivial-garbage" version)) - (sha256 - (base32 "0rfwxvwg0kpcaa0hsi035yrkfdfks4bq8d9azmrww2f0rmv9g6sd")))) - (build-system asdf-build-system/sbcl) - (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-trivial-garbage - (sbcl-package->cl-source-package sbcl-trivial-garbage)) - -(define-public ecl-trivial-garbage - (sbcl-package->ecl-package sbcl-trivial-garbage)) - -(define-public sbcl-ucons - (let ((commit "d976810ef2b12a2caaf55bd0f258272e9b79f3be") - (revision "0")) - (package - (name "sbcl-ucons") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/marcoheisig/ucons") - (commit commit))) - (file-name (git-file-name "cl-ucons" version)) - (sha256 - (base32 "17aj47pdjiywnf33hl46p27za2q0pq5ar3fpqxaqskggxrfxmijl")))) - (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)))) - -(define-public cl-ucons - (sbcl-package->cl-source-package sbcl-ucons)) - -(define-public ecl-ucons - (sbcl-package->ecl-package sbcl-ucons)) - -(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 cl-clobber - (sbcl-package->cl-source-package sbcl-clobber)) - -(define-public ecl-clobber - (sbcl-package->ecl-package sbcl-clobber)) - -(define-public sbcl-closer-mop - (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc") - (revision "3")) - (package - (name "sbcl-closer-mop") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pcostanza/closer-mop") - (commit commit))) - (sha256 - (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16")) - (file-name (git-file-name "cl-closer-mop" version )))) - (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)))) - -(define-public cl-closer-mop - (sbcl-package->cl-source-package sbcl-closer-mop)) - -(define-public ecl-closer-mop - (sbcl-package->ecl-package sbcl-closer-mop)) - -(define-public sbcl-cl-cffi-gtk - (let ((commit "1700fe672c65455c1fc33061ec92a3df84287ec7") - (revision "3")) - (package - (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/sharplispers/cl-cffi-gtk/") - (commit commit))) - (file-name (git-file-name "cl-cffi-gtk" version)) - (sha256 - (base32 "1cn2f6b62axjzdzfv971218ably32dvqfdy499li25vjd8nb2qm3")))) - (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") - (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)))) - -(define-public cl-cffi-gtk - (sbcl-package->cl-source-package sbcl-cl-cffi-gtk)) - -(define-public ecl-cl-cffi-gtk - (sbcl-package->ecl-package sbcl-cl-cffi-gtk)) - -(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-webkit - (sbcl-package->cl-source-package sbcl-cl-webkit)) - -(define-public ecl-cl-webkit - (sbcl-package->ecl-package sbcl-cl-webkit)) - -(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/sharplispers/lparallel/") - (commit commit))) - (file-name (git-file-name "cl-lparallel" version)) - (sha256 - (base32 "0nv2dx8cl25g68icqhw95yr5mygm86lcjzmzijql51na1p60g6y9")))) - (build-system asdf-build-system/sbcl) - (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") - (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)))) - -(define-public cl-lparallel - (sbcl-package->cl-source-package sbcl-lparallel)) - -(define-public ecl-lparallel - (sbcl-package->ecl-package sbcl-lparallel)) - -(define-public sbcl-cl-markup - (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390")) - (package - (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: - -@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-markup - (sbcl-package->cl-source-package sbcl-cl-markup)) - -(define-public ecl-cl-markup - (sbcl-package->ecl-package sbcl-cl-markup)) - -;;; 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/moderninterpreters/markup") - (commit commit))) - (file-name (git-file-name "markup-reader" version)) - (sha256 - (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("markup"))) - (native-inputs - (list sbcl-fiveam)) - (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))) - -(define-public cl-xml-emitter - (sbcl-package->cl-source-package sbcl-xml-emitter)) - -(define-public ecl-xml-emitter - (sbcl-package->ecl-package sbcl-xml-emitter)) - -(define-public sbcl-kdlcl - (let ((commit "dd4a48a3473c3c8fb34d4a37f87d6a1776c5875c") - (revision "0")) - (package - (name "sbcl-kdlcl") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/chee/kdlcl") - (commit commit))) - (file-name (git-file-name "cl-kdlcl" version)) - (sha256 - (base32 "0bqqxkd6s420ld2hmhvbbvpzss0m2kimmxaqhz7j1ksmq86bvvmj")))) - (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)))) - -(define-public cl-kdlcl - (sbcl-package->cl-source-package sbcl-kdlcl)) - -(define-public ecl-kdlcl - (sbcl-package->ecl-package sbcl-kdlcl)) - -(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-mustache - (sbcl-package->cl-source-package sbcl-cl-mustache)) - -(define-public ecl-cl-mustache - (sbcl-package->ecl-package sbcl-cl-mustache)) - -(define-public sbcl-cl-css - (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f")) - (package - (name "sbcl-cl-css") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/inaimathi/cl-css/") - (commit commit))) - (file-name (git-file-name "cl-css" version)) - (sha256 - (base32 - "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/inaimathi/cl-css/") - (synopsis "Non-validating, inline CSS generator for Common Lisp") - (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)))) - -(define-public cl-css - (sbcl-package->cl-source-package sbcl-cl-css)) - -(define-public ecl-cl-css - (sbcl-package->ecl-package sbcl-cl-css)) - -(define-public sbcl-portable-threads - (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df")) - (package - (name "sbcl-portable-threads") - (version (git-version "2.3" "2" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/binghe/portable-threads/") - (commit commit))) - (file-name (git-file-name "portable-threads" version)) - (sha256 - (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs")))) - (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") - (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)) - -(define-public ecl-portable-threads - (sbcl-package->ecl-package sbcl-portable-threads)) - -(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 cl-usocket - (sbcl-package->cl-source-package sbcl-usocket)) - -(define-public ecl-usocket - (sbcl-package->ecl-package sbcl-usocket)) - -(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-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-trivial-arguments - (let ((commit "ecd84ed9cf9ef8f1e873d7409e6bd04979372aa7") - (revision "1")) - (package - (name "sbcl-trivial-arguments") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/trivial-arguments") - (commit commit))) - (file-name (git-file-name "trivial-arguments" version)) - (sha256 - (base32 "02vaqfavhj8jqxnr68nnzvzshm8jbgcy6m9lvyv4daa6f7ihqf88")))) - (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") - (description - "This is a simple library to retrieve the argument list of a function.") - (license license:zlib)))) - -(define-public ecl-trivial-arguments - (sbcl-package->ecl-package sbcl-trivial-arguments)) - -(define-public cl-trivial-arguments - (sbcl-package->cl-source-package sbcl-trivial-arguments)) - -(define-public sbcl-trivial-clipboard - (let ((commit "aee67d6132a46237f61d508ae4bd9ff44032566d") - (revision "7")) - (package - (name "sbcl-trivial-clipboard") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/snmsts/trivial-clipboard") - (commit commit))) - (file-name (git-file-name "cl-trivial-clipboard" version)) - (sha256 - (base32 "029qmx523xfk54p99ndgbmdd20s5i32mzpf77xymngrn4c33v9jk")))) - (build-system asdf-build-system/sbcl) - (inputs - ;; Pick xsel instead of xclip because its closure size is slightly - ;; smaller. - (list wl-clipboard xsel)) - (native-inputs - (list sbcl-fiveam)) - (arguments - `(#: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 - "@command{trivial-clipboard} gives access to the system clipboard.") - (license license:expat)))) - -(define-public cl-trivial-clipboard - (sbcl-package->cl-source-package sbcl-trivial-clipboard)) - -(define-public ecl-trivial-clipboard - (sbcl-package->ecl-package sbcl-trivial-clipboard)) - -(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") - (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))) - -(define-public cl-md5 - (sbcl-package->cl-source-package sbcl-md5)) - -(define-public ecl-md5 - (package - (inherit (sbcl-package->ecl-package sbcl-md5)) - (inputs - (list ecl-flexi-streams)))) - -(define-public sbcl-cl+ssl - (let ((commit "17d5cdd65405f1d26e26f3e875e70027d0c8eedb") - (revision "6")) - (package - (name "sbcl-cl+ssl") - (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") - (commit commit))) - (file-name (git-file-name "cl+ssl" version)) - (sha256 - (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s")))) - (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 - 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-cl+ssl - (sbcl-package->cl-source-package sbcl-cl+ssl)) - -(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-kons-9 - (let ((commit "fe0b3228ca28c316457d35f9e7c67edc83b2a4cc") - (revision "0")) - (package - (name "sbcl-kons-9") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/kaveh808/kons-9") - (commit commit))) - (file-name (git-file-name "cl-kons-9" version)) - (sha256 - (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-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/") + (url "https://github.com/zkat/chanl") (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)))) + (base32 + "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) (inputs - (list sbcl-rt)) - (home-page "http://files.kpe.io/kmrcl/") - (synopsis "General utilities for Common Lisp programs") - (description - "KMRCL is a collection of utilities used by a number of Kevin -Rosenberg's Common Lisp packages.") - (license license:llgpl)))) + (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-kmrcl - (sbcl-package->cl-source-package sbcl-kmrcl)) +(define-public cl-chanl + (sbcl-package->cl-source-package sbcl-chanl)) -(define-public ecl-kmrcl - (sbcl-package->ecl-package sbcl-kmrcl)) +(define-public ecl-chanl + (sbcl-package->ecl-package sbcl-chanl)) -(define-public sbcl-cl-base64 - (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a")) - (package - (name "sbcl-cl-base64") - (version (git-version "3.3.4" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/cl-base64.git/") - (commit commit))) - (file-name (git-file-name name 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)))) - (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") - (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)))) - -(define-public cl-base64 - (sbcl-package->cl-source-package sbcl-cl-base64)) - -(define-public ecl-cl-base64 - (sbcl-package->ecl-package sbcl-cl-base64)) - -(define-public sbcl-chunga +(define-public sbcl-charje.documentation (package - (name "sbcl-chunga") - (version "1.1.7") + (name "sbcl-charje.documentation") + (version "0.0.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://git.sr.ht/~charje/documentation") + (commit (string-append "v" version)))) (sha256 - (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd")))) + (base32 + "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc")) + (file-name (git-file-name "cl-charje.documentation" version)))) (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)) + (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-charje.documentation + (sbcl-package->cl-source-package sbcl-charje.documentation)) + +(define-public ecl-charje.documentation + (sbcl-package->ecl-package sbcl-charje.documentation)) + +(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+))) + +(define-public cl-charje.loop + (sbcl-package->cl-source-package sbcl-charje.loop)) + +(define-public ecl-charje.loop + (sbcl-package->ecl-package sbcl-charje.loop)) + +(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 - "Chunga implements streams capable of chunked encoding on demand as -defined in RFC 2616.") - (license license:bsd-2))) + "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-chunga - (sbcl-package->cl-source-package sbcl-chunga)) +(define-public cl-chemboy + (sbcl-package->cl-source-package sbcl-chemboy)) -(define-public ecl-chunga - (sbcl-package->ecl-package sbcl-chunga)) +(define-public ecl-chemboy + (sbcl-package->ecl-package sbcl-chemboy)) -(define-public sbcl-cl-who - (let ((version "1.1.4") - (commit "07dafe9b351c32326ce20b5804e798f10d4f273d") - (revision "3")) - (package - (name "sbcl-cl-who") - (version (git-version version revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/cl-who") - (commit commit))) - (file-name (git-file-name "cl-who" version)) - (sha256 - (base32 - "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5")))) - (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") - (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)))) +(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-who - (sbcl-package->cl-source-package sbcl-cl-who)) +(define-public cl-chemical-compounds + (sbcl-package->cl-source-package sbcl-chemical-compounds)) -(define-public ecl-cl-who - (sbcl-package->ecl-package sbcl-cl-who)) +(define-public ecl-chemical-compounds + (sbcl-package->ecl-package sbcl-chemical-compounds)) (define-public sbcl-chipz (let ((version "0.8") @@ -6345,857 +3290,140 @@ the format used by the popular compression tool bzip2.") (define-public ecl-chipz (sbcl-package->ecl-package sbcl-chipz)) -(define-public sbcl-cl-tls - (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba") - (revision "0")) - (package - (name "sbcl-cl-tls") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/shrdlu68/cl-tls") - (commit commit))) - (file-name (git-file-name "cl-tls" version)) - (sha256 - (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7")))) - (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}.") - (license license:bsd-3)))) - -(define-public cl-tls - (sbcl-package->cl-source-package sbcl-cl-tls)) - -(define-public ecl-cl-tls - (sbcl-package->ecl-package sbcl-cl-tls)) - -(define-public sbcl-dns-client - (let ((commit "9f252e9c2bb61c57a6cd367e21ad366b0d3e87e0") - (revision "0")) - (package - (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/dns-client") - (commit commit))) - (file-name (git-file-name "cl-dns-client" version)) - (sha256 - (base32 "1b6g2wvydwmv1k68favjyq4gfalfxfyl5i0hyh640wdaz2rfvi4n")))) - (build-system asdf-build-system/sbcl) - (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 ecl-dns-client - (sbcl-package->ecl-package sbcl-dns-client)) - -(define-public cl-dns-client - (sbcl-package->cl-source-package sbcl-dns-client)) - -(define-public sbcl-lisp-pay - (let ((commit "c4de776f0a284709931ff3674160ced3b41bd000") - (revision "0")) - (package - (name "sbcl-lisp-pay") - (version (git-version "0.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/K1D77A/lisp-pay") - (commit commit))) - (file-name (git-file-name "cl-lisp-pay" version)) - (sha256 - (base32 "09r6qy4fipriqa0d6g9qm6dq992lr58vh24g5j0adm19i5fnjavh")))) - (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.") - (license license:expat)))) - -(define-public cl-lisp-pay - (sbcl-package->cl-source-package sbcl-lisp-pay)) - -(define-public ecl-lisp-pay - (sbcl-package->ecl-package sbcl-lisp-pay)) - -(define-public sbcl-stripe - (let ((commit "b59631d21d63e101de6eb96b56941471504ba644") - (revision "0")) - (package - (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-stripe - (sbcl-package->cl-source-package sbcl-stripe)) - -(define-public ecl-stripe - (sbcl-package->ecl-package sbcl-stripe)) - -(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 ecl-drakma - (sbcl-package->ecl-package sbcl-drakma)) - -(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") +(define-public sbcl-chirp + (let ((commit "01c79fa41939688216d1f86d0766a687becb0654") (revision "1")) (package - (name "sbcl-hunchentoot") - (version (git-version "1.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/edicl/hunchentoot") - (commit commit))) - (file-name (git-file-name "cl-hunchentoot" version)) - (sha256 - (base32 "1h7ggmmzvgwr4p6j3ai0dqrw30q5309l13w4c03gqrapvwrb65l0")))) - (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") - (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)))) - -(define-public cl-hunchentoot - (sbcl-package->cl-source-package sbcl-hunchentoot)) - -(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-hunchentoot-errors - (let ((commit "69eb3bcea59ed1ccf3dd1960e6d48fb21f1dadab") - (revision "0")) - (package - (name "sbcl-hunchentoot-errors") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/hunchentoot-errors") - (commit commit))) - (file-name (git-file-name "cl-hunchentoot-errors" version)) - (sha256 - (base32 "0fab7s8qhhs713cw014qqvzm5z61wmxm2fcbkarhg41cz3li9k1j")))) - (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") - (description - "This package provides a functionality augmenting Hunchentoot error -pages and logs with request and session information.") - (license license:expat)))) - -(define-public cl-hunchentoot-errors - (sbcl-package->cl-source-package sbcl-hunchentoot-errors)) - -(define-public ecl-hunchentoot-errors - (sbcl-package->ecl-package sbcl-hunchentoot-errors)) - -(define-public sbcl-lunamech-matrix-api - (let ((commit "aa54a820149584c237b03d500ad83397fe25dc92") - (revision "0")) - (package - (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/K1D77A/lunamech-matrix-api") - (commit commit))) - (file-name (git-file-name "cl-lunamech-matrix-api" version)) - (sha256 - (base32 "0a664qq4m5gk4iv5ck63gmsl3218jhjsalawklj56wn2pw0cf8a0")))) - (build-system asdf-build-system/sbcl) - (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.") - (license license:expat)))) - -(define-public cl-lunamech-matrix-api - (sbcl-package->cl-source-package sbcl-lunamech-matrix-api)) - -(define-public ecl-lunamech-matrix-api - (sbcl-package->ecl-package sbcl-lunamech-matrix-api)) - -(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")) - (package - (name "sbcl-cl-annot") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/m2ym/cl-annot") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n")))) - (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") - (description - "@code{cl-annot} is an general annotation library for Common Lisp.") - (license license:llgpl)))) - -(define-public cl-annot - (sbcl-package->cl-source-package sbcl-cl-annot)) - -(define-public ecl-cl-annot - (sbcl-package->ecl-package sbcl-cl-annot)) - -(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-utilities - (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b") - (revision "1")) - (package - (name "sbcl-cl-utilities") - (version (git-version "0.0.0" 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")) - (sha256 - (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2")))) - (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") - (description - "On Cliki.net , 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 cl-utilities - (sbcl-package->cl-source-package sbcl-cl-utilities)) - -(define-public ecl-cl-utilities - (sbcl-package->ecl-package sbcl-cl-utilities)) - -(define-public sbcl-map-set - (let ((commit "7b4b545b68b8") - (revision "1")) - (package - (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)) - -(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-myway - (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7") - (revision "1")) - (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)) - -(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-smart-buffer - (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62") - (revision "1")) - (package - (name "sbcl-smart-buffer") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/smart-buffer") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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-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)))) - -(define-public cl-smart-buffer - (sbcl-package->cl-source-package sbcl-smart-buffer)) - -(define-public ecl-smart-buffer - (sbcl-package->ecl-package sbcl-smart-buffer)) - -(define-public sbcl-fast-http - (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a") - (revision "2")) - (package - (name "sbcl-fast-http") + (name "sbcl-chirp") (version (git-version "0.2.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/fast-http") + (url "https://github.com/Shinmera/chirp") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "chirp" version)) (sha256 - (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi")))) + (base32 "10xlz1vwdv3jv48kmpndpnrg6672m0r5vsjgm2pksfl8bc05j2m0")))) (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))) + `(#:asd-systems '("chirp-core" "chirp-dexador" "chirp-drakma" "chirp"))) (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") + `(("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 - "@code{fast-http} is a HTTP request/response protocol parser for Common -Lisp.") - ;; Author specified the MIT license + "This package provides a Common Lisp Twitter client featuring full API +coverage.") + (license license:zlib)))) + +(define-public cl-chirp + (sbcl-package->cl-source-package sbcl-chirp)) + +(define-public ecl-chirp + (sbcl-package->ecl-package sbcl-chirp)) + +(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-fast-http - (sbcl-package->cl-source-package sbcl-fast-http)) +(define-public cl-chlorophyll + (sbcl-package->cl-source-package sbcl-chlorophyll)) -(define-public ecl-fast-http - (sbcl-package->ecl-package sbcl-fast-http)) +(define-public ecl-chlorophyll + (sbcl-package->ecl-package sbcl-chlorophyll)) -(define-public sbcl-static-vectors +(define-public sbcl-chronicity (package - (name "sbcl-static-vectors") - (version "1.8.9") + (name "sbcl-chronicity") + (version "0.4.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sionescu/static-vectors") + (url "https://github.com/chaitanyagupta/chronicity") (commit (string-append "v" version)))) - (file-name (git-file-name name version)) + (file-name (git-file-name "chronicity" version)) (sha256 - (base32 "079qa20lhanzsz1qf4iags91n0ziylbjgbcymm5a5qj7yryas4fw")))) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-alexandria sbcl-cffi)) + (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/sionescu/static-vectors") - (synopsis "Allocate SIMPLE-ARRAYs in static memory") + (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 - "With @code{static-vectors}, you can create vectors allocated in static -memory.") - (license license:expat))) + "CHRONICITY is Common Lisp natural language date and time parser inspired +by Ruby's @code{Chronic}.") + (license license:bsd-3))) -(define-public cl-static-vectors - (sbcl-package->cl-source-package sbcl-static-vectors)) +(define-public ecl-chronicity + (sbcl-package->ecl-package sbcl-chronicity)) -(define-public ecl-static-vectors - (sbcl-package->ecl-package sbcl-static-vectors)) +(define-public cl-chronicity + (sbcl-package->cl-source-package sbcl-chronicity)) -(define-public sbcl-marshal - (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec") - (revision "1")) - (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)))) - -(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-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-legion - (sbcl-package->cl-source-package sbcl-legion)) - -(define-public ecl-legion +(define-public sbcl-chunga (package - (inherit (sbcl-package->ecl-package sbcl-legion)) - (arguments - ;; Tests get stuck forever - (list #:tests? #f)))) - -(define-public sbcl-jonathan - (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300") - (revision "1")) - (package - (name "sbcl-jonathan") - (version (git-version "0.1.0" revision commit)) - (source - (origin + (name "sbcl-chunga") + (version "1.1.7") + (source + (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Rudolph-Miller/jonathan") - (commit commit))) + (url "https://github.com/edicl/chunga") + (commit (string-append "v" version)))) (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)))) + (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-jonathan - (sbcl-package->cl-source-package sbcl-jonathan)) +(define-public cl-chunga + (sbcl-package->cl-source-package sbcl-chunga)) -(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 ecl-chunga + (sbcl-package->ecl-package sbcl-chunga)) (define-public sbcl-ciel (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a") @@ -7323,2261 +3551,375 @@ reset to 0 and you're able to read it again.") (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)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/stacksmith/trivial-rfc-1123") - (commit commit))) - (file-name (git-file-name "cl-trivial-rfc-1123" version)) - (sha256 - (base32 "1w4ywpj10fnp7cya62dzlxlg8nyk4lppn2pnmfixsndwr4ib1h6x")))) - (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") - (description - "This package parses and prints dates in RFC-1123 format.") - (license license:bsd-3)))) - -(define-public cl-trivial-rfc-1123 - (sbcl-package->cl-source-package sbcl-trivial-rfc-1123)) - -(define-public ecl-trivial-rfc-1123 - (sbcl-package->ecl-package sbcl-trivial-rfc-1123)) - -(define-public sbcl-lack - (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") +(define-public sbcl-cl-abnf + ;; There are no releases + (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70") (revision "1")) (package - (name "sbcl-lack") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/lack") - (commit commit))) - (file-name (git-file-name "lack" version)) - (sha256 - (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) - (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") - (description - "Lack is a Common Lisp library which allows web applications to be -constructed of modular components. It was originally a part of Clack, however -it's going to be rewritten as an individual project since Clack v2 with -performance and simplicity in mind.") - (license license:llgpl)))) - -(define-public cl-lack - (sbcl-package->cl-source-package sbcl-lack)) - -(define-public ecl-lack - (sbcl-package->ecl-package sbcl-lack)) - -(define-public sbcl-cl-isaac - (let ((commit "9cd88f39733be753facbf361cb0e08b9e42ff8d5") - (revision "0")) - (package - (name "sbcl-cl-isaac") - (version (git-version "1.0.7" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/thephoeron/cl-isaac") - (commit commit))) - (file-name (git-file-name "cl-isaac" version)) - (sha256 - (base32 "0ig1mf8iridfr7vci9gy499194h0hda0xki5s6g0y04g85ibnpw9")))) - (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)))) - -(define-public cl-isaac - (sbcl-package->cl-source-package sbcl-cl-isaac)) - -(define-public ecl-cl-isaac - (sbcl-package->ecl-package sbcl-cl-isaac)) - -(define-public sbcl-local-time - (let ((commit "40169fe26d9639f3d9560ec0255789bf00b30036") - (revision "4")) - (package - (name "sbcl-local-time") - (version (git-version "1.0.6" revision commit)) + (name "sbcl-cl-abnf") + (version (git-version "0.0.0" 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")))) + (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 - `(#: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\".") + `(#: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-local-time - (sbcl-package->cl-source-package sbcl-local-time)) +(define-public cl-abnf + (sbcl-package->cl-source-package sbcl-cl-abnf)) -(define-public ecl-local-time - (sbcl-package->ecl-package sbcl-local-time)) +(define-public ecl-cl-abnf + (sbcl-package->ecl-package sbcl-cl-abnf)) -(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-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))) - -(define-public ecl-chronicity - (sbcl-package->ecl-package sbcl-chronicity)) - -(define-public cl-chronicity - (sbcl-package->cl-source-package sbcl-chronicity)) - -(define-public sbcl-trivial-mimes - (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9") - (revision "2")) +(define-public sbcl-cl-algebraic-data-type + (let ((commit "b2568428193a512d141d6b615772d50ceb5f9bca")) (package - (name "sbcl-trivial-mimes") - (version (git-version "1.1.0" revision commit)) + (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/Shinmera/trivial-mimes") + (url "https://github.com/stylewarning/cl-algebraic-data-type") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-algebraic-data-type" version)) (sha256 - (base32 "00kcm17q5plpzdj1qwg83ldhxksilgpcdkf3m9azxcdr968xs9di")))) + (base32 "1lnqxcv8pd5z8n0g5p2l0dbljx9pqiv18hxl0vhsh7ldhkrjv2jx")))) (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-trivial-mimes - (sbcl-package->cl-source-package sbcl-trivial-mimes)) - -(define-public ecl-trivial-mimes - (sbcl-package->ecl-package sbcl-trivial-mimes)) - -(define-public sbcl-ningle - (let ((commit "2e85675bbb668d6ef341514fc9f22391a0f506b1") - (revision "2")) - (package - (name "sbcl-ningle") - (version (git-version "0.3.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fukamachi/ningle") - (commit commit))) - (file-name (git-file-name "cl-ningle" version)) - (sha256 - (base32 "0s9nn8ml1j4839rycvdjcbsynkqnhxw1zmrgpjz48smscwdf1f8p")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:tests? #f)) ; TODO: pull in clack-test - (native-inputs - (list sbcl-prove)) - (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") - (description - "Clack is a web application environment for Common Lisp inspired by -Python's WSGI and Ruby's Rack.") - (license license:llgpl)))) - -(define-public cl-clack - (sbcl-package->cl-source-package sbcl-clack)) - -(define-public ecl-clack - (sbcl-package->ecl-package sbcl-clack)) - -(define-public sbcl-cl-log - (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837") - (revision "1")) - (package - (name "sbcl-cl-log") - (version "1.0.1") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/nicklevine/cl-log") - (commit commit))) - (sha256 - (base32 "1r3z9swy1b59swvaa5b97is9ysrfmjvjjhhw56p7p5hqg93b92ak")) - (file-name (git-file-name "cl-log" version)))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp general purpose logging utility") - (description "CL-LOG is a general purpose logging utility, loosely modelled -in some respects after Gary King's Log5. Its features include: logging to -several destinations at once, via \"messengers\", each messenger is tailored to -accept some log messages and reject others, and this tailoring can be changed -on-the-fly, very rapid processing of messages which are rejected by all -messengers, fully independent use of the utility by several different -sub-systems in an application, support for messengers which cl:format text to a -stream, support for messengers which do not invoke cl:format, timestamps in -theory accurate to internal-time-units-per-second.") - (home-page "https://github.com/nicklevine/cl-log") - (license license:expat)))) - -(define-public cl-log - (sbcl-package->cl-source-package sbcl-cl-log)) - -(define-public ecl-cl-log - (sbcl-package->ecl-package sbcl-cl-log)) - -(define-public sbcl-log4cl - (let ((commit "fe3da517147d023029782ced7cd989ba24f1e62d") - (revision "2")) - (package - (name "sbcl-log4cl") - (version (git-version "1.1.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/log4cl") - (commit commit))) - (file-name (git-file-name "cl-log4cl" version)) - (sha256 - (base32 "0n119sy35k9yl4n18az1sw9a7saa5jh3v44863b305by1p5xdy7k")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-stefil)) - (inputs - (list sbcl-bordeaux-threads)) - (home-page "https://github.com/7max/log4cl") - (synopsis "Common Lisp logging framework, modeled after Log4J") - (description - "This is a Common Lisp logging framework that can log at various levels -and mix text with expressions.") - (license license:asl2.0)))) - -(define-public cl-log4cl - (sbcl-package->cl-source-package sbcl-log4cl)) - -(define-public ecl-log4cl - (sbcl-package->ecl-package sbcl-log4cl)) - -(define-public sbcl-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 "cl-printv" version)) - (sha256 - (base32 "07agyzkwp3w2r4d2anrmr8h00yngpr5dq9mjd3m4kzhn1jcmilfb")))) - (build-system asdf-build-system/sbcl) - (inputs - (list figlet)) + sbcl-global-vars)) (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") + '(#:tests? #f)) ; No tests. + (home-page "https://github.com/stylewarning/cl-algebraic-data-type") + (synopsis "Common Lisp library for algebraic data types") (description - "@code{PRINTV} is a \"batteries-included\" tracing and debug-logging -macro for Common Lisp.") - (license license:asl2.0)))) + "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 ecl-printv - (sbcl-package->ecl-package sbcl-printv)) +(define-public cl-algebraic-data-type + (sbcl-package->cl-source-package sbcl-cl-algebraic-data-type)) -(define-public cl-printv - (sbcl-package->cl-source-package sbcl-printv)) +(define-public ecl-algebraic-data-type + (sbcl-package->ecl-package sbcl-cl-algebraic-data-type)) -(define-public sbcl-cl-debug - (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31") - (revision "1")) - (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)))) - -(define-public ecl-cl-debug - (sbcl-package->ecl-package sbcl-cl-debug)) - -(define-public cl-debug - (sbcl-package->cl-source-package sbcl-cl-debug)) - -(define-public sbcl-verbose - (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174") - (revision "1")) - (package - (name "sbcl-verbose") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/verbose/") - (commit commit))) - (file-name (git-file-name "verbose" version)) - (sha256 - (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6")))) - (build-system asdf-build-system/sbcl) - (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") - (description - "This is a Common Lisp library providing logging faciltiy similar to -@code{CL-LOG} and @code{LOG4CL}.") - (license license:zlib)))) - -(define-public ecl-verbose - (sbcl-package->ecl-package sbcl-verbose)) - -(define-public cl-verbose - (sbcl-package->cl-source-package sbcl-verbose)) - -(define-public sbcl-vgplot - (let ((commit "76329928a3709387c0779175af56ec49d16bcd35") +(define-public sbcl-cl-all + (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace") (revision "0")) (package - (name "sbcl-vgplot") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/volkers/vgplot") - (commit commit))) - (file-name (git-file-name "vgplot" version)) - (sha256 - (base32 "1vc5fd787xa8831wjbmwrpg17f9isi5k8dmb85fsysz47plbvi1y")))) - (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") - (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+)))) - -(define-public cl-vgplot - (sbcl-package->cl-source-package sbcl-vgplot)) - -(define-public ecl-vgplot - (sbcl-package->ecl-package sbcl-vgplot)) - -(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-find-port - (sbcl-package->cl-source-package sbcl-find-port)) - -(define-public ecl-find-port - (sbcl-package->ecl-package sbcl-find-port)) - -(define-public sbcl-numpy-file-format - (let ((commit "e440c7bbc0d86b9abf73acb0fa665b77b82a6c98") - (revision "2")) - (package - (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 cl-numpy-file-format - (sbcl-package->cl-source-package sbcl-numpy-file-format)) - -(define-public ecl-numpy-file-format - (sbcl-package->ecl-package sbcl-numpy-file-format)) - -(define-public sbcl-py4cl - (let ((commit "2f2a008dd6162d4446803971292fe1b323fe0dd5") - (revision "2")) - (package - (name "sbcl-py4cl") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/bendudson/py4cl") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1zx1kpfpd8mi1qaa7gr32mki6nvl6pqcs3437fvn4xa3yf7ybsha")) - (modules '((guix build utils))))) - (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 - (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 - "Py4CL is a bridge between Common Lisp and Python, which enables Common -Lisp to interact with Python code. It uses streams to communicate with a -separate python process, the approach taken by cl4py. This is different to -the CFFI approach used by burgled-batteries, but has the same goal.") - (home-page "https://github.com/bendudson/py4cl") - ;; MIT License - (license license:expat)))) - -(define-public cl-py4cl - (sbcl-package->cl-source-package sbcl-py4cl)) - -(define-public ecl-py4cl - (sbcl-package->ecl-package sbcl-py4cl)) - -(define-public sbcl-schemeish - (let ((commit "dff57bafae5d0cffa104c8fdc4146502f32d7f85") - (revision "1")) - (package - (name "sbcl-schemeish") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/chebert/schemeish") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0q9b07spmhg1b576cnnacvkf7zr3mab2rdydfylbn92y9mms9vyj")))) - (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)))) - -(define-public cl-schemeish - (sbcl-package->cl-source-package sbcl-schemeish)) - -(define-public ecl-schemeish - (sbcl-package->ecl-package sbcl-schemeish)) - -(define-public sbcl-parse-declarations - (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2") - (revision "1")) - (package - (name "sbcl-parse-declarations") + (name "sbcl-cl-all") (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/Shinmera/cl-all") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-all" version)) (sha256 - (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd")))) - (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) - #: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)))) - -(define-public cl-burgled-batteries3 - (sbcl-package->cl-source-package sbcl-burgled-batteries3)) - -(define-public ecl-burgled-batteries3 - (sbcl-package->ecl-package sbcl-burgled-batteries3)) - -(define-public sbcl-metabang-bind - (let ((commit "08196426cb099db0623e6cae2aeca566e0b788b2") - (revision "2")) - (package - (name "sbcl-metabang-bind") - (version (git-version "0.8.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/metabang-bind") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "14g7k3zhm8cd6bssc5mm5h6iq1dv5lfhiq33aimcmj5a6vbiq47d")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lift)) - (synopsis "Macro that generalizes @code{multiple-value-bind} etc.") - (description - "Bind extends the idea of of let and destructing to provide a uniform -syntax for all your accessor needs. It combines @code{let}, -@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure -editing, property or association-lists, and @code{multiple-value-bind} and a -whole lot more into a single form.") - (home-page "https://common-lisp.net/project/metabang-bind/") - ;; MIT License - (license license:expat)))) - -(define-public cl-metabang-bind - (sbcl-package->cl-source-package sbcl-metabang-bind)) - -(define-public ecl-metabang-bind - (sbcl-package->ecl-package sbcl-metabang-bind)) - -(define-public sbcl-fare-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 cl-fare-csv - (sbcl-package->cl-source-package sbcl-fare-csv)) - -(define-public ecl-fare-csv - (sbcl-package->ecl-package sbcl-fare-csv)) - -(define-public sbcl-fare-utils - (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724") - (revision "1")) - (package - (name "sbcl-fare-utils") - (version (git-version "1.0.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url - "https://gitlab.common-lisp.net/frideau/fare-utils.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-hu.dwim.stefil)) - (synopsis "Collection of utilities and data structures") - (description - "fare-utils is a small collection of utilities. It contains a lot of -basic everyday functions and macros.") - (home-page "https://gitlab.common-lisp.net/frideau/fare-utils") - ;; MIT License - (license license:expat)))) - -(define-public cl-fare-utils - (sbcl-package->cl-source-package sbcl-fare-utils)) - -(define-public ecl-fare-utils - (sbcl-package->ecl-package sbcl-fare-utils)) - -(define-public sbcl-fare-mop - (let ((commit "538aa94590a0354f382eddd9238934763434af30") - (revision "1")) - (package - (name "sbcl-fare-mop") - (version (git-version "1.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fare/fare-mop") - (commit commit))) - (file-name (git-file-name "fare-mop" version)) - (sha256 - (base32 - "0maxs8392953fhnaa6zwnm2mdbhxjxipp4g4rvypm06ixr6pyv1c")))) - (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") - (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 ecl-fare-mop - (sbcl-package->ecl-package sbcl-fare-mop)) - -(define-public cl-fare-mop - (sbcl-package->cl-source-package sbcl-fare-mop)) - -(define-public sbcl-inferior-shell - (let ((commit "15c2d04a7398db965ea1c3ba2d49efa7c851f2c2") - (revision "1")) - (package - (name "sbcl-inferior-shell") - (version (git-version "2.0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/fare/inferior-shell") - (commit commit))) - (file-name (git-file-name "inferior-shell" version)) - (sha256 - (base32 "02qx37zzk5j4xmwh77k2qa2wvnzvaj6qml5dh2q7b6b1ljvgcj4m")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (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 - "This package provides a Common Lisp system helping in scripting, it -uses @code{uiop:run-program} as a backend.") - (license license:expat)))) - -(define-public ecl-inferior-shell - (sbcl-package->ecl-package sbcl-inferior-shell)) - -(define-public cl-inferior-shell - (sbcl-package->cl-source-package sbcl-inferior-shell)) - -(define-public sbcl-cl-gss - (let ((commit "60086f4fd3b82316352e7f2288edbd58f03e08c5") - (revision "1")) - (package - (name "sbcl-cl-gss") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lokedhs/cl-gss") - (commit commit))) - (file-name (git-file-name "cl-gss" version)) - (sha256 - (base32 "0zhxxn3zarird255s9i56bz0fm6dkv00mn8bbsjrhskg3wpcg4pb")))) + (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp")))) (build-system asdf-build-system/sbcl) + (outputs '("out" "bin")) (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 - "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)))) + (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-cl-gss - (sbcl-package->ecl-package sbcl-cl-gss)) +(define-public cl-all + (sbcl-package->cl-source-package sbcl-cl-all)) -(define-public cl-gss - (sbcl-package->cl-source-package sbcl-cl-gss)) - -(define-public sbcl-trivial-utf-8 - (let ((commit "6ca9943588cbc61ad22a3c1ff81beb371e122394") +(define-public sbcl-cl-ana + (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e") (revision "2")) (package - (name "sbcl-trivial-utf-8") + (name "sbcl-cl-ana") (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 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-trivial-utilities") - (version (git-version "0.4.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.com/ediethelm/trivial-utilities") + (url "https://github.com/ghollisjr/cl-ana") (commit commit))) - (file-name (git-file-name "trivial-utilities" version)) + (file-name (git-file-name "cl-ana" version)) (sha256 - (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 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 ecl-swap-bytes - (sbcl-package->ecl-package sbcl-swap-bytes)) - -(define-public sbcl-iolib - (let ((commit "010b7a6bdd2e918ebf2ec85edd3853179f01cb30") - (revision "0")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name "cl-iolib" version)) - (sha256 - (base32 "1qqy2yhprkmdn2vmi69akf818q3n99gv8cacv6456af0wjm5p1ga")))) + (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y")))) (build-system asdf-build-system/sbcl) (native-inputs - (list pkg-config sbcl-fiveam)) + (list openmpi ;; for hdf-cffi + pkg-config + sbcl-cl-fad)) (inputs - (list libfixposix - sbcl-alexandria - sbcl-bordeaux-threads + (list gsl + hdf5-parallel-openmpi + libffi + sbcl-antik sbcl-cffi - sbcl-idna - sbcl-split-sequence - sbcl-swap-bytes)) + 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 - '(#:asd-systems '("iolib" - "iolib/os") + (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 + "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 cl-ana + (sbcl-package->cl-source-package sbcl-cl-ana)) + +(define-public sbcl-cl-annot + (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d") + (revision "1")) + (package + (name "sbcl-cl-annot") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/m2ym/cl-annot") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n")))) + (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") + (description + "@code{cl-annot} is an general annotation library for Common Lisp.") + (license license:llgpl)))) + +(define-public cl-annot + (sbcl-package->cl-source-package sbcl-cl-annot)) + +(define-public ecl-cl-annot + (sbcl-package->ecl-package sbcl-cl-annot)) + +(define-public sbcl-cl-ansi-text + (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c")) + (package + (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/pnathan/cl-ansi-text") + (commit commit))) + (sha256 + (base32 + "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14")) + (file-name (git-file-name "cl-ansi-text" version)))) + (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") + (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)))) + +(define-public cl-ansi-text + (sbcl-package->cl-source-package sbcl-cl-ansi-text)) + +(define-public ecl-cl-ansi-text + (sbcl-package->ecl-package sbcl-cl-ansi-text)) + +(define-public sbcl-cl-ascii-table + (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2") + (revision "1")) + (package + (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/telephil/cl-ascii-table") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s")))) + (build-system asdf-build-system/sbcl) + (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-ascii-table + (sbcl-package->cl-source-package sbcl-cl-ascii-table)) + +(define-public ecl-cl-ascii-table + (sbcl-package->ecl-package sbcl-cl-ascii-table)) + +(define-public sbcl-cl-async + (let ((commit "f6423e44404a44434d803605e0d2e17199158e28") + (revision "1")) + (package + (name "sbcl-cl-async") + (version (git-version "0.6.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/orthecreedence/cl-async") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x")))) + (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/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-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-iolib - (sbcl-package->ecl-package sbcl-iolib)) - -(define-public sbcl-ieee-floats - (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d") - (revision "1")) - (package - (name "sbcl-ieee-floats") - (build-system asdf-build-system/sbcl) - (version (git-version "20170924" revision commit)) - (home-page "https://github.com/marijnh/ieee-floats/") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m")))) - (native-inputs - (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 sbcl-closure-common - (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c") - (revision "1")) - (package - (name "sbcl-closure-common") - (build-system asdf-build-system/sbcl) - (version (git-version "20101006" revision commit)) - (home-page "https://common-lisp.net/project/cxml/") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/closure-common") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n")))) - (inputs - `(("trivial-gray-streams" ,sbcl-trivial-gray-streams) - ("babel" ,sbcl-babel))) - (synopsis "Support Common Lisp library for CXML") - (description "Closure-common is an internal helper library. The name -Closure is a reference to the web browser it was originally written for.") - ;; TODO: License? - (license #f)))) - -(define-public sbcl-cxml - (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf") - (revision "1")) - (package - (name "sbcl-cxml") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/cxml") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37")))) - (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)))) - -(define-public cl-cxml - (sbcl-package->cl-source-package sbcl-cxml)) - -(define-public ecl-cxml - (sbcl-package->ecl-package sbcl-cxml)) - -(define-public sbcl-cxml-rng - (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b") - (revision "1")) - (package - (name "sbcl-cxml-rng") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://www.lichteblau.com/git/cxml-rng.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql")))) - (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)))) - -(define-public cl-cxml-rng - (sbcl-package->cl-source-package sbcl-cxml-rng)) - -;; FIXME: Fails on ECL with -;; In function STRUCTURE-SET, the value of the first argument is -;; # -;; which is not of the expected type %TYPED-PATTERN. -;; (define-public ecl-cxml-rng -;; (sbcl-package->ecl-package sbcl-cxml-rng)) - -(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 "https://github.com/takagi/cl-reexport") - (commit commit))) - (file-name (git-file-name "cl-reexport" version)) - (sha256 - (base32 - "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc")))) - (inputs - (list sbcl-alexandria)) - (native-inputs - (list sbcl-prove)) - (synopsis "Reexport external symbols in other Common Lisp packages") + (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 - "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-reexport - (sbcl-package->cl-source-package sbcl-cl-reexport)) - -(define-public ecl-cl-reexport - (sbcl-package->ecl-package sbcl-cl-reexport)) - -(define-public sbcl-cl-cookie - (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546") - (revision "1")) - (package - (name "sbcl-cl-cookie") - (build-system asdf-build-system/sbcl) - (version (git-version "0.9.10" revision commit)) - (home-page "https://github.com/fukamachi/cl-cookie") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h")))) - (inputs - `(("proc-parse" ,sbcl-proc-parse) - ("alexandria" ,sbcl-alexandria) - ("quri" ,sbcl-quri) - ("cl-ppcre" ,sbcl-cl-ppcre) - ("local-time" ,sbcl-local-time))) - (native-inputs - (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)))) - -(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-dexador - (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5") - (revision "2")) - (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") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name "cl-dexador" 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.") + "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-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-async + (sbcl-package->cl-source-package sbcl-cl-async)) -(define-public ecl-dexador - (sbcl-package->ecl-package sbcl-dexador)) +(define-public ecl-cl-async + (sbcl-package->ecl-package sbcl-cl-async)) -(define-public sbcl-lisp-namespace - (let ((commit "699fccb6727027343bb5fca69162a3113996edfc") - (revision "2")) +(define-public sbcl-cl-async-future + (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959") + (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-async-future") + (version (git-version "0.4.4.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name "cl-lisp-namespace" version)) - (sha256 - (base32 "1p5db9mab4whapy1pl38ajw5fkrrdw266n05mnhf4xx2fb9sbx6p")))) - (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.") - (license license:llgpl)))) - -(define-public cl-lisp-namespace - (sbcl-package->cl-source-package sbcl-lisp-namespace)) - -(define-public ecl-lisp-namespace - (sbcl-package->ecl-package sbcl-lisp-namespace)) - -(define-public sbcl-trivial-cltl2 - (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61") - (revision "2")) - (package - (name "sbcl-trivial-cltl2") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1.1" revision commit)) - (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) + (url "https://github.com/orthecreedence/cl-async-future") (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)))) - -(define-public cl-trivial-cltl2 - (sbcl-package->cl-source-package sbcl-trivial-cltl2)) - -(define-public ecl-trivial-cltl2 - (sbcl-package->ecl-package sbcl-trivial-cltl2)) - -(define-public sbcl-introspect-environment - (let ((commit "8fb20a1a33d29637a22943243d1482a20c32d6ae") - (revision "2")) - (package - (name "sbcl-introspect-environment") - (build-system asdf-build-system/sbcl) - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/Bike/introspect-environment") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name "cl-introspect-environment" 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")))) - (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)))) - -(define-public cl-compiler-macro - (sbcl-package->cl-source-package sbcl-compiler-macro)) - -(define-public ecl-compiler-macro - (sbcl-package->ecl-package sbcl-compiler-macro)) - -(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 cl-type-i - (sbcl-package->cl-source-package sbcl-type-i)) - -(define-public ecl-type-i - (package - (inherit (sbcl-package->ecl-package sbcl-type-i)) - (arguments - ;; The tests get stuck indefinitly - '(#:tests? #f)))) - -(define-public sbcl-simplified-types - (let ((commit "8fd0727a70a9de76289ac62c1567b8d278e7434e") - (revision "0")) - (package - (name "sbcl-simplified-types") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/marcoheisig/simplified-types") - (commit commit))) - (file-name (git-file-name "cl-simplified-types" version)) - (sha256 - (base32 "1hdwmn5lz717aj6qdqmfmr3cbjl8l3giwn0fb5ca9pj83cx7fg8y")))) + "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-alexandria - sbcl-introspect-environment - sbcl-trivia)) - (home-page "https://github.com/marcoheisig/simplified-types") - (synopsis "Simplify Common Lisp type specifiers") + (list sbcl-blackbird)) + (native-inputs + (list sbcl-cl-async sbcl-eos)) + (synopsis "Futures implementation for Common Lisp") (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") + "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-simplified-types - (sbcl-package->cl-source-package sbcl-simplified-types)) +(define-public cl-async-future + (sbcl-package->cl-source-package sbcl-cl-async-future)) -(define-public ecl-simplified-types - (sbcl-package->ecl-package sbcl-simplified-types)) - -(define-public sbcl-typo - (let ((commit "0e883490f81edf2a1be4e5b101d1caec78d7853b") - (revision "0")) - (package - (name "sbcl-typo") - (version (git-version "0.0.0" revision commit)) - (source - (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) - (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)) - -(define-public ecl-typo - (sbcl-package->ecl-package sbcl-typo)) - -(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-fare-quasiquote - (let ((commit "640d39a0451094071b3e093c97667b3947f43639") - (revision "1")) - (package - (name "sbcl-fare-quasiquote") - (build-system asdf-build-system/sbcl) - (version (git-version "1.0.1" revision commit)) - (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote") - (source - (origin - (method git-fetch) - (uri (git-reference - (url (string-append "https://gitlab.common-lisp.net/frideau/" - "fare-quasiquote.git")) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg")))) - (inputs - `(("fare-utils" ,sbcl-fare-utils) - ("named-readtables" ,sbcl-named-readtables) - ("optima" ,sbcl-optima))) - (arguments - ;; 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 - ;; 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-fare-quasiquote - (sbcl-package->cl-source-package sbcl-fare-quasiquote)) - -(define-public ecl-fare-quasiquote - (sbcl-package->ecl-package sbcl-fare-quasiquote)) - -;;; 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-trivia.trivial") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/guicho271828/trivia") - (commit commit))) - (file-name (git-file-name "cl-trivia" version)) - (sha256 - (base32 - "0fnnjnba07qrsf82jm4q6dini7z72xabcssy5y2bqy082r07l8l7")))) - (build-system asdf-build-system/sbcl) - (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-trivia.trivial - (sbcl-package->cl-source-package sbcl-trivia.trivial)) - -(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 sbcl-cl-xmlspam - (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a")) - (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") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (string-append name "-" version)) - (sha256 - (base32 - "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-xmlspam - (sbcl-package->cl-source-package sbcl-cl-xmlspam)) - -(define-public ecl-cl-xmlspam - (sbcl-package->ecl-package sbcl-cl-xmlspam)) - -(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-dbus - (sbcl-package->cl-source-package sbcl-dbus)) - -(define-public ecl-dbus - (sbcl-package->ecl-package sbcl-dbus)) - -(define-public sbcl-cl-hooks - (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7") - (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") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y")))) - (inputs - (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. - -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: - -@itemize - -@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 ecl-cl-async-future + (sbcl-package->ecl-package sbcl-cl-async-future)) (define-public sbcl-cl-autowrap (let ((revision "2") @@ -9616,189 +3958,538 @@ extension-points via the concept of hooks.") (define-public ecl-cl-autowrap (sbcl-package->ecl-package sbcl-cl-autowrap)) -(define-public sbcl-s-sysdeps - ;; No release since 2013. - (let ((commit "7f8de283b7fbd8b038fdf08493063a736db36ce7") - (revision "3")) - (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") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0rp81iq0rgl48qdwbmfy89glga81hmry2lp8adjbr5h5ybr92b4n")))) - (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)))) - -(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-cl-prevalence - (let ((commit "e6b27640ce89ae5f8af38beb740e319bb6cd2368") - (revision "6")) - (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") - (source - (origin - (method git-fetch) - (uri (git-reference - (url home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0")))) - (inputs - (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml)) - (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)) - -(define-public sbcl-series - (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a") +(define-public sbcl-cl-base32 + (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85") (revision "1")) (package - (name "sbcl-series") - (version (git-version "2.2.11" revision commit)) + (name "sbcl-cl-base32") + (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "git://git.code.sf.net/p/series/series") + (url "https://github.com/hargettp/cl-base32") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw")))) - (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") - (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/") - (license license:expat)))) - -(define-public cl-series - (sbcl-package->cl-source-package sbcl-series)) - -(define-public ecl-series - (sbcl-package->ecl-package sbcl-series)) - -(define-public sbcl-periods - (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949") - (revision "2")) - (package - (name "sbcl-periods") - (version (git-version "0.0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jwiegley/periods") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("local-time" ,sbcl-local-time) - ("series" ,sbcl-series))) - (arguments - '(#:asd-systems '("periods" - "periods-series"))) - (synopsis "Common Lisp library for manipulating date/time objects") - (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") - (license license:bsd-3)))) - -(define-public cl-periods - (sbcl-package->cl-source-package sbcl-periods)) - -(define-public ecl-periods - (sbcl-package->ecl-package sbcl-periods)) - -(define-public sbcl-metatilities-base - (let ((commit "ef04337759972fd622c9b27b53149f3d594a841f") - (revision "2")) - (package - (name "sbcl-metatilities-base") - (version (git-version "0.6.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/metatilities-base") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "069rk5ncwvjnnzvvky6xiriynl72yzvjpnzl6jw9jf3b8na14zrk")))) + (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-lift)) - (synopsis "Core of the metatilities Common Lisp library") + (list sbcl-lisp-unit)) + (synopsis "Common Lisp library for base32 encoding and decoding") (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/") + "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-metatilities-base - (sbcl-package->cl-source-package sbcl-metatilities-base)) +(define-public cl-base32 + (sbcl-package->cl-source-package sbcl-cl-base32)) -(define-public ecl-metatilities-base - (sbcl-package->ecl-package sbcl-metatilities-base)) +(define-public ecl-cl-base32 + (sbcl-package->ecl-package sbcl-cl-base32)) + +(define-public sbcl-cl-base58 + (let ((commit "f446835b4104896e0eed6a61d2ceb4ad22f589d8") + (revision "1")) + (package + (name "sbcl-cl-base58") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eudoxia0/cl-base58/") + (commit commit))) + (file-name (git-file-name "cl-base58" version)) + (sha256 + (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-prove)) + (home-page "https://github.com/eudoxia0/cl-base58") + (synopsis "Implementation of base58 for Common Lisp") + (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)))) + +(define-public cl-base58 + (sbcl-package->cl-source-package sbcl-cl-base58)) + +(define-public ecl-cl-base58 + (sbcl-package->ecl-package sbcl-cl-base58)) + +(define-public sbcl-cl-base64 + (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a")) + (package + (name "sbcl-cl-base64") + (version (git-version "3.3.4" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "http://git.kpe.io/cl-base64.git/") + (commit commit))) + (file-name (git-file-name name 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)))) + (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") + (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)))) + +(define-public cl-base64 + (sbcl-package->cl-source-package sbcl-cl-base64)) + +(define-public ecl-cl-base64 + (sbcl-package->ecl-package sbcl-cl-base64)) + +(define-public sbcl-cl-cairo2 + (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b") + (revision "1")) + (package + (name "sbcl-cl-cairo2") + (version (git-version "0.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rpav/cl-cairo2") + (commit commit))) + (file-name (git-file-name "cl-cairo2" version)) + (sha256 + (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 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 package provides CFFI bindings for Common Lisp to the Cairo +C library.") + (license license:boost1.0)))) + +(define-public cl-cairo2 + (sbcl-package->cl-source-package sbcl-cl-cairo2)) + +(define-public ecl-cl-cairo2 + (sbcl-package->ecl-package sbcl-cl-cairo2)) + +(define-public sbcl-cl-cffi-gtk + (let ((commit "1700fe672c65455c1fc33061ec92a3df84287ec7") + (revision "3")) + (package + (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/sharplispers/cl-cffi-gtk/") + (commit commit))) + (file-name (git-file-name "cl-cffi-gtk" version)) + (sha256 + (base32 "1cn2f6b62axjzdzfv971218ably32dvqfdy499li25vjd8nb2qm3")))) + (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") + (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)))) + +(define-public cl-cffi-gtk + (sbcl-package->cl-source-package sbcl-cl-cffi-gtk)) + +(define-public ecl-cl-cffi-gtk + (sbcl-package->ecl-package sbcl-cl-cffi-gtk)) + +(define-public sbcl-cl-change-case + (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022") + (revision "1")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name "cl-change-case" version)) + (sha256 + (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode)) + (native-inputs + (list sbcl-fiveam)) + (synopsis + "Convert Common Lisp strings between camelCase, PascalCase and more") + (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)) + +(define-public ecl-cl-change-case + (sbcl-package->ecl-package sbcl-cl-change-case)) + +(define-public sbcl-cl-charms + (let ((commit "64aba59d89f85bc5c9402e445873965338a66a02") + (revision "1")) + (package + (name "sbcl-cl-charms") + (version (git-version "0.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/HiTECNOLOGYs/cl-charms") + (commit commit))) + (file-name (git-file-name "cl-charms" version)) + (sha256 + (base32 "1jczaypa9dhxr34yyhsxb6lrdnircjx8am4iqkc3shfpjn32q323")))) + (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)))) + +(define-public cl-charms + (sbcl-package->cl-source-package sbcl-cl-charms)) + +(define-public ecl-cl-charms + (sbcl-package->ecl-package sbcl-cl-charms)) + +(define-public sbcl-cl-collider + (let ((commit "a46908896982868955b29bfb3a5337a0af489b0b") + (revision "0")) + (package + (name "sbcl-cl-collider") + (version (git-version "2018.7.15" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/byulparan/cl-collider") + (commit commit))) + (file-name (git-file-name "cl-collider" 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)))) + +(define-public cl-collider + (sbcl-package->cl-source-package sbcl-cl-collider)) + +(define-public ecl-cl-collider + (sbcl-package->ecl-package sbcl-cl-collider)) + +(define-public sbcl-cl-colors + (let ((commit "827410584553f5c717eec6182343b7605f707f75")) + (package + (name "sbcl-cl-colors") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tpapp/cl-colors") + (commit commit))) + (sha256 + (base32 + "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a")) + (file-name (git-file-name "cl-colors" version)))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-let-plus)) + (synopsis "Simple color library for Common Lisp") + (description + "This is a very simple color library for Common Lisp, providing + +@itemize +@item Types for representing colors in HSV and RGB spaces. +@item Simple conversion functions between the above types (and also +hexadecimal representation for RGB). +@item Some predefined colors (currently X11 color names – of course the +library does not depend on X11).Because color in your terminal is nice. +@end itemize + +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 ecl-cl-colors + (sbcl-package->ecl-package sbcl-cl-colors)) + +(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 ecl-cl-colors2 + (sbcl-package->ecl-package sbcl-cl-colors2)) + +(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 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://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") + (description + "This is a library that implements delimited continuations by +transforming Common Lisp code to continuation passing style.") + (home-page "https://common-lisp.net/project/cl-cont/") + (license license:llgpl)))) + +(define-public cl-cont + (sbcl-package->cl-source-package sbcl-cl-cont)) + +(define-public ecl-cl-cont + (sbcl-package->ecl-package sbcl-cl-cont)) (define-public sbcl-cl-containers (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f") @@ -9856,362 +4547,1004 @@ decisions becomes significantly easier.") (define-public ecl-cl-containers (sbcl-package->ecl-package sbcl-cl-containers)) -(define-public sbcl-cambl - (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636") +(define-public sbcl-cl-cookie + (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546") (revision "1")) (package - (name "sbcl-cambl") - (version (git-version "4.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jwiegley/cambl") - (commit commit))) - (file-name (git-file-name "cambl" version)) - (sha256 - (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz")))) + (name "sbcl-cl-cookie") (build-system asdf-build-system/sbcl) - (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") - (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)))) - -(define-public cl-cambl - (sbcl-package->cl-source-package sbcl-cambl)) - -(define-public ecl-cambl - (sbcl-package->ecl-package sbcl-cambl)) - -(define-public sbcl-cl-ledger - (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b") - (revision "1")) - (package - (name "sbcl-cl-ledger") - (version (git-version "4.0.0" revision commit)) + (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 "https://github.com/ledger/cl-ledger") + (url home-page) (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1")))) - (build-system asdf-build-system/sbcl) + "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h")))) (inputs - `(("cambl" ,sbcl-cambl) + `(("proc-parse" ,sbcl-proc-parse) + ("alexandria" ,sbcl-alexandria) + ("quri" ,sbcl-quri) ("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-ledger - (sbcl-package->cl-source-package sbcl-cl-ledger)) - -(define-public ecl-cl-ledger - (sbcl-package->ecl-package sbcl-cl-ledger)) - -(define-public sbcl-bst - (let ((commit "8545aed0d504df2829ad139566feeabe22305388") - (revision "0")) - (package - (name "sbcl-bst") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/bst") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8")))) - (build-system asdf-build-system/sbcl) + ("local-time" ,sbcl-local-time))) (native-inputs - (list sbcl-alexandria sbcl-fiveam)) - (synopsis "Binary search tree 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)))) + (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)))) -(define-public cl-bst - (sbcl-package->cl-source-package sbcl-bst)) +(define-public cl-cookie + (sbcl-package->cl-source-package sbcl-cl-cookie)) -(define-public ecl-bst - (sbcl-package->ecl-package sbcl-bst)) +(define-public ecl-cl-cookie + (sbcl-package->ecl-package sbcl-cl-cookie)) -(define-public sbcl-trivial-octet-streams - (let ((commit "bc5d398b18549fd42e9c2a365df28ad865f1b85d") - (revision "0")) +(define-public sbcl-cl-coroutine + (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72") + (revision "1")) (package - (name "sbcl-trivial-octet-streams") + (name "sbcl-cl-coroutine") (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/sharplispers/trivial-octet-streams") + (url "https://github.com/takagi/cl-coroutine") (commit commit))) - (file-name (git-file-name "cl-trivial-octet-streams" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0ysnsarlzynb7jf4b63b6kkxjancxc66jwmn0sb3vxyh87siiv6n")))) + (base32 + "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/sharplispers/trivial-octet-streams") - (synopsis "In-memory octet streams for Common Lisp") + (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 - "TRIVIAL-OCTET-STREAMS is a Common Lisp library implementing in-memory -octet streams analogous to string streams.") - (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-trivial-octet-streams - (sbcl-package->cl-source-package sbcl-trivial-octet-streams)) +(define-public cl-coroutine + (sbcl-package->cl-source-package sbcl-cl-coroutine)) -(define-public ecl-trivial-octet-streams - (sbcl-package->ecl-package sbcl-trivial-octet-streams)) +(define-public ecl-cl-coroutine + (sbcl-package->ecl-package sbcl-cl-coroutine)) -(define-public sbcl-cl-octet-streams +(define-public sbcl-cl-cpus (package - (name "sbcl-cl-octet-streams") - (version "1.2") + (name "sbcl-cl-cpus") + (version "0.0.3") (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/cl-octet-streams") + (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 cl-cpus + (sbcl-package->cl-source-package sbcl-cl-cpus)) + +(define-public ecl-cl-cpus + (sbcl-package->ecl-package sbcl-cl-cpus)) + +(define-public sbcl-cl-cron + (let ((commit "092aef5d5666fb43c04258e4043f609670a20456") + (revision "0")) + (package + (name "sbcl-cl-cron") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ciel-lang/cl-cron") + (commit commit))) + (file-name (git-file-name "cl-cron" version)) + (sha256 + (base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d")))) + (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") + (description + "@code{cl-cron} is a simple tool that provides cron like facilities +directly inside of Common Lisp.") + (license license:gpl3+)))) + +(define-public cl-cron + (sbcl-package->cl-source-package sbcl-cl-cron)) + +(define-public ecl-cl-cron + (sbcl-package->ecl-package sbcl-cl-cron)) + +(define-public sbcl-cl-css + (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f")) + (package + (name "sbcl-cl-css") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/inaimathi/cl-css/") + (commit commit))) + (file-name (git-file-name "cl-css" version)) + (sha256 + (base32 + "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/inaimathi/cl-css/") + (synopsis "Non-validating, inline CSS generator for Common Lisp") + (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)))) + +(define-public cl-css + (sbcl-package->cl-source-package sbcl-cl-css)) + +(define-public ecl-cl-css + (sbcl-package->ecl-package sbcl-cl-css)) + +(define-public sbcl-cl-csv + (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651") + (revision "2")) + (package + (name "sbcl-cl-csv") + (version (git-version "1.0.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AccelerationNet/cl-csv") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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-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-csv + (sbcl-package->cl-source-package sbcl-cl-csv)) + +(define-public ecl-cl-csv + (sbcl-package->ecl-package sbcl-cl-csv)) + +(define-public sbcl-cl-debug + (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31") + (revision "1")) + (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)))) + +(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/dkochmanski/cl-dejavu") + (commit commit))) + (file-name (git-file-name "cl-dejavu" version)) + (sha256 + (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0")))) + (build-system asdf-build-system/sbcl) + (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-dejavu + (sbcl-package->cl-source-package sbcl-cl-dejavu)) + +(define-public ecl-dejavu + (sbcl-package->ecl-package sbcl-cl-dejavu)) + +(define-public sbcl-cl-difflib + (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e") + (revision "0")) + (package + (name "sbcl-cl-difflib") + (version (git-version "0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/wiseman/cl-difflib") + (commit commit))) + (file-name + (git-file-name name version)) + (sha256 + (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48")))) + (build-system asdf-build-system/sbcl) + ;; 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 + "A Common Lisp library for computing differences between +sequences based on the Python difflib module.") + (license license:expat)))) + +(define-public cl-difflib + (sbcl-package->cl-source-package sbcl-cl-difflib)) + +(define-public ecl-cl-difflib + (sbcl-package->ecl-package sbcl-cl-difflib)) + +(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 cl-diskspace + (sbcl-package->cl-source-package sbcl-cl-diskspace)) + +(define-public ecl-cl-diskspace + (sbcl-package->ecl-package sbcl-cl-diskspace)) + +(define-public sbcl-cl-docutils + (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40") + (revision "1")) + (package + (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/michaelw/cl-dot") + (commit commit))) + (file-name (git-file-name "cl-dot" version)) + (sha256 + (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/michaelw/cl-dot") + (synopsis "Generate Graphviz dot output from arbitrary Lisp data") + (description + "CL-DOT is a Common Lisp library for generating Graphviz dot output from +arbitrary Lisp data.") + (license license:expat)))) + +(define-public cl-dot + (sbcl-package->cl-source-package sbcl-cl-dot)) + +(define-public ecl-cl-dot + (sbcl-package->ecl-package sbcl-cl-dot)) + +(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-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 cl-environments + (sbcl-package->cl-source-package sbcl-cl-environments)) + +(define-public ecl-cl-environments + (sbcl-package->ecl-package sbcl-cl-environments)) + +(define-public sbcl-cl-fad + ;; No release since 2019 + (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535") + (revision "1")) + (package + (name "sbcl-cl-fad") + (version (git-version "0.7.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/cl-fad/") + (commit commit))) + (sha256 + (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)) + (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)))) + +(define-public cl-fad + (sbcl-package->cl-source-package sbcl-cl-fad)) + +(define-public ecl-cl-fad + (sbcl-package->ecl-package sbcl-cl-fad)) + +(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-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-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 cl-flac + (sbcl-package->cl-source-package sbcl-cl-flac)) + +(define-public ecl-cl-flac + (sbcl-package->ecl-package sbcl-cl-flac)) + +(define-public sbcl-cl-fond + (let ((commit "dac975cbc73f231b400d5b8d8539b16330239a4a") + (revision "1")) + (package + (name "sbcl-cl-fond") + (version (git-version "1.1.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)) + (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.") + (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-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 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8")))) + (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)) - (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+))) + (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. -(define-public cl-octet-streams - (sbcl-package->cl-source-package sbcl-cl-octet-streams)) +In order for this library to work the values types of variables and return +types of functions have to be declared. -(define-public ecl-cl-octet-streams - (sbcl-package->ecl-package sbcl-cl-octet-streams)) +Macros and symbol-macros are fully expanded and all special forms, except +@code{CATCH}, are supported.") + (license license:expat))) -(define-public sbcl-in-memory-streams - (let ((commit "bb4ce9c8c08479c9904f5d29f2b6187f264dc620") - (revision "1")) +(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 - (name "sbcl-in-memory-streams") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/cl-in-memory-streams") - (commit commit))) - (file-name (git-file-name "cl-in-memory-streams" version)) - (sha256 - (base32 "1fls1jnkf86wimip6f95y496sc4rxpsh2y65lgqsqpi0yda5xl2f")))) - (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+)))) - -(define-public cl-in-memory-streams - (sbcl-package->cl-source-package sbcl-in-memory-streams)) - -(define-public ecl-in-memory-streams - (sbcl-package->ecl-package sbcl-in-memory-streams)) - -(define-public sbcl-lzlib - (let ((commit "22767ca12d1c1bd59a7ae1f9c5ef7d2e937206bb") - (revision "2")) - (package - (name "sbcl-lzlib") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/cl-lzlib") - (commit commit))) - (file-name (git-file-name "cl-lzlib" version)) - (sha256 - (base32 "1dxzlkay7aqcs65h2f7j7rl4sdjija60dshlahzyllfw174p9d3m")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list lzlib - sbcl-cffi - sbcl-cl-octet-streams - sbcl-lparallel)) + (inherit pkg) (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+)))) + ;; 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 . + '(#:tests? #f))))) -(define-public cl-lzlib - (sbcl-package->cl-source-package sbcl-lzlib)) - -(define-public ecl-lzlib - (sbcl-package->ecl-package sbcl-lzlib)) - -(define-public sbcl-chanl - (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c") +(define-public sbcl-cl-freetype2 + (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04") (revision "1")) (package - (name "sbcl-chanl") - (version (git-version "0.4.1" revision commit)) + (name "sbcl-cl-freetype2") + (version (git-version "1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/zkat/chanl") + (url "https://github.com/rpav/cl-freetype2") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-freetype2" version)) (sha256 - (base32 - "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4")))) + (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q")))) (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 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 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-chanl - (sbcl-package->cl-source-package sbcl-chanl)) +(define-public cl-freetype2 + (sbcl-package->cl-source-package sbcl-cl-freetype2)) -(define-public ecl-chanl - (sbcl-package->ecl-package sbcl-chanl)) +(define-public ecl-cl-freetype2 + (sbcl-package->ecl-package sbcl-cl-freetype2)) -(define-public sbcl-cl-store - (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3") - (revision "1")) +(define-public sbcl-cl-gamepad + (let ((commit "d5b99fbaa2e39294d23061699e8f1e761eda7205") + (revision "3")) (package - (name "sbcl-cl-store") - (version (git-version "0.8.11" revision 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/skypher/cl-store") + (url "https://github.com/Shirakumo/cl-gamepad") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-gamepad" version)) (sha256 - (base32 - "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr")))) + (base32 "0y6kg9wq92p07i1chm1v7j7p77iqc5c985pdvmmivcip8zmd4hm4")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-rt)) - (synopsis "Common Lisp library to serialize data") + (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") (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/") + "This is a library to provide cross-platform access to gamepads, +joysticks, and other such HID devices.") + (license license:zlib)))) + +(define-public cl-gamepad + (sbcl-package->cl-source-package sbcl-cl-gamepad)) + +(define-public ecl-cl-gamepad + (sbcl-package->ecl-package sbcl-cl-gamepad)) + +(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. + +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 cl-store - (sbcl-package->cl-source-package sbcl-cl-store)) +(define-public cl-cl-geometry + (sbcl-package->cl-source-package sbcl-cl-geometry)) -(define-public ecl-cl-store - (sbcl-package->ecl-package sbcl-cl-store)) +(define-public ecl-cl-geometry + (sbcl-package->ecl-package sbcl-cl-geometry)) -(define-public sbcl-specialization-store - (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3") +(define-public sbcl-cl-glfw3 + (let ((commit "32c3f34d592d55ee7ce932ed85804c1a9c4158c6") (revision "1")) (package - (name "sbcl-specialization-store") - (version (git-version "0.0.5" revision commit)) + (name "sbcl-cl-glfw3") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/markcox80/specialization-store") + (url "https://github.com/AlexCharlton/cl-glfw3") (commit commit))) - (file-name (git-file-name "specialization-store" version)) + (file-name (git-file-name "cl-glfw3" version)) (sha256 - (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0")))) + (base32 "1wzr43nckdx4rlgxzhm1r4kfc264q969mc43y0js9ramh7l8gba5")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) + (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 - (list sbcl-alexandria sbcl-introspect-environment)) - (home-page "https://github.com/markcox80/specialization-store") - (synopsis "Different type of generic function for Common Lisp") + `(("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 - "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.") + "This package provides a Common Lisp bindings to @code{glfw}, an OpenGL +application development library.") (license license:bsd-2)))) -(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-glfw3 + (sbcl-package->cl-source-package sbcl-cl-glfw3)) -(define-public cl-specialization-store - (sbcl-package->cl-source-package sbcl-specialization-store)) +(define-public ecl-cl-glfw3 + (sbcl-package->ecl-package sbcl-cl-glfw3)) + +(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-glib + (sbcl-package->cl-source-package sbcl-cl-glib)) + +(define-public ecl-cl-glib + (sbcl-package->ecl-package sbcl-cl-glib)) + +(define-public sbcl-cl-gltf + (let ((commit "7a3af05a7f491d8973b217f096806ef12a97474b") + (revision "1")) + (package + (name "sbcl-cl-gltf") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-gltf") + (commit commit))) + (file-name (git-file-name "cl-gltf" version)) + (sha256 + (base32 "1d64fg2l2c0wns3wpp1xypd8687gnp3k70fv9fb48m1kpzg4kvrh")))) + (build-system asdf-build-system/sbcl) + (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 package provides a Common Lisp parser for glTF file format.") + (license license:zlib)))) + +(define-public cl-gltf + (sbcl-package->cl-source-package sbcl-cl-gltf)) + +;; 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 #. +;; +;; See +;; +;; (define-public ecl-cl-gltf +;; (sbcl-package->ecl-package sbcl-cl-gltf)) (define-public sbcl-cl-gobject-introspection (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9") @@ -10300,40 +5633,221 @@ Common Lisp-style definitions, based on cl-gobject-introspection.") (define-public ecl-cl-gobject-introspection-wrapper (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper)) -(define-public sbcl-cl-glib - (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57") - (revision "1")) +(define-public sbcl-cl-gopher + (let ((commit "0899e7fa2134206f9d9778c7d53c49b7a59ff070") + (revision "3")) (package - (name "sbcl-cl-glib") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-cl-gopher") + (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/knusbaum/cl-gopher") (commit commit))) - (file-name (git-file-name "cl-glib" version)) + (file-name (git-file-name "cl-gopher" version)) (sha256 - (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" )))) + (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) + (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") + (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.") + (license license:bsd-2)))) + +(define-public cl-gopher + (sbcl-package->cl-source-package sbcl-cl-gopher)) + +(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-cl-graph") + (version (git-version "0.10.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/cl-graph") + (commit commit))) + (file-name (git-file-name "cl-graph" version)) + (sha256 + (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf")))) (build-system asdf-build-system/sbcl) (arguments - '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject"))) + ;; 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 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-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)))) -(define-public cl-glib - (sbcl-package->cl-source-package sbcl-cl-glib)) +(define-public cl-cl-graph + (sbcl-package->cl-source-package sbcl-cl-graph)) -(define-public ecl-cl-glib - (sbcl-package->ecl-package sbcl-cl-glib)) +;; NOTE: (Sharlatan-20221118T214734+0000): No ECL support +;; +;; ecl-cl-graph + +(define-public sbcl-cl-grnm + (let ((commit "778a312e9eb3d3de7541457b516ea3d9055a15aa") + (revision "0")) + (package + (name "sbcl-cl-grnm") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/quil-lang/cl-grnm") + (commit commit))) + (file-name (git-file-name "cl-grnm" version)) + (sha256 + (base32 "1hb5n37n3x2ylrghcqsia2g9a6f5wg24l659jiz4ncpi5bsv4m3s")))) + (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)))) + +(define-public cl-grnm + (sbcl-package->cl-source-package sbcl-cl-grnm)) + +(define-public ecl-cl-grnm + (sbcl-package->ecl-package sbcl-cl-grnm)) + +(define-public sbcl-cl-gserver + (package + (name "sbcl-cl-gserver") + (version "1.8.0") + (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)) + (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))) + +(define-public cl-gserver + (sbcl-package->cl-source-package sbcl-cl-gserver)) + +(define-public ecl-cl-gserver + (sbcl-package->ecl-package sbcl-cl-gserver)) + +(define-public sbcl-cl-gss + (let ((commit "60086f4fd3b82316352e7f2288edbd58f03e08c5") + (revision "1")) + (package + (name "sbcl-cl-gss") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lokedhs/cl-gss") + (commit commit))) + (file-name (git-file-name "cl-gss" version)) + (sha256 + (base32 "0zhxxn3zarird255s9i56bz0fm6dkv00mn8bbsjrhskg3wpcg4pb")))) + (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")))))))) + (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 + "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-gss + (sbcl-package->cl-source-package sbcl-cl-gss)) + +(define-public ecl-cl-gss + (sbcl-package->ecl-package sbcl-cl-gss)) (define-public sbcl-cl-gtk4 (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4") @@ -10372,395 +5886,38 @@ Introspection, in the cl-gtk4 ASDF system.") (define-public ecl-cl-gtk4 (sbcl-package->ecl-package sbcl-cl-gtk4)) -(define-public sbcl-cl-slug - (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749") - (revision "1")) +(define-public sbcl-cl-hamt + ;; No release + (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208")) (package - (name "sbcl-cl-slug") - (version (git-version "0.4.1" 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/EuAndreh/cl-slug") - (commit commit))) - (file-name (git-file-name "cl-slug" version)) - (sha256 - (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx")))) - (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") - (description - "This is a small Common Lisp library to make slugs, mainly for URIs, -from English and beyond.") - (license license:llgpl)))) - -(define-public ecl-cl-slug - (sbcl-package->ecl-package sbcl-cl-slug)) - -(define-public cl-slug - (sbcl-package->cl-source-package sbcl-cl-slug)) - -(define-public sbcl-string-case - (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7") - (revision "0")) - (package - (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) + (url "https://github.com/danshapero/cl-hamt/") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md")))) + (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5")))) (build-system asdf-build-system/sbcl) - (synopsis "Efficient string= case in Common Lisp") + (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") (description - "@code{string-case} is a Common Lisp macro that generates specialised decision -trees to dispatch on string equality.") + "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-string-case - (sbcl-package->cl-source-package sbcl-string-case)) +(define-public cl-hamt + (sbcl-package->cl-source-package sbcl-cl-hamt)) -(define-public ecl-string-case - (sbcl-package->ecl-package sbcl-string-case)) - -(define-public sbcl-garbage-pools - (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790") - (revision "1")) - (package - (name "sbcl-garbage-pools") - (version (git-version "0.1.2" 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) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d")))) - (build-system asdf-build-system/sbcl) - (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. - -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-global-vars - (sbcl-package->cl-source-package sbcl-global-vars)) - -(define-public ecl-global-vars - (sbcl-package->ecl-package sbcl-global-vars)) - -(define-public sbcl-trivial-file-size - (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23") - (revision "0")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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. - -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 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-macroexpand-all - (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9") - (revision "0")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (synopsis "Portable macroexpand-all for Common Lisp") - (description - "This library provides a macroexpand-all function that calls the -implementation specific equivalent.") - (license license:unlicense)))) - -(define-public cl-trivial-macroexpand-all - (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all)) - -(define-public ecl-trivial-macroexpand-all - (sbcl-package->ecl-package sbcl-trivial-macroexpand-all)) - -(define-public sbcl-serapeum - (let ((commit "c08442a9757b7fa30ac345cb040e1642f97f6b78") - (revision "12")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1sabd048agvgv7bhbw126rci9hf45fk08zhghcv6an2h6xwmc3qv")))) - (build-system asdf-build-system/sbcl) - (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") - (description - "Serapeum is a conservative library of Common Lisp utilities. It is a -supplement, not a competitor, to Alexandria.") - (license license:expat)))) - -(define-public cl-serapeum - (sbcl-package->cl-source-package sbcl-serapeum)) - -(define-public ecl-serapeum - (sbcl-package->ecl-package sbcl-serapeum)) - -(define-public sbcl-rutils - (let ((commit "db3c3f4ae897025b5f0cd81042ca147da60ca0c5") - (revision "0")) - (package - (name "sbcl-rutils") - (version (git-version "5.2.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/vseloved/rutils") - (commit commit))) - (file-name (git-file-name "rutils" version)) - (sha256 - (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 - `(("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-rutils - (sbcl-package->cl-source-package sbcl-rutils)) - -(define-public ecl-rutils - (sbcl-package->ecl-package sbcl-rutils)) - -(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-arrow-macros") - (version (git-version "0.2.7" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hipeta/arrow-macros") - (commit commit))) - (file-name (git-file-name "arrow-macros" version)) - (sha256 - (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4")))) - (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") - (description - "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and diamond wands -in swiss-arrows.") - (license license:expat)))) - -(define-public cl-arrow-macros - (sbcl-package->cl-source-package sbcl-arrow-macros)) - -(define-public ecl-arrow-macros - (sbcl-package->ecl-package sbcl-arrow-macros)) - -(define-public sbcl-arrows - (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382") - (revision "0")) - (package - (name "sbcl-arrows") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.com/Harleqin/arrows.git") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy")))) - (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)))) - -(define-public cl-arrows - (sbcl-package->cl-source-package sbcl-arrows)) - -(define-public ecl-arrows - (sbcl-package->ecl-package sbcl-arrows)) - -(define-public sbcl-simple-parallel-tasks - (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6") - (revision "1")) - (package - (name "sbcl-simple-parallel-tasks") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/simple-parallel-tasks") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7")))) - (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)))) - -(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 ecl-cl-hamt + (sbcl-package->ecl-package sbcl-cl-hamt)) (define-public sbcl-cl-heap (package @@ -10792,801 +5949,376 @@ binary heap and a Fibonacci heap) as well as an efficient priority queue.") (define-public ecl-cl-heap (sbcl-package->ecl-package sbcl-cl-heap)) -(define-public sbcl-curry-compose-reader-macros - (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2") - (revision "0")) +(define-public sbcl-cl-hooks + (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7") + (revision "1")) (package - (name "sbcl-curry-compose-reader-macros") - (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/eschulte/curry-compose-reader-macros") - (commit commit))) + (uri (git-reference + (url home-page) + (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98")))) - (build-system asdf-build-system/sbcl) + "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y")))) (inputs - (list sbcl-alexandria sbcl-named-readtables)) - (synopsis "Reader macros for partial application and composition") - (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)))) + (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 cl-curry-compose-reader-macros - (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros)) +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 ecl-curry-compose-reader-macros - (sbcl-package->ecl-package sbcl-curry-compose-reader-macros)) +@itemize -(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))) +@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 cl-yason - (sbcl-package->cl-source-package sbcl-yason)) +This library tries to complement some of these weaknesses of method-based +extension-points via the concept of hooks.") + (license license:llgpl)))) -(define-public ecl-yason - (sbcl-package->ecl-package sbcl-yason)) +(define-public cl-hooks + (sbcl-package->cl-source-package sbcl-cl-hooks)) -(define-public sbcl-graph - (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f") +(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-graph") + (name "sbcl-cl-html-diff") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/wiseman/cl-html-diff") + (commit commit))) + (file-name + (git-file-name name version)) + (sha256 + (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb")))) + (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.") + (license license:expat)))) + +(define-public cl-html-diff + (sbcl-package->cl-source-package sbcl-cl-html-diff)) + +(define-public ecl-cl-html-diff + (sbcl-package->ecl-package sbcl-cl-html-diff)) + +(define-public sbcl-cl-html5-parser + (let ((commit "74a92eb3a183a0afd089ea33350e816e6b9aeefa") + (revision "1")) + (package + (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/eschulte/graph") - (commit commit))) - (file-name (git-file-name name version)) + (uri (git-reference + (url "https://github.com/rotatef/cl-html5-parser") + (commit commit))) + (file-name (git-file-name "cl-html5-parser" version)) (sha256 - (base32 - "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g")))) + (base32 "04if61wigylsmn996rbfl8ylsd0d9hzdmg7p2wiglncibjzcl5k9")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-stefil)) + (list sbcl-json-streams sbcl-split-sequence 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") - (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+)))) + (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-graph - (sbcl-package->cl-source-package sbcl-graph)) +(define-public cl-html5-parser + (sbcl-package->cl-source-package sbcl-cl-html5-parser)) -(define-public ecl-graph - (sbcl-package->ecl-package sbcl-graph)) +(define-public ecl-cl-html5-parser + (sbcl-package->ecl-package sbcl-cl-html5-parser)) -(define-public sbcl-trivial-indent - (let ((commit "f25275094b80df8aa158af46db980bbc3ce2f88b") - (revision "1")) +(define-public sbcl-cl-https-everywhere + ;; No release. + ;; Don't forget to update the https-everywhere input. + (let ((commit "cbcc73b985a5b1c0ce0d4ec38bc982a0538d4bd8")) (package - (name "sbcl-trivial-indent") - (version (git-version "1.0.0" revision 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)) - (sha256 - (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-trivial-indent - (sbcl-package->cl-source-package sbcl-trivial-indent)) - -(define-public ecl-trivial-indent - (sbcl-package->ecl-package sbcl-trivial-indent)) - -(define-public sbcl-data-format-validation - (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb") - (revision "1")) - (package - (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/willijar/cl-data-format-validation/") - (commit commit))) - (file-name (git-file-name "data-format-validation" version)) - (sha256 - (base32 - "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-ppcre)) - (synopsis "Validation and conversion between user and internal data") - (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)))) - -(define-public sbcl-cl-docutils - (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40") - (revision "1")) - (package - (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-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/documentation-utils") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq")))) - (build-system asdf-build-system/sbcl) - (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-documentation-utils - (sbcl-package->cl-source-package sbcl-documentation-utils)) - -(define-public ecl-documentation-utils - (sbcl-package->ecl-package sbcl-documentation-utils)) - -(define-public sbcl-documentation-utils-extensions - (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750")) - (package - (name "sbcl-documentation-utils-extensions") + (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/sirherrbatka/documentation-utils-extensions/") - (commit commit))) + (uri (git-reference + (url "https://github.com/ruricolist/cl-https-everywhere/") + (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f")))) + (base32 "1wcvx1icwym1ncd6wl1wxzkyyndrm796caalbklvjd4a2cbl3xxi")))) (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") - (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)))) - -(define-public cl-documentation-utils-extensions - (sbcl-package->cl-source-package sbcl-documentation-utils-extensions)) - -(define-public ecl-documentation-utils-extensions - (sbcl-package->ecl-package sbcl-documentation-utils-extensions)) - -(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-charje.documentation - (sbcl-package->cl-source-package sbcl-charje.documentation)) - -(define-public ecl-charje.documentation - (sbcl-package->ecl-package sbcl-charje.documentation)) - -(define-public sbcl-staple - (let ((commit "0ee8e25fe6fe8fa83b2a6c93d4febd468c3eaa4e") - (revision "1")) - (package - (name "sbcl-staple") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/staple/") - (commit commit))) - (sha256 - (base32 "0qf0if7py3n4rszg25lcavpsqikfz6k5dvcmh5q67y8x5r12i5m7")) - (file-name (git-file-name "staple" version)))) - (build-system asdf-build-system/sbcl) - (arguments - '(#: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-helambdap - (let ((commit "5bf65f57a36ee094cadb096caca6e90eb3ba46c4") - (revision "0")) - (package - (name "sbcl-helambdap") - (version (git-version "20220103" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://git.code.sf.net/p/helambdap/code") - (commit commit))) - (file-name (git-file-name "cl-helambdap" version)) - (sha256 - (base32 "1kzapbf9l2bw8i9m9sxv0dfnkksrxq81d5hbn34pm25abk0i937j")))) - (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") - (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 ecl-form-fiddle - (sbcl-package->ecl-package sbcl-form-fiddle)) - -(define-public sbcl-array-utils - (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834") - (revision "0")) - (package - (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/array-utils") - (commit commit))) - (file-name (git-file-name "cl-array-utils" version)) - (sha256 - (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az")))) - (build-system asdf-build-system/sbcl) + `(("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 - (list sbcl-parachute)) - (inputs - (list sbcl-documentation-utils)) - (synopsis "Tiny collection of array and vector utilities for Common Lisp") + `(("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 - "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)))) + "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 cl-array-utils - (sbcl-package->cl-source-package sbcl-array-utils)) +(define-public cl-https-everywhere + (sbcl-package->cl-source-package sbcl-cl-https-everywhere)) -(define-public ecl-array-utils - (sbcl-package->ecl-package sbcl-array-utils)) - -(define-public sbcl-lass - (let ((commit "1f2418dbf2d8d6f5892171057616b2ca9d6e5008") - (revision "1")) - (package - (name "sbcl-lass") - (version (git-version "0.6.0" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/LASS") - (commit commit))) - (file-name (git-file-name "cl-lass" version)) - (sha256 - (base32 "1wax2kykc9ff0sk2linp9v8fcsm5ay6idpq365vivady9fh504r5")))) - (build-system asdf-build-system/sbcl) - (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)) - -(define-public sbcl-xhtmlambda - (let ((commit "c86376bccebf77ca428e8033df2ba7d8450ea1e8") - (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)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/xhtmlambda/XHTMLambda") - (commit commit))) - (file-name (git-file-name "cl-xhtmlambda" version)) - (sha256 - (base32 "0narbzz06ry1wn048avm1fwihvnjvvc4wfcv5hmdazkilpvnqz2y")))) - (build-system asdf-build-system/sbcl) - (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 cl-xhtmlambda - (sbcl-package->cl-source-package sbcl-xhtmlambda)) - -(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 cl-clad - (sbcl-package->cl-source-package sbcl-clad)) - -(define-public sbcl-plump - (let ((commit "0c3e0b57b43b6e0c5794b6a902f1cf5bee2a2927") +(define-public sbcl-cl-i18n + (let ((commit "acb162a12dac50fc46d83da8934fce85d19e31c4") (revision "3")) (package - (name "sbcl-plump") - (version (git-version "2.0.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/Shinmera/plump") - (commit commit))) - (file-name (git-file-name "cl-plump" version)) + (uri (git-reference + (url "https://codeberg.org/cage/cl-i18n") + (commit commit))) + (file-name (git-file-name "cl-i18n" version)) (sha256 - (base32 "1fyb66pqvr1iy31ah9638ihs8cax17zkxk0zq14jy7x5l9rq1qlf")))) + (base32 "1y29cirmlyc406a45sdx39spvnjzbs772c977075ccicz46qaxz7")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-array-utils sbcl-documentation-utils)) - (synopsis "Lenient XML / XHTML / HTML parser for Common Lisp") + (list sbcl-alexandria sbcl-babel sbcl-cl-ppcre-unicode)) + (synopsis "Internationalisation framework 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/") - (license license:zlib)))) + "This is a Gettext-style internationalisation framework for Common +Lisp.") + (home-page "https://codeberg.org/cage/cl-i18n") + (license license:llgpl)))) -(define-public cl-plump - (sbcl-package->cl-source-package sbcl-plump)) +(define-public cl-i18n + (sbcl-package->cl-source-package sbcl-cl-i18n)) -(define-public ecl-plump - (sbcl-package->ecl-package sbcl-plump)) +(define-public ecl-cl-i18n + (sbcl-package->ecl-package sbcl-cl-i18n)) -(define-public sbcl-plump-sexp - (let ((commit "bbcf75e9ecda8fe7603098ab8c15828407bb4f08") +(define-public sbcl-cl-indentify + (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53")) + (package + (name "sbcl-cl-indentify") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/yitzchak/cl-indentify") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p")))) + (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") + (description + "A library and command line utility to automatically indent Common Lisp +source files.") + (license license:expat)))) + +(define-public cl-indentify + (sbcl-package->cl-source-package sbcl-cl-indentify)) + +(define-public ecl-cl-indentify + (sbcl-package->ecl-package sbcl-cl-indentify)) + +(define-public sbcl-cl-inflector + (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe") + (revision "1")) + (package + (name "sbcl-cl-inflector") + (version (git-version "0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/AccelerationNet/cl-inflector") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-lisp-unit2)) + (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)) + +(define-public ecl-cl-inflector + (sbcl-package->ecl-package sbcl-cl-inflector)) + +(define-public sbcl-cl-ini + (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7") (revision "0")) (package - (name "sbcl-plump-sexp") - (version (git-version "0.1.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/Shinmera/plump-sexp") - (commit commit))) - (file-name (git-file-name "cl-plump-sexp" version)) + (uri (git-reference + (url "https://github.com/compufox/cl-ini") + (commit commit))) + (file-name (git-file-name "sbcl-cl-ini" version)) (sha256 (base32 - "0zm9h0assjb8766z2v6l1k1s60y90y6f8smrl1dczwqlvc8xyln5")))) + "12vy3gspqn0wmkyz5id1xrgv1scgb16m7pkvmbmi19vlpj2iyq7p")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-plump)) - (synopsis "Convert S-expressions into a Plump DOM and back") + (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 - "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)))) + "Parse INI formatted files into a Common Lisp list structure.") + (license license:expat)))) -(define-public cl-plump-sexp - (sbcl-package->cl-source-package sbcl-plump-sexp)) +(define-public cl-ini + (sbcl-package->cl-source-package sbcl-cl-ini)) -(define-public ecl-plump-sexp - (sbcl-package->ecl-package sbcl-plump-sexp)) +(define-public ecl-cl-ini + (sbcl-package->ecl-package sbcl-cl-ini)) -;;; 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-cl-inotify + (let ((commit "66f29e01ec28355ebba8292411b4de90eebd76a3") + (revision "0")) (package - (name "sbcl-antik-base") + (name "sbcl-cl-inotify") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://gitlab.common-lisp.net/antik/antik.git") + (url "https://github.com/Ferada/cl-inotify") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-inotify" version)) (sha256 - (base32 - "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km")))) - (build-system asdf-build-system/sbcl) - (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)))) + (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-antik-base - (sbcl-package->cl-source-package sbcl-antik-base)) +(define-public cl-inotify + (sbcl-package->cl-source-package sbcl-cl-inotify)) -(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-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-gsll - (sbcl-package->cl-source-package sbcl-gsll)) - -(define-public ecl-gsll - (sbcl-package->ecl-package sbcl-gsll)) - -(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-antik - (sbcl-package->cl-source-package sbcl-antik)) +(define-public ecl-cl-inotify + (sbcl-package->ecl-package sbcl-cl-inotify)) (define-public sbcl-cl-interpol (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa") @@ -11625,668 +6357,376 @@ doesn't support them.") (define-public ecl-cl-interpol (sbcl-package->ecl-package sbcl-cl-interpol)) -(define-public sbcl-symbol-munger - (let ((commit "e96558e8315b8eef3822be713354787b2348b25e") - (revision "2")) +(define-public sbcl-cl-ipfs-api2 + (let ((commit "3ee52c80023bcc662f7d01276ea0a5814bd0011b") + (revision "0")) (package - (name "sbcl-symbol-munger") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-cl-ipfs-api2") + (version (git-version "0.51" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/AccelerationNet/symbol-munger") + (url "https://github.com/JadedCtrl/cl-ipfs-api2") (commit commit))) - (file-name (git-file-name "cl-symbol-munger" version)) + (file-name (git-file-name "cl-ipfs-api2" version)) (sha256 - (base32 - "16fshnxp9212503z1vjlmx5pafv14bzpihn486x1ljakqjigfnfz")))) + (base32 "1h0csxk4db1hid793mk5kz3nbjyl7z4ic1zk2wy46k1vz5lnnsph")))) (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") + '(#: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 - "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)))) + "@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 cl-symbol-munger - (sbcl-package->cl-source-package sbcl-symbol-munger)) +(define-public cl-ipfs-api2 + (sbcl-package->cl-source-package sbcl-cl-ipfs-api2)) -(define-public ecl-symbol-munger - (sbcl-package->ecl-package sbcl-symbol-munger)) +(define-public ecl-cl-ipfs-api2 + (sbcl-package->ecl-package sbcl-cl-ipfs-api2)) -(define-public sbcl-cl-csv - (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651") - (revision "2")) +(define-public sbcl-cl-irc + (let ((commit "963823537c7bfcda2edd4c44d172192da6722175") + (revision "0")) (package - (name "sbcl-cl-csv") - (version (git-version "1.0.6" revision commit)) + (name "sbcl-cl-irc") + (version (git-version "0.9.2" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/AccelerationNet/cl-csv") + (url "https://salsa.debian.org/common-lisp-team/cl-irc.git") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-irc" version)) (sha256 - (base32 - "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x")))) + (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w")))) (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-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-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 cl-csv - (sbcl-package->cl-source-package sbcl-cl-csv)) +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 ecl-cl-csv - (sbcl-package->ecl-package sbcl-cl-csv)) +(define-public cl-irc + (sbcl-package->cl-source-package sbcl-cl-irc)) -(define-public sbcl-external-program - (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749") +(define-public ecl-cl-irc + (sbcl-package->ecl-package sbcl-cl-irc)) + +(define-public sbcl-cl-isaac + (let ((commit "9cd88f39733be753facbf361cb0e08b9e42ff8d5") + (revision "0")) + (package + (name "sbcl-cl-isaac") + (version (git-version "1.0.7" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/thephoeron/cl-isaac") + (commit commit))) + (file-name (git-file-name "cl-isaac" version)) + (sha256 + (base32 "0ig1mf8iridfr7vci9gy499194h0hda0xki5s6g0y04g85ibnpw9")))) + (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)))) + +(define-public cl-isaac + (sbcl-package->cl-source-package sbcl-cl-isaac)) + +(define-public ecl-cl-isaac + (sbcl-package->ecl-package sbcl-cl-isaac)) + +(define-public sbcl-cl-jpeg + (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af") (revision "1")) (package - (name "sbcl-external-program") - (version (git-version "0.0.6" 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/sellout/external-program") + (url "https://github.com/sharplispers/cl-jpeg") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z")))) + (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy")))) (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-trivial-features)) - (native-inputs - (list sbcl-fiveam)) - (synopsis "Common Lisp library for running external programs") + (synopsis "JPEG image library for 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)))) + "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-external-program - (sbcl-package->cl-source-package sbcl-external-program)) +(define-public cl-jpeg + (sbcl-package->cl-source-package sbcl-cl-jpeg)) -(define-public ecl-external-program - (sbcl-package->ecl-package sbcl-external-program)) +(define-public ecl-cl-jpeg + (sbcl-package->ecl-package sbcl-cl-jpeg)) -(define-public sbcl-cl-ana - (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e") - (revision "2")) +(define-public sbcl-cl-json + (package + (name "sbcl-cl-json") + (version "0.6.0") + (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")))) + (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))) + +(define-public cl-json + (sbcl-package->cl-source-package sbcl-cl-json)) + +(define-public ecl-cl-json + (sbcl-package->ecl-package sbcl-cl-json)) + +(define-public sbcl-cl-json-pointer + (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c") + (revision "0")) (package - (name "sbcl-cl-ana") + (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/ghollisjr/cl-ana") + (url "https://github.com/y2q-actionman/cl-json-pointer") (commit commit))) - (file-name (git-file-name "cl-ana" version)) + (file-name (git-file-name "cl-json-pointer" version)) (sha256 - (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y")))) + (base32 "0b7a755wc2ghsd1pv7d32877b21h4nssp41xs017anbmj55czb2h")))) (build-system asdf-build-system/sbcl) - (native-inputs - (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 - "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)))) + ;; 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-ana - (sbcl-package->cl-source-package sbcl-cl-ana)) +(define-public cl-json-pointer + (sbcl-package->cl-source-package sbcl-cl-json-pointer)) -(define-public sbcl-eazy-gnuplot - (let ((commit "2eb900fe2557e6c066a9851c166e572c25bc0996") - (revision "0")) +(define-public ecl-cl-json-pointer + (sbcl-package->ecl-package sbcl-cl-json-pointer)) + +(define-public sbcl-cl-ledger + (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b") + (revision "1")) (package - (name "sbcl-eazy-gnuplot") - (version (git-version "0.2.0" revision commit)) + (name "sbcl-cl-ledger") + (version (git-version "4.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/guicho271828/eazy-gnuplot") + (url "https://github.com/ledger/cl-ledger") (commit commit))) - (file-name (git-file-name "cl-eazy-gnuplot" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0mpkx1z52riahydzvqv7kk15p0pv2k7k5a7j65fg571kcxmssx8s")) - (patches (search-patches "sbcl-eazy-gnuplot-skip-path-check.patch")))) + (base32 + "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1")))) (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) (inputs - (list gnuplot - sbcl-alexandria - sbcl-iterate - sbcl-trivia)) + `(("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-ledger + (sbcl-package->cl-source-package sbcl-cl-ledger)) + +(define-public ecl-cl-ledger + (sbcl-package->ecl-package sbcl-cl-ledger)) + +(define-public sbcl-cl-lex + (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b") + (revision "1")) + (package + (name "sbcl-cl-lex") + (version (git-version "1.1.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/djr7C4/cl-lex") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-ppcre)) + (synopsis "Common Lisp macros for generating lexical analyzers") + (description + "This is a Common Lisp library providing a set of macros for generating +lexical analyzers automatically. The lexers generated using @code{cl-lex} can +be used with @code{cl-yacc}.") + (home-page "https://github.com/djr7C4/cl-lex") + (license license:gpl3)))) + +(define-public cl-lex + (sbcl-package->cl-source-package sbcl-cl-lex)) + +(define-public ecl-cl-lex + (sbcl-package->ecl-package sbcl-cl-lex)) + +(define-public sbcl-cl-liballegro + (let ((commit "49f632ce97fc4f835bf5d450588793234b980a64") + (revision "1")) + (package + (name "sbcl-cl-liballegro") + (version (git-version "0.2.15" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/resttime/cl-liballegro") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0brbr7i342s0gadlnzd3a61w2b9ihhx60l19ararnc2asvyhmz7x")))) + (build-system asdf-build-system/sbcl) (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 - "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 cl-eazy-gnuplot - (sbcl-package->cl-source-package sbcl-eazy-gnuplot)) - -(define-public ecl-eazy-gnuplot - (sbcl-package->ecl-package sbcl-eazy-gnuplot)) - -(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) + (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 - (list sbcl-cl-fad sbcl-trivial-gray-streams)) - (synopsis "Common Lisp library for tar and cpio archives") + `(("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 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)))) + "This package provides CFFI bindings and interface to Allegro 5 game +developing library for Common Lisp.") + (license license:zlib)))) -(define-public cl-archive - (sbcl-package->cl-source-package sbcl-archive)) +(define-public cl-liballegro + (sbcl-package->cl-source-package sbcl-cl-liballegro)) -(define-public ecl-archive - (sbcl-package->ecl-package sbcl-archive)) +(define-public ecl-cl-liballegro + (sbcl-package->ecl-package sbcl-cl-liballegro)) -(define-public sbcl-tar-file - (let ((commit "0c10bc82f14702c97a26dc25ce075b5d3a2347d1") +(define-public sbcl-cl-libsvm-format + (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb") (revision "0")) (package - (name "sbcl-tar-file") - (version (git-version "0.2.1" revision commit)) + (name "sbcl-cl-libsvm-format") + (version (git-version "0.1.0" 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. - -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-tar-file - (sbcl-package->cl-source-package sbcl-tar-file)) - -(define-public ecl-tar-file - (sbcl-package->ecl-package sbcl-tar-file)) - -(define-public sbcl-tar - (let ((commit "7c6e07a10c93d9e311f087b5f6328cddd481669a") - (revision "0")) - (package - (name "sbcl-tar") - (version (git-version "0.2.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-tar/cl-tar") - (commit commit))) - (file-name (git-file-name "cl-tar" version)) - (sha256 - (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 - '(#: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") - (description - "@code{cl-tar} is a Common Lisp library providing a high-level interface -for interacting with tar archives.") - (license license:expat)))) - -(define-public cl-tar - (sbcl-package->cl-source-package sbcl-tar)) - -(define-public ecl-tar - (sbcl-package->ecl-package sbcl-tar)) - -(define-public sbcl-misc-extensions - (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a") - (revision "1")) - (package - (name "sbcl-misc-extensions") - (version (git-version "3.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/misc-extensions/devel.git") + (url "https://github.com/masatoi/cl-libsvm-format") (commit commit))) (file-name (git-file-name name version)) (sha256 (base32 - "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0")))) + "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg")))) (build-system asdf-build-system/sbcl) - (synopsis "Collection of small macros and extensions for Common Lisp") - (description - "This project is intended as a catchall for small, general-purpose -extensions to Common Lisp. It contains: - -@itemize -@item @code{new-let}, a macro that combines and generalizes @code{let}, -@code{let*} and @code{multiple-value-bind}, -@item @code{gmap}, an iteration macro that generalizes @code{map}. -@end itemize\n") - (home-page "https://common-lisp.net/project/misc-extensions/") - (license license:public-domain)))) - -(define-public cl-misc-extensions - (sbcl-package->cl-source-package sbcl-misc-extensions)) - -(define-public ecl-misc-extensions - (sbcl-package->ecl-package sbcl-misc-extensions)) - -(define-public sbcl-mt19937 - (package - (name "sbcl-mt19937") - (version "1.1") - (source - (origin - (method url-fetch) - (uri (string-append "https://common-lisp.net/project/asdf-packaging/" - "mt19937-latest.tar.gz")) - (sha256 - (base32 - "1iw636b0iw5ygkv02y8i41lh7xj0acglv0hg5agryn0zzi2nf1xv")))) - (build-system asdf-build-system/sbcl) - (synopsis "Mersenne Twister pseudo-random number generator") - (description - "MT19937 is a portable Mersenne Twister pseudo-random number generator -for Common Lisp.") - (home-page "https://www.cliki.net/mt19937") - (license license:public-domain))) - -(define-public cl-mt19937 - (sbcl-package->cl-source-package sbcl-mt19937)) - -(define-public ecl-mt19937 - (sbcl-package->ecl-package sbcl-mt19937)) - -(define-public sbcl-fset - (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852") - (revision "1")) - (package - (name "sbcl-fset") - (version (git-version "1.3.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/slburson/fset") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy")) - (snippet '(begin - ;; Remove obsolete copy of system definition. - (delete-file "Code/fset.asd") - #t)))) - (build-system asdf-build-system/sbcl) - (inputs - (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)))) - -(define-public cl-fset - (sbcl-package->cl-source-package sbcl-fset)) - -(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 sbcl-modf - (let ((commit "dea93fe62c6bf7f66f32f52ac0c555aedbf7abad") - (revision "0")) - (package - (name "sbcl-modf") - (version (git-version "0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/smithzvk/modf") - (commit commit))) - (file-name (git-file-name "cl-modf" version)) - (sha256 - (base32 - "1aap7ldy7lv942khp026pgndgdzfkkqa9xcq1ykinrmflrgdazay")))) - (build-system asdf-build-system/sbcl) - (inputs - (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 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") - (description - "This is a library that implements delimited continuations by -transforming Common Lisp code to continuation passing style.") - (home-page "https://common-lisp.net/project/cl-cont/") - (license license:llgpl)))) - -(define-public cl-cont - (sbcl-package->cl-source-package sbcl-cl-cont)) - -(define-public ecl-cl-cont - (sbcl-package->ecl-package sbcl-cl-cont)) - -(define-public sbcl-cl-coroutine - (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72") - (revision "1")) - (package - (name "sbcl-cl-coroutine") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/takagi/cl-coroutine") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("alexandria" ,sbcl-alexandria) - ("cl-cont" ,sbcl-cl-cont))) (native-inputs (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") + (inputs + (list sbcl-alexandria)) + (synopsis "LibSVM data format reader for Common Lisp") (description - "This is a coroutine library for Common Lisp implemented using the -continuations of the @code{cl-cont} library.") - (home-page "https://github.com/takagi/cl-coroutine") - (license license:llgpl)))) - -(define-public cl-coroutine - (sbcl-package->cl-source-package sbcl-cl-coroutine)) - -(define-public ecl-cl-coroutine - (sbcl-package->ecl-package sbcl-cl-coroutine)) - -(define-public sbcl-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 ecl-vas-string-metrics - (sbcl-package->ecl-package sbcl-vas-string-metrics)) - -(define-public cl-vas-string-metrics - (sbcl-package->cl-source-package sbcl-vas-string-metrics)) - -(define-public sbcl-vom - (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24") - (revision "1")) - (package - (name "sbcl-vom") - (version (git-version "0.1.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/orthecreedence/vom") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy")))) - (build-system asdf-build-system/sbcl) - (synopsis "Tiny logging utility for Common Lisp") - (description - "Vom is a logging library for Common Lisp. It's goal is to be useful -and small. It does not provide a lot of features as other loggers do, but -has a small codebase that's easy to understand and use.") - (home-page "https://github.com/orthecreedence/vom") + "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-vom - (sbcl-package->cl-source-package sbcl-vom)) +(define-public cl-libsvm-format + (sbcl-package->cl-source-package sbcl-cl-libsvm-format)) -(define-public ecl-vom - (sbcl-package->ecl-package sbcl-vom)) +(define-public ecl-cl-libsvm-format + (sbcl-package->ecl-package sbcl-cl-libsvm-format)) (define-public sbcl-cl-libuv (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29") @@ -12335,60 +6775,3522 @@ has a small codebase that's easy to understand and use.") (define-public ecl-cl-libuv (sbcl-package->ecl-package sbcl-cl-libuv)) -(define-public sbcl-cl-async - (let ((commit "f6423e44404a44434d803605e0d2e17199158e28") - (revision "1")) +(define-public sbcl-cl-libxml2 + (let ((commit "8d03110c532c1a3fe15503fdfefe82f60669e4bd")) (package - (name "sbcl-cl-async") - (version (git-version "0.6.1" revision commit)) + (name "sbcl-cl-libxml2") + (version (git-version "0.3.4" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orthecreedence/cl-async") + (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 + (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") + (license license:llgpl)))) + +(define-public cl-libxml2 + (sbcl-package->cl-source-package sbcl-cl-libxml2)) + +(define-public ecl-cl-libxml2 + (sbcl-package->ecl-package sbcl-cl-libxml2)) + +(define-public sbcl-cl-libyaml + (let ((commit "a7fe9f68bddfd00b7ca467b65b3b41b276336843") + (revision "1")) + (package + (name "sbcl-cl-libyaml") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eudoxia0/cl-libyaml") + (commit commit))) + (file-name (git-file-name "cl-libyaml" version)) + (sha256 + (base32 + "06pvmackyhq03rjmihpx6w63m6cy8wx78ll5xpwwvd85bgrqq817")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (inputs + `(("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 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-libyaml + (sbcl-package->cl-source-package sbcl-cl-libyaml)) + +(define-public ecl-cl-libyaml + (sbcl-package->ecl-package sbcl-cl-libyaml)) + +(define-public sbcl-cl-locale + (let ((commit "0a36cc0dcf5e0a8c8bf97869cd6199980ca25eec") + (revision "1")) + (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))) + (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)))) + +(define-public cl-locale + (sbcl-package->cl-source-package sbcl-cl-locale)) + +(define-public ecl-cl-locale + (sbcl-package->ecl-package sbcl-cl-locale)) + +(define-public sbcl-cl-log + (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837") + (revision "1")) + (package + (name "sbcl-cl-log") + (version "1.0.1") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/nicklevine/cl-log") + (commit commit))) + (sha256 + (base32 "1r3z9swy1b59swvaa5b97is9ysrfmjvjjhhw56p7p5hqg93b92ak")) + (file-name (git-file-name "cl-log" version)))) + (build-system asdf-build-system/sbcl) + (synopsis "Common Lisp general purpose logging utility") + (description "CL-LOG is a general purpose logging utility, loosely modelled +in some respects after Gary King's Log5. Its features include: logging to +several destinations at once, via \"messengers\", each messenger is tailored to +accept some log messages and reject others, and this tailoring can be changed +on-the-fly, very rapid processing of messages which are rejected by all +messengers, fully independent use of the utility by several different +sub-systems in an application, support for messengers which cl:format text to a +stream, support for messengers which do not invoke cl:format, timestamps in +theory accurate to internal-time-units-per-second.") + (home-page "https://github.com/nicklevine/cl-log") + (license license:expat)))) + +(define-public cl-log + (sbcl-package->cl-source-package sbcl-cl-log)) + +(define-public ecl-cl-log + (sbcl-package->ecl-package sbcl-cl-log)) + +(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-cl-markdown") + (version (git-version "0.10.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/cl-markdown") + (commit commit))) + (file-name (git-file-name "cl-markdown" version)) + (sha256 + (base32 "1algqwmafipyf194cx9wfhg0pdx1ppx6s444p1pm8yaycbsyla1v")))) + (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") + (description + "This is an implementation of a Markdown parser in Common Lisp.") + (license license:expat)))) + +(define-public cl-markdown + (sbcl-package->cl-source-package sbcl-cl-markdown)) + +(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-cl-markless + (let ((commit "a0e145c03103bd3bf7e275d5ac0e19e8381eb844") + (revision "1")) + (package + (name "sbcl-cl-markless") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-markless") + (commit commit))) + (file-name (git-file-name "cl-markless" version)) + (sha256 + (base32 "154ax1yk0b1035yij29c5pgfn7ifghrxy821mk68wyljg8afgvh5")))) + (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)))) + +(define-public cl-markless + (sbcl-package->cl-source-package sbcl-cl-markless)) + +(define-public ecl-cl-markless + (sbcl-package->ecl-package sbcl-cl-markless)) + +(define-public sbcl-cl-markup + (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390")) + (package + (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: + +@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-markup + (sbcl-package->cl-source-package sbcl-cl-markup)) + +(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-cl-mathstats") + (version (git-version "0.8.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/cl-mathstats") + (commit commit))) + (file-name (git-file-name "cl-mathstats" version)) + (sha256 + (base32 "0gsjvmkmnxc4hp5z9mkm5vsllywqyg7kx8jgz88vnx47yj3va1s8")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-lift)) + (inputs + (list sbcl-cl-containers sbcl-metatilities-base)) + (home-page "https://github.com/hraban/cl-mathstats") + (synopsis "Common Lisp collection of mathematical routines") + (description + "This package provides Common Lisp math and statistics routines.") + (license license:expat)))) + +(define-public cl-mathstats + (sbcl-package->cl-source-package sbcl-cl-mathstats)) + +(define-public ecl-cl-mathstats + (sbcl-package->ecl-package sbcl-cl-mathstats)) + +(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") + (license license:bsd-2)))) + +(define-public cl-messagepack + (sbcl-package->cl-source-package sbcl-cl-messagepack)) + +(define-public ecl-cl-messagepack + (sbcl-package->ecl-package sbcl-cl-messagepack)) + +(define-public sbcl-cl-mime + (let ((commit "d30a28e0a40393bd3af7d138daa05319ed2e9d07") + (revision "1")) + (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)) + (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") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 - "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x")))) + (base32 "0qn8if0fj6vzc897pqqqs0m1y107gmzqngpqhqmwrcsp1ckj5k0v")))) (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))) + (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-mime + (sbcl-package->cl-source-package sbcl-cl-mime)) + +(define-public ecl-cl-mime + (sbcl-package->ecl-package sbcl-cl-mime)) + +(define-public sbcl-cl-mimeparse + (let ((commit "93cbdf6f6fe8a2eb5f652f8adec453eb98ea0547") + (revision "0")) + (package + (name "sbcl-cl-mimeparse") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mmontone/cl-mimeparse") + (commit commit))) + (file-name (git-file-name "cl-mimeparse" version)) + (sha256 + (base32 "0gdkpi3620va0a3q56svcn1q9f5w0pqfhx30lnldg8fjnrdfiwkk")))) + (build-system asdf-build-system/sbcl) (arguments - `(#:asd-systems '("cl-async" - "cl-async-repl" - "cl-async-ssl") + '(#:asd-test-systems '("cl-mimeparse-tests"))) + (native-inputs + (list sbcl-rt)) + (inputs + (list sbcl-cl-ppcre sbcl-parse-number)) + (home-page "https://github.com/mmontone/cl-mimeparse/") + (synopsis "Common Lisp library for parsing MIME types") + (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)))) + +(define-public cl-mimeparse + (sbcl-package->cl-source-package sbcl-cl-mimeparse)) + +(define-public ecl-cl-mimeparse + (sbcl-package->ecl-package sbcl-cl-mimeparse)) + +(define-public sbcl-cl-mixed + (let ((commit "4aaff134d3902d93a2a8605c10de4bcfc62d7afa") + (revision "0")) + (package + (name "sbcl-cl-mixed") + (version (git-version "2.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-mixed") + (commit commit))) + (file-name (git-file-name "cl-mixed" version)) + (sha256 + (base32 "1mrj95lxb1gbxxm89x8gy1ifw2ic1p5wwpapkxcd2jr8abw7zny0")) + (modules '((guix build utils))) + (snippet + ;; Delete bundled libraries. + `(begin + (delete-file-recursively "static"))))) + (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* "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") + (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 - "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/") + "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)))) + +(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-cl-modio") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/cl-modio/") + (commit commit))) + (sha256 + (base32 "0hz87v81pi8kr2c7az30czpdf7v757lkzlsmdcc59p94pipca7m9")) + (file-name (git-file-name "cl-modio" 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)))) + +(define-public cl-modio + (sbcl-package->cl-source-package sbcl-cl-modio)) + +(define-public ecl-cl-modio + (sbcl-package->ecl-package sbcl-cl-modio)) + +(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-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 "https://github.com/Shirakumo/cl-mpg123") + (commit commit))) + (file-name (git-file-name "cl-mpg123" version)) + (sha256 + (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 '("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)))))))) + (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") + (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)))) + +(define-public cl-mpg123 + (sbcl-package->cl-source-package sbcl-cl-mpg123)) + +(define-public ecl-cl-mpg123 + (sbcl-package->ecl-package sbcl-cl-mpg123)) + +(define-public sbcl-cl-murmurhash + ;; No release. + (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364") + (revision "1")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-babel)) + (native-inputs + (list sbcl-fiveam)) + (synopsis "32-bit version of Murmurhash3 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)))) -(define-public cl-async - (sbcl-package->cl-source-package sbcl-cl-async)) +(define-public cl-murmurhash + (sbcl-package->cl-source-package sbcl-cl-murmurhash)) -(define-public ecl-cl-async - (sbcl-package->ecl-package sbcl-cl-async)) +(define-public ecl-cl-murmurhash + (sbcl-package->ecl-package sbcl-cl-murmurhash)) + +(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-mustache + (sbcl-package->cl-source-package sbcl-cl-mustache)) + +(define-public ecl-cl-mustache + (sbcl-package->ecl-package sbcl-cl-mustache)) + +(define-public sbcl-cl-mysql + (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9") + (revision "1")) + (package + (name "sbcl-cl-mysql") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hackinghat/cl-mysql") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr")))) + (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") + (description + "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.") + (home-page "http://www.hackinghat.com/index.php/cl-mysql") + (license license:expat)))) + +(define-public cl-mysql + (sbcl-package->cl-source-package sbcl-cl-mysql)) + +(define-public ecl-cl-mysql + (sbcl-package->ecl-package sbcl-cl-mysql)) + +(define-public sbcl-cl-num-utils + (let ((commit "97a88cd34540acf52e872a82ebfef3da0a34fa12") + (revision "1")) + (package + (name "sbcl-cl-num-utils") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tpapp/cl-num-utils") + (commit commit))) + (file-name (git-file-name "cl-num-utils" version)) + (sha256 + (base32 "15ihsxxs76xnldmqfsbxybckqjwrxwcpphgghiwzr2mnbqjpdqkh")))) + (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") + (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)))) + +(define-public cl-num-utils + (sbcl-package->cl-source-package sbcl-cl-num-utils)) + +(define-public ecl-cl-num-utils + (sbcl-package->ecl-package sbcl-cl-num-utils)) + +(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-cl-online-learning") + (version (git-version "0.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/masatoi/cl-online-learning") + (commit commit))) + (file-name (git-file-name "cl-online-learning" version)) + (sha256 + (base32 + "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9")))) + (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") + (description + "This library contains a collection of machine learning algorithms for +online linear classification written in Common Lisp.") + (license license:expat)))) + +(define-public cl-online-learning + (sbcl-package->cl-source-package sbcl-cl-online-learning)) + +(define-public ecl-cl-online-learning + (sbcl-package->ecl-package sbcl-cl-online-learning)) + +(define-public sbcl-cl-opengl + (let ((commit "e2d83e0977b7e7ac3f3d348d8ccc7ccd04e74d59") + (revision "1")) + (package + (name "sbcl-cl-opengl") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/3b/cl-opengl") + (commit commit))) + (file-name (git-file-name "cl-opengl" version)) + (sha256 + (base32 "0mhqmll09f079pnd6mgswz9nvr6h5n27d4q7zpmm2igf1v460id7")))) + (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") + (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)))) + +(define-public cl-opengl + (sbcl-package->cl-source-package sbcl-cl-opengl)) + +(define-public ecl-cl-opengl + (sbcl-package->ecl-package sbcl-cl-opengl)) + +(define-public sbcl-cl-out123 + (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7") + (revision "2")) + (package + (name "sbcl-cl-out123") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-out123") + (commit commit))) + (file-name (git-file-name "cl-out123" version)) + (sha256 + (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w")) + (modules '((guix build utils))) + (snippet + '(begin + ;; Remove bundled pre-compiled libraries. + (delete-file-recursively "static"))))) + (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") + (description + "This is a bindings library to @code{libout123} which allows easy +cross-platform audio playback.") + (license license:zlib)))) + +(define-public cl-out123 + (sbcl-package->cl-source-package sbcl-cl-out123)) + +(define-public ecl-cl-out123 + (sbcl-package->ecl-package sbcl-cl-out123)) + +(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 cl-package-locks + (sbcl-package->cl-source-package sbcl-cl-package-locks)) + +(define-public ecl-cl-package-locks + (sbcl-package->ecl-package sbcl-cl-package-locks)) + +(define-public sbcl-cl-pass + (let ((commit "e58e97c0c0588dc742c061208afb9bc31e4dbd34") + (revision "1")) + (package + (name "sbcl-cl-pass") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eudoxia0/cl-pass") + (commit commit))) + (file-name (git-file-name "cl-pass" version)) + (sha256 + (base32 "05qx4jrkxqbqi72cxgswbpnifbdvp9mh7apc7566v522899bh0hb")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public cl-pass + (sbcl-package->cl-source-package sbcl-cl-pass)) + +(define-public ecl-cl-pass + (sbcl-package->ecl-package sbcl-cl-pass)) + +(define-public sbcl-cl-pcg + (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f") + (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 cl-pcg + (sbcl-package->cl-source-package sbcl-cl-pcg)) + +(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-public sbcl-cl-pdf + (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213") + (revision "3")) + (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)))) + +(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-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 cl-permutation + (sbcl-package->cl-source-package sbcl-cl-permutation)) + +(define-public ecl-cl-permutation + (sbcl-package->ecl-package sbcl-cl-permutation)) + +(define-public sbcl-cl-portaudio + (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f") + (revision "1")) + (package + (name "sbcl-cl-portaudio") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/filonenko-mikhail/cl-portaudio") + (commit commit))) + (file-name (git-file-name "cl-portaudio" version)) + (sha256 + (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb")))) + (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") + (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-portaudio + (sbcl-package->cl-source-package sbcl-cl-portaudio)) + +(define-public ecl-cl-portaudio + (sbcl-package->ecl-package sbcl-cl-portaudio)) + +(define-public sbcl-cl-posix-mqueue + (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f") + (revision "1")) + (package + (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/xFA25E/cl-posix-mqueue") + (commit commit))) + (file-name (git-file-name "cl-posix-mqueue" version)) + (sha256 + (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 + `(("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 + "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-posix-mqueue + (sbcl-package->cl-source-package sbcl-cl-posix-mqueue)) + +(define-public ecl-cl-posix-mqueue + (sbcl-package->ecl-package sbcl-cl-posix-mqueue)) + +(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-prevalence") + (build-system asdf-build-system/sbcl) + (version (git-version "5" revision commit)) + (home-page "https://github.com/40ants/cl-prevalence") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0")))) + (inputs + (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml)) + (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)) + +(define-public sbcl-cl-progress-bar + (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae")) + (package + (name "sbcl-cl-progress-bar") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sirherrbatka/cl-progress-bar/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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-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-cl-project + (let ((commit "151107014e534fc4666222d57fec2cc8549c8814") + (revision "1")) + (package + (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 name version)) + (sha256 + (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y")))) + (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)))) + +(define-public cl-project + (sbcl-package->cl-source-package sbcl-cl-project)) + +(define-public ecl-cl-project + (sbcl-package->ecl-package sbcl-cl-project)) + +(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-cl-qprint") + (version (git-version "0.9.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eugeneia/cl-qprint/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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-qprint + (sbcl-package->cl-source-package sbcl-cl-qprint)) + +(define-public ecl-cl-qprint + (sbcl-package->ecl-package sbcl-cl-qprint)) + +(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-cl-random") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tpapp/cl-random") + (commit commit))) + (file-name (git-file-name "cl-random" version)) + (sha256 + (base32 "0jn80xphyvyp2v72acr6b8a2f6dw06myr5vrjfl14brsvks7wr89")))) + (build-system asdf-build-system/sbcl) + (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") + (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-random + (sbcl-package->cl-source-package sbcl-cl-random)) + +(define-public ecl-cl-random + (sbcl-package->ecl-package sbcl-cl-random)) + +(define-public sbcl-cl-random-forest + (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91") + (revision "1")) + (package + (name "sbcl-cl-random-forest") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/masatoi/cl-random-forest") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq")))) + (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") + (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-random-forest + (sbcl-package->cl-source-package sbcl-cl-random-forest)) + +(define-public ecl-cl-random-forest + (sbcl-package->ecl-package sbcl-cl-random-forest)) + +(define-public sbcl-cl-raylib + (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d") + (revision "0")) + (package + (name "sbcl-cl-raylib") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/longlene/cl-raylib") + (commit commit))) + (file-name (git-file-name "cl-raylib" version)) + (sha256 + (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 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-raylib + (sbcl-package->cl-source-package sbcl-cl-raylib)) + +(define-public ecl-cl-raylib + (sbcl-package->ecl-package sbcl-cl-raylib)) + +(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-cl-readline") + (version (git-version "0.1.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/vindarel/cl-readline") + (commit commit))) + (file-name (git-file-name "cl-readline" version)) + (sha256 + (base32 "14iskvqfw71ssaav483vmqw62lrpznysjs800gjjppxs785p1fa0")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("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 cl-readline + (sbcl-package->cl-source-package sbcl-cl-readline)) + +(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-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) + (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 "https://github.com/takagi/cl-reexport") + (commit commit))) + (file-name (git-file-name "cl-reexport" version)) + (sha256 + (base32 + "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc")))) + (inputs + (list sbcl-alexandria)) + (native-inputs + (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-reexport + (sbcl-package->cl-source-package sbcl-cl-reexport)) + +(define-public ecl-cl-reexport + (sbcl-package->ecl-package sbcl-cl-reexport)) + +(define-public sbcl-cl-rmath + (let ((commit "f6add1edda31547691d08e36ccf6c17305161aca") + (revision "1")) + (package + (name "sbcl-cl-rmath") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tpapp/cl-rmath") + (commit commit))) + (file-name (git-file-name "cl-rmath" version)) + (sha256 + (base32 "1ld8vbpy10paymx2hn0mcgd21i7cjhdrayln1jx0kayqxm12mmk4")))) + (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") + (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-rmath + (sbcl-package->cl-source-package sbcl-cl-rmath)) + +(define-public ecl-cl-rmath + (sbcl-package->ecl-package sbcl-cl-rmath)) + +(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)))) + +(define-public cl-slice + (sbcl-package->cl-source-package sbcl-cl-slice)) + +(define-public ecl-cl-slice + (sbcl-package->ecl-package sbcl-cl-slice)) + +(define-public sbcl-cl-slug + (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749") + (revision "1")) + (package + (name "sbcl-cl-slug") + (version (git-version "0.4.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/EuAndreh/cl-slug") + (commit commit))) + (file-name (git-file-name "cl-slug" version)) + (sha256 + (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx")))) + (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") + (description + "This is a small Common Lisp library to make slugs, mainly for URIs, +from English and beyond.") + (license license:llgpl)))) + +(define-public cl-slug + (sbcl-package->cl-source-package sbcl-cl-slug)) + +(define-public ecl-cl-slug + (sbcl-package->ecl-package sbcl-cl-slug)) + +(define-public sbcl-cl-smtp + (let ((commit "ed47d326fad867ee11323fa3a0f307b5d40e8f2b") + (revision "0")) + (package + (name "sbcl-cl-smtp") + (version (git-version "20191031.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp") + (commit commit))) + (file-name (git-file-name "cl-smtp" version)) + (sha256 + (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0")))) + (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)))) + +(define-public cl-smtp + (sbcl-package->cl-source-package sbcl-cl-smtp)) + +(define-public ecl-cl-smtp + (sbcl-package->ecl-package sbcl-cl-smtp)) + +(define-public sbcl-cl-spark + (let ((commit "4e34bcebdcf8e45265986eb43ad4ad03bb41a581") + (revision "1")) + (package + (name "sbcl-cl-spark") + (version (git-version "0.1.13" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tkych/cl-spark") + (commit commit))) + (file-name (git-file-name "cl-spark" version)) + (sha256 + (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk")))) + (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)))) + +(define-public cl-spark + (sbcl-package->cl-source-package sbcl-cl-spark)) + +(define-public ecl-cl-spark + (sbcl-package->ecl-package sbcl-cl-spark)) + +(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-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 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+ssl") + (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") + (commit commit))) + (file-name (git-file-name "cl+ssl" version)) + (sha256 + (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s")))) + (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 + 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-cl+ssl + (sbcl-package->cl-source-package sbcl-cl+ssl)) + +(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-cl-steamworks + (let ((commit "9d6a4de653a8cc256ae35e0298912b518aa92ba3") + (revision "1")) + (package + (name "sbcl-cl-steamworks") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/cl-steamworks/") + (commit commit))) + (sha256 + (base32 "1fzj3rlqw1kwdlmh0ga0y71p2n1adflcamzx4yp9kga552c1db5j")) + (file-name (git-file-name "cl-steamworks" version)))) + (build-system asdf-build-system/sbcl) + (inputs + (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-steamworks + (sbcl-package->cl-source-package sbcl-cl-steamworks)) + +(define-public ecl-cl-steamworks + (sbcl-package->ecl-package sbcl-cl-steamworks)) + +(define-public sbcl-cl-store + (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3") + (revision "1")) + (package + (name "sbcl-cl-store") + (version (git-version "0.8.11" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/skypher/cl-store") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr")))) + (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)))) + +(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-cl-strftime") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/cl-strftime/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "00c8hq7vzgb89ab3q7mrp60x743kiqmsk1g51ynhxlqhph2bnslf")))) + (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") + (description + "CL-STRFTIME is a Common Lisp compiler for the strftime “language.”") + (license license:expat)))) + +(define-public cl-strftime + (sbcl-package->cl-source-package sbcl-cl-strftime)) + +(define-public ecl-cl-strftime + (sbcl-package->ecl-package sbcl-cl-strftime)) + +(define-public sbcl-cl-string-match + (let ((revision "1") + (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97")) + (package + (name "sbcl-cl-string-match") + (version (git-version "0" revision changeset)) + (source + (origin + (method hg-fetch) + (uri (hg-reference + (url "https://github.com/vityok/cl-string-match") + (changeset changeset))) + (sha256 + (base32 + "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y")) + (file-name (git-file-name "cl-string-match" version)))) + (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") + (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)))) + +(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-strings + (let ((revision "1") + (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140")) + (package + (name "sbcl-cl-strings") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/diogoalexandrefranco/cl-strings") + (commit commit))) + (sha256 + (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj")) + (file-name (git-file-name "cl-strings" version)))) + (build-system asdf-build-system/sbcl) + (synopsis "Set of utilities to manipulate strings in 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)) + +(define-public ecl-cl-strings + (sbcl-package->ecl-package sbcl-cl-strings)) + +(define-public sbcl-cl-svg + (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc") + (revision "1")) + (package + (name "sbcl-cl-svg") + (version (git-version "0.0.3" 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)) + (sha256 + (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/wmannis/cl-svg") + (synopsis "Write SVG file format") + (description + "This package provides the @code{CL-SVG} Common Lisp system to produce +Scalable Vector Graphics files.") + (license license:expat)))) + +(define-public cl-svg + (sbcl-package->cl-source-package sbcl-cl-svg)) + +(define-public ecl-cl-svg + (sbcl-package->ecl-package sbcl-cl-svg)) + +(define-public sbcl-cl-sxml + (let ((commit "e5542b1d9bd6cee03ae27547d00660ccfbb60109") + (revision "1")) + (package + (name "sbcl-cl-sxml") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eadmund/cl-sxml") + (commit commit))) + (file-name (git-file-name "cl-sxml" 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+)))) + +(define-public cl-sxml + (sbcl-package->cl-source-package sbcl-cl-sxml)) + +(define-public ecl-cl-sxml + (sbcl-package->ecl-package sbcl-cl-sxml)) + +(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-syslog") + (version (git-version "0.2.4" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mmaul/cl-syslog") + (commit commit))) + (file-name (git-file-name "cl-syslog" version)) + (sha256 + (base32 "1qcz55jiqwk91b01hsahxnha884f6zf2883j2m51sqph0mvj69mh")))) + (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 cl-syslog + (sbcl-package->cl-source-package sbcl-cl-syslog)) + +(define-public ecl-cl-syslog + (sbcl-package->ecl-package sbcl-cl-syslog)) + +(define-public sbcl-cl-template + (let ((commit "46193a9a389bb950530e579eae7e6e5a18184832") + (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)))) + +(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://github.com/fisxoj/cl-tga") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/fisxoj/cl-tga") + (synopsis "TGA file loader for Common Lisp") + (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)))) + +(define-public cl-tga + (sbcl-package->cl-source-package sbcl-cl-tga)) + +(define-public ecl-cl-tga + (sbcl-package->ecl-package sbcl-cl-tga)) + +(define-public sbcl-cl-tld + ;; No release. + (let ((commit "f5014da8d831fa9481d4181d4450f10a52850c75")) + (package + (name "sbcl-cl-tld") + (version (git-version "0.1" "2" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lu4nx/cl-tld") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0sxnn35gzdby1ixil6zbjg72vli9fcspwzsqimqk455310syx9iv")))) + (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") + (description + "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 cl-tld + (sbcl-package->cl-source-package sbcl-cl-tld)) + +(define-public ecl-cl-tld + (sbcl-package->ecl-package sbcl-cl-tld)) + +(define-public sbcl-cl-tls + (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba") + (revision "0")) + (package + (name "sbcl-cl-tls") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/shrdlu68/cl-tls") + (commit commit))) + (file-name (git-file-name "cl-tls" version)) + (sha256 + (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7")))) + (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}.") + (license license:bsd-3)))) + +(define-public cl-tls + (sbcl-package->cl-source-package sbcl-cl-tls)) + +(define-public ecl-cl-tls + (sbcl-package->ecl-package sbcl-cl-tls)) + +(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 cl-typesetting + (sbcl-package->cl-source-package sbcl-cl-typesetting)) + +(define-public ecl-cl-typesetting + (sbcl-package->ecl-package sbcl-cl-typesetting)) + +(define-public sbcl-cl-uglify-js + ;; There have been many bug fixes since the 2010 release. + (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5") + (revision "1")) + (package + (name "sbcl-cl-uglify-js") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mishoo/cl-uglify-js") + (commit commit))) + (file-name (git-file-name "cl-uglify-js" version)) + (sha256 + (base32 + "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a")))) + (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)) + +(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-unification") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/cl-unification/cl-unification") + (commit commit))) + (file-name (git-file-name "cl-unification" version)) + (sha256 + (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (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-unification + (sbcl-package->cl-source-package sbcl-cl-unification)) + +(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-cl-utilities + (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b") + (revision "1")) + (package + (name "sbcl-cl-utilities") + (version (git-version "0.0.0" 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")) + (sha256 + (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2")))) + (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") + (description + "On Cliki.net , 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 cl-utilities + (sbcl-package->cl-source-package sbcl-cl-utilities)) + +(define-public ecl-cl-utilities + (sbcl-package->ecl-package sbcl-cl-utilities)) + +(define-public sbcl-cl-variates + (let ((commit "4e7548754d8a8731a42487fae31174db4bf36d47") + (revision "0")) + (package + (name "sbcl-cl-variates") + (version "0.9.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/cl-variates/cl-variates") + (commit commit))) + (file-name (git-file-name "cl-variates" version)) + (sha256 + (base32 "03wnvfi3yfflpvi0mr732r834msij4vrwdbgf6csh0b8kqxl47zn")))) + (build-system asdf-build-system/sbcl) + ;; USE-PACKAGE # causes name-conflicts in + ;; # 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-variates + (sbcl-package->cl-source-package sbcl-cl-variates)) + +(define-public ecl-cl-variates + (sbcl-package->ecl-package sbcl-cl-variates)) + +(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-vorbis") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/cl-vorbis") + (commit commit))) + (file-name (git-file-name "cl-vorbis" 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")))))) + (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 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-vorbis + (sbcl-package->cl-source-package sbcl-cl-vorbis)) + +(define-public ecl-cl-vorbis + (sbcl-package->ecl-package sbcl-cl-vorbis)) + +(define-public sbcl-cl-wayland + (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae") + (revision "0")) + (package + (name "sbcl-cl-wayland") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sdilts/cl-wayland") + (commit commit))) + (file-name (git-file-name "cl-wayland" version)) + (sha256 + (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf")))) + (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)))) + +(define-public cl-wayland + (sbcl-package->cl-source-package sbcl-cl-wayland)) + +(define-public ecl-cl-wayland + (sbcl-package->ecl-package sbcl-cl-wayland)) + +(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-webkit + (sbcl-package->cl-source-package sbcl-cl-webkit)) + +(define-public ecl-cl-webkit + (sbcl-package->ecl-package sbcl-cl-webkit)) + +(define-public sbcl-cl-who + (let ((version "1.1.4") + (commit "07dafe9b351c32326ce20b5804e798f10d4f273d") + (revision "3")) + (package + (name "sbcl-cl-who") + (version (git-version version revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/cl-who") + (commit commit))) + (file-name (git-file-name "cl-who" version)) + (sha256 + (base32 + "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5")))) + (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") + (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)))) + +(define-public cl-who + (sbcl-package->cl-source-package sbcl-cl-who)) + +(define-public ecl-cl-who + (sbcl-package->ecl-package sbcl-cl-who)) + +(define-public sbcl-cl-xmlspam + (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a")) + (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") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (string-append name "-" version)) + (sha256 + (base32 + "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-xmlspam + (sbcl-package->cl-source-package sbcl-cl-xmlspam)) + +(define-public ecl-cl-xmlspam + (sbcl-package->ecl-package sbcl-cl-xmlspam)) + +(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-cl-yaml") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eudoxia0/cl-yaml") + (commit commit))) + (file-name (git-file-name "cl-yaml" version)) + (sha256 + (base32 "1izjg0v6rf7dh069bbnnr67l30lsqj86wdk7y9ggbgiwh6v9j185")))) + (build-system asdf-build-system/sbcl) + (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 + "This is a YAML parser and emitter for Common Lisp built on top of +libyaml.") + (license license:expat)))) + +(define-public cl-yaml + (sbcl-package->cl-source-package sbcl-cl-yaml)) + +(define-public ecl-cl-yaml + (sbcl-package->ecl-package sbcl-cl-yaml)) + +(define-public sbcl-cl-z85 + (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098") + (revision "1")) + (package + (name "sbcl-cl-z85") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/cl-z85") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-cl-octet-streams sbcl-fiveam)) + (synopsis "Common Lisp library for Z85 encoding and decoding") + (description + "This package provides functions to encode or decode byte vectors or +byte streams using the Z85 format, which is a base-85 encoding used by +ZeroMQ.") + (home-page "https://codeberg.org/glv/cl-z85") + (license license:gpl3+)))) + +(define-public cl-z85 + (sbcl-package->cl-source-package sbcl-cl-z85)) + +(define-public ecl-cl-z85 + (sbcl-package->ecl-package sbcl-cl-z85)) + +(define-public sbcl-clache + (let ((commit "112976729565e1035532389ca25090ae99badd07")) + (package + (name "sbcl-clache") + (version (git-version "0.2.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/html/clache/") + (commit commit))) + (file-name (git-file-name "cl-clache" version)) + (sha256 + (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-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 + "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-clache + (sbcl-package->cl-source-package sbcl-clache)) + +(define-public ecl-clache + (sbcl-package->ecl-package sbcl-clache)) + +(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") + (description + "Clack is a web application environment for Common Lisp inspired by +Python's WSGI and Ruby's Rack.") + (license license:llgpl)))) + +(define-public cl-clack + (sbcl-package->cl-source-package sbcl-clack)) + +(define-public ecl-clack + (sbcl-package->ecl-package sbcl-clack)) + +(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 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) + (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") + (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)))) + +(define-public cl-clamp + (sbcl-package->cl-source-package sbcl-clamp)) + +(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") @@ -12447,1736 +10349,613 @@ Import} library for Common Lisp.") ecl-cffi ecl-split-sequence))))) -(define-public sbcl-blackbird - (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8") +(define-public sbcl-clavier + (let ((commit "9b1424eaad131e114a45b400784079124b5e2321") (revision "1")) (package - (name "sbcl-blackbird") - (version (git-version "0.5.2" revision commit)) + (name "sbcl-clavier") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/orthecreedence/blackbird") + (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 - "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c")))) + (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y")))) (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-stefil)) (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-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-blackbird - (sbcl-package->cl-source-package sbcl-blackbird)) +(define-public cl-clavier + (sbcl-package->cl-source-package sbcl-clavier)) -(define-public ecl-blackbird - (sbcl-package->ecl-package sbcl-blackbird)) +(define-public ecl-clavier + (sbcl-package->ecl-package sbcl-clavier)) -(define-public sbcl-cl-async-future - (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959") - (revision "1")) +(define-public sbcl-claw + (let ((revision "0") + (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250")) (package - (name "sbcl-cl-async-future") - (version (git-version "0.4.4.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/orthecreedence/cl-async-future") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-blackbird)) - (native-inputs - (list sbcl-cl-async sbcl-eos)) - (synopsis "Futures implementation for Common Lisp") - (description - "This is futures implementation for Common Lisp. It plugs in nicely -to cl-async.") - (home-page "https://orthecreedence.github.io/cl-async/future") - (license license:expat)))) - -(define-public cl-async-future - (sbcl-package->cl-source-package sbcl-cl-async-future)) - -(define-public ecl-cl-async-future - (sbcl-package->ecl-package sbcl-cl-async-future)) - -(define-public sbcl-green-threads - (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840") - (revision "1")) - (package - (name "sbcl-green-threads") - (version (git-version "0.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/thezerobit/green-threads") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("cl-async-future" ,sbcl-cl-async-future) - ("cl-cont" ,sbcl-cl-cont))) - (native-inputs - (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-green-threads - (sbcl-package->cl-source-package sbcl-green-threads)) - -(define-public ecl-green-threads - (sbcl-package->ecl-package sbcl-green-threads)) - -(define-public sbcl-cl-base32 - (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85") - (revision "1")) - (package - (name "sbcl-cl-base32") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hargettp/cl-base32") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lisp-unit)) - (synopsis "Common Lisp library for base32 encoding and decoding") - (description - "This package provides functions for base32 encoding and decoding as -defined in RFC4648.") - (home-page "https://github.com/hargettp/cl-base32") - (license license:expat)))) - -(define-public cl-base32 - (sbcl-package->cl-source-package sbcl-cl-base32)) - -(define-public ecl-cl-base32 - (sbcl-package->ecl-package sbcl-cl-base32)) - -(define-public sbcl-cl-z85 - (let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098") - (revision "1")) - (package - (name "sbcl-cl-z85") + (name "sbcl-claw") (version (git-version "1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://codeberg.org/glv/cl-z85") + (url "https://github.com/borodust/claw") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "claw" version)) (sha256 - (base32 "0r27pidjaxbm7k1rr90nnajwl5xm2kp65g1fv0fva17lzy45z1mp")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-cl-octet-streams sbcl-fiveam)) - (synopsis "Common Lisp library for Z85 encoding and decoding") - (description - "This package provides functions to encode or decode byte vectors or -byte streams using the Z85 format, which is a base-85 encoding used by -ZeroMQ.") - (home-page "https://codeberg.org/glv/cl-z85") - (license license:gpl3+)))) - -(define-public cl-z85 - (sbcl-package->cl-source-package sbcl-cl-z85)) - -(define-public ecl-cl-z85 - (sbcl-package->ecl-package sbcl-cl-z85)) - -(define-public sbcl-ltk - (let ((commit "ff14a781d211c19c35e65a7ecaece67dda0b3ebb") - (revision "0")) - (package - (name "sbcl-ltk") - (version (git-version "0.992" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/herth/ltk") - (commit commit))) - (file-name (git-file-name "cl-ltk" version)) - (sha256 - (base32 "0f1xgsj2j7bq21cq2pa9rw3ybxd9vyknisl6z307lxx7lvhm3xac")))) + (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d")))) (build-system asdf-build-system/sbcl) (inputs - (list imagemagick tk)) - (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") + (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 - "LTK is a Common Lisp binding for the Tk graphics toolkit. It is -written in pure Common Lisp and does not require any Tk knowledge for its -usage.") - (home-page "http://www.peter-herth.de/ltk/") - (license license:llgpl)))) - -(define-public cl-ltk - (sbcl-package->cl-source-package sbcl-ltk)) - -(define-public ecl-ltk - (sbcl-package->ecl-package sbcl-ltk)) - -(define-public sbcl-cl-lex - (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b") - (revision "1")) - (package - (name "sbcl-cl-lex") - (version (git-version "1.1.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/djr7C4/cl-lex") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-ppcre)) - (synopsis "Common Lisp macros for generating lexical analyzers") - (description - "This is a Common Lisp library providing a set of macros for generating -lexical analyzers automatically. The lexers generated using @code{cl-lex} can -be used with @code{cl-yacc}.") - (home-page "https://github.com/djr7C4/cl-lex") - (license license:gpl3)))) - -(define-public cl-lex - (sbcl-package->cl-source-package sbcl-cl-lex)) - -(define-public ecl-cl-lex - (sbcl-package->ecl-package sbcl-cl-lex)) - -(define-public sbcl-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 ecl-cl-colors2 - (sbcl-package->ecl-package sbcl-cl-colors2)) - -(define-public sbcl-colored - (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb") - (revision "1")) - (package - (name "sbcl-colored") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/colored/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k")))) - (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)))) - -(define-public cl-colored - (sbcl-package->cl-source-package sbcl-colored)) - -(define-public ecl-colored - (sbcl-package->ecl-package sbcl-colored)) - -(define-public sbcl-cl-jpeg - (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af") - (revision "1")) - (package - (name "sbcl-cl-jpeg") - (version (git-version "2.8" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/cl-jpeg") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy")))) - (build-system asdf-build-system/sbcl) - (synopsis "JPEG image library for Common Lisp") - (description - "This is a baseline JPEG codec written in Common Lisp. It can be used -for reading and writing JPEG image files.") - (home-page "https://github.com/sharplispers/cl-jpeg") - (license license:bsd-3)))) - -(define-public cl-jpeg - (sbcl-package->cl-source-package sbcl-cl-jpeg)) - -(define-public ecl-cl-jpeg - (sbcl-package->ecl-package sbcl-cl-jpeg)) - -(define-public sbcl-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://github.com/shamazmazum/jpeg-turbo/") - (commit commit))) - (file-name (git-file-name "cl-jpeg-turbo" version)) - (sha256 - (base32 "1andd1ibbk3224idnpsnrn96flr5d1wm9ja3di57fs04wn577sag")))) - (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/") + "This is a Common Lisp autowrapping facility for quickly creating clean +and lean bindings to C libraries.") (license license:bsd-2)))) -(define-public cl-jpeg-turbo - (sbcl-package->cl-source-package sbcl-jpeg-turbo)) +(define-public cl-claw + (sbcl-package->cl-source-package sbcl-claw)) -(define-public ecl-cl-jpeg-turbo - (sbcl-package->ecl-package sbcl-jpeg-turbo)) +(define-public ecl-claw + (sbcl-package->ecl-package sbcl-claw)) -(define-public sbcl-png - (let ((commit "11b965fe378fd0561abe3616b18ff03af5179648") - (revision "1")) - (package - (name "sbcl-png") - (version (git-version "0.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ljosa/cl-png") - (commit commit))) - (file-name (git-file-name "cl-png" version)) - (sha256 - (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 - `(("cffi" ,sbcl-cffi) - ("libpng" ,libpng))) - (home-page "https://github.com/ljosa/cl-png") - (synopsis "Read and write PNG file format") - (description - "This package provides a @code{PNG} Common Lisp system to operate with -Portable Network Graphics file format.") - (license license:lgpl2.1)))) - -(define-public ecl-png - (sbcl-package->ecl-package sbcl-png)) - -(define-public cl-png - (sbcl-package->cl-source-package sbcl-png)) - -(define-public sbcl-cl-svg - (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc") - (revision "1")) - (package - (name "sbcl-cl-svg") - (version (git-version "0.0.3" 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)) - (sha256 - (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/wmannis/cl-svg") - (synopsis "Write SVG file format") - (description - "This package provides the @code{CL-SVG} Common Lisp system to produce -Scalable Vector Graphics files.") - (license license:expat)))) - -(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")) - (package - (name "sbcl-nodgui") - (version (git-version "0.6.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/cage/nodgui.git") - (commit commit))) - (file-name (git-file-name "cl-nodgui" version)) - (sha256 - (base32 "0j98mcq0mn3wrlqm3j29pv530q0pkq00sk6liai97an51i1n08g6")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-nodgui - (sbcl-package->cl-source-package sbcl-nodgui)) - -(define-public ecl-nodgui - (sbcl-package->ecl-package sbcl-nodgui)) - -(define-public sbcl-salza2 +(define-public sbcl-claw-support (package - (name "sbcl-salza2") - (version "2.1") + (name "sbcl-claw-support") + (version "1.0.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/xach/salza2") - (commit (string-append "release-" version)))) + (url "https://github.com/borodust/claw-support") + (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b"))) (file-name (git-file-name name version)) (sha256 - (base32 "1p48lxdibnps5rpyh5cmnk0vc77bmmxb32qdzfz93zadr8wwas10")))) + (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23")))) (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") + (home-page "https://github.com/borodust/claw-support") + (synopsis "Support routines for claw") (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))) + "This package provides support routines for the @code{claw} Common Lisp +package.") + (license license:expat))) -(define-public cl-salza2 - (sbcl-package->cl-source-package sbcl-salza2)) +(define-public cl-claw-support + (sbcl-package->cl-source-package sbcl-claw-support)) -(define-public ecl-salza2 - (sbcl-package->ecl-package sbcl-salza2)) +(define-public ecl-claw-support + (sbcl-package->ecl-package sbcl-claw-support)) -(define-public sbcl-origin - (let ((commit "d646134302456408d6d43580bb05299f1695ab8e") - (revision "1")) +(define-public sbcl-claw-utils + (let ((revision "0") + (commit "efe25016501973dc369f067a64c7d225802bc56f")) (package - (name "sbcl-origin") - (version (git-version "2.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://git.mfiano.net/mfiano/origin") + (url "https://github.com/borodust/claw-utils") (commit commit))) - (file-name (git-file-name "origin" version)) + (file-name (git-file-name "claw-utils" version)) (sha256 - (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b")))) + (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5")))) (build-system asdf-build-system/sbcl) - (native-inputs - (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") + (list sbcl-alexandria sbcl-cffi sbcl-claw)) + (home-page "https://github.com/borodust/claw-utils") + (synopsis "Utilities for easier autowrapping") (description - "This is a native Common Lisp graphics math library with an emphasis on -performance and correctness.") + "This Common Lisp library contains various handy utilities to help +autowrapping with @code{claw}.") (license license:expat)))) -(define-public ecl-origin - (sbcl-package->ecl-package sbcl-origin)) +(define-public cl-claw-utils + (sbcl-package->cl-source-package sbcl-claw-utils)) -(define-public cl-origin - (sbcl-package->cl-source-package sbcl-origin)) +(define-public ecl-claw-utils + (sbcl-package->ecl-package sbcl-claw-utils)) -(define-public sbcl-png-read - (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88") - (revision "1")) +(define-public sbcl-clawk + (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6")) (package - (name "sbcl-png-read") - (version (git-version "0.3.1" revision commit)) + (name "sbcl-clawk") + (version (git-version "4" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Ramarren/png-read") + (url "https://github.com/sharplispers/clawk") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0")))) + (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a")))) (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") - (license license:bsd-3)))) + (list sbcl-regex)) + (home-page "https://github.com/sharplispers/clawk") + (synopsis "Common Lisp AWK") + (description + "CLAWK is an AWK implementation embedded into Common Lisp.") + (license license:bsd-2)))) -(define-public cl-png-read - (sbcl-package->cl-source-package sbcl-png-read)) +(define-public cl-clawk + (sbcl-package->cl-source-package sbcl-clawk)) -(define-public ecl-png-read - (sbcl-package->ecl-package sbcl-png-read)) +(define-public ecl-clawk + (sbcl-package->ecl-package sbcl-clawk)) -(define-public sbcl-3b-bmfont - (let ((commit "332c2262705f161627fc18add0310451a42799af") - (revision "3")) +(define-public sbcl-clesh + (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11")) (package - (name "sbcl-3b-bmfont") - (version (git-version "0.0.1" 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/3b/3b-bmfont/") + (url "https://github.com/Neronus/Clesh") (commit commit))) - (file-name (git-file-name "cl-3b-bmfont" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6")))) + (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-trivial-shell sbcl-named-readtables)) + (home-page "https://github.com/Neronus/Clesh") + (synopsis "Embed shell code in Common Lisp") + (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)))) + +(define-public cl-clesh + (sbcl-package->cl-source-package sbcl-clesh)) + +(define-public ecl-clesh + (sbcl-package->ecl-package sbcl-clesh)) + +(define-public sbcl-clinenoise + (let ((commit "46e21f99d06a55d93eaa382cf652d55d457032ef") + (revision "1")) + (package + (name "sbcl-clinenoise") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/jasom/clinenoise") + (commit commit))) + (file-name (git-file-name "clinenoise" version)) + (sha256 + (base32 "0ydlirfk4dbpqqjwwph99v5swcrhd8v9g8q24fvs35wn2vm08lh1")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-cffi sbcl-split-sequence)) + (home-page "https://github.com/jasom/clinenoise") + (synopsis "Port of linenoise to Common Lisp") + (description + "This package provides a trivial line-input library for VT-like +terminals.") + (license license:bsd-2)))) + +(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-clingon") + (version (git-version "0.5.0" revision commit)) + (source + (origin + (method git-fetch) + (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) + (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") + (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)))) + +(define-public cl-clingon + (sbcl-package->cl-source-package sbcl-clingon)) + +(define-public ecl-clingon + (sbcl-package->ecl-package sbcl-clingon)) + +(define-public sbcl-clip + (let ((commit "7afa68702fbb99c47ed115ea0faccd97a29d9b2e") + (revision "1")) + (package + (name "sbcl-clip") + (version (git-version "0.7.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/shinmera/clip") + (commit commit))) + (file-name (git-file-name "clip" version)) + (sha256 + (base32 "13kkajkva2shm19fvn4yashsw18l6imv2rmy3hmpcky7g5ay7bv3")))) + (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") + (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)))) + +(define-public cl-clip + (sbcl-package->cl-source-package sbcl-clip)) + +(define-public ecl-clip + (sbcl-package->ecl-package sbcl-clip)) + +(define-public sbcl-clml + (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8") + (revision "0")) + (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) - (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-array-operations + sbcl-cl-fad + sbcl-cl-ppcre + sbcl-drakma + sbcl-introspect-environment + sbcl-iterate + sbcl-lparallel sbcl-parse-number - sbcl-split-sequence)) - (home-page "https://github.com/3b/3b-bmfont/") - (synopsis "Read/write bmfont metadata files") + sbcl-split-sequence + sbcl-trivial-garbage)) + (synopsis "Common Lisp machine learning library") (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)))) + "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 ecl-3b-bmfont - (sbcl-package->ecl-package sbcl-3b-bmfont)) +(define-public cl-clml + (sbcl-package->cl-source-package sbcl-clml)) -(define-public cl-3b-bmfont - (sbcl-package->cl-source-package sbcl-3b-bmfont)) - -(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-sdf - ;; Shinmera's fork required for Alloy. - (let ((commit "e1ab3ac4ea52c0e0119b832f428c71f580b4d83b") - (revision "1")) +(define-public sbcl-clobber + (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98") + (revision "0")) (package - (name "sbcl-sdf") - (version (git-version "0.0.1" revision commit)) + (name "sbcl-clobber") + (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/sdf") + (url "https://github.com/robert-strandh/Clobber") (commit commit))) - (file-name (git-file-name "sdf" version)) + (file-name (git-file-name "cl-clobber" version)) (sha256 - (base32 "1cyq4hkgiw9mnb87ah6xw19cybfs9hfbjvg1ch2mf4cr0ism0nvn")))) + (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n")))) (build-system asdf-build-system/sbcl) - (inputs - (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") + (home-page "https://github.com/robert-strandh/Clobber") + (synopsis "Common Lisp Library for transaction-oriented databases") (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)))) + "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 ecl-sdf - (sbcl-package->ecl-package sbcl-sdf)) +(define-public cl-clobber + (sbcl-package->cl-source-package sbcl-clobber)) -(define-public cl-sdf - (sbcl-package->cl-source-package sbcl-sdf)) +(define-public ecl-clobber + (sbcl-package->ecl-package sbcl-clobber)) -(define-public sbcl-zpng +(define-public sbcl-clog (package - (name "sbcl-zpng") - (version "1.2.2") + (name "sbcl-clog") + (version "1.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-zpng - (sbcl-package->ecl-package sbcl-zpng)) - -(define-public sbcl-cl-qrencode - (package - (name "sbcl-cl-qrencode") - (version "0.1.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jnjcc/cl-qrencode") + (url "https://github.com/rabbibotton/clog") (commit (string-append "v" version)))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-clog" 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-hdf5-cffi - (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c") - (revision "1")) - (package - (name "sbcl-hdf5-cffi") - (version (git-version "1.8.18" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hdfgroup/hdf5-cffi") - (commit commit))) - (file-name (git-file-name "cl-hdf5-cffi" version)) - (sha256 - (base32 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf")))) - (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp bindings for the HDF5 library") - (description - "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.") - (home-page "https://github.com/hdfgroup/hdf5-cffi") - (license (license:non-copyleft - (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/" - commit - "/LICENSE"))) - (inputs - (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-hdf5-cffi - (sbcl-package->cl-source-package sbcl-hdf5-cffi)) - -(define-public ecl-hdf5-cffi - (sbcl-package->ecl-package sbcl-hdf5-cffi)) - -(define-public sbcl-history-tree - (package - (name "sbcl-history-tree") - (version "0.1.2") - (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)) - (sha256 - (base32 "1n3q6aqh0wm24pksj8371j5iinxpzy2kcnz97kmpndm1yhv4x5f2")))) + (base32 "0f4i6571nm0j704zgnh60sc9slifs11byb2gs8gamqjcfh931dap")))) (build-system asdf-build-system/sbcl) (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-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 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).") + "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-history-tree - (sbcl-package->cl-source-package sbcl-history-tree)) +(define-public cl-clog + (sbcl-package->cl-source-package sbcl-clog)) -(define-public ecl-history-tree - (sbcl-package->ecl-package sbcl-history-tree)) +(define-public ecl-clog + (sbcl-package->ecl-package sbcl-clog)) -(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-float-features - (let ((commit "c1f86aea91cfaa3aa59799162be23ef8a12b199d") - (revision "2")) +(define-public sbcl-clop + (let ((commit "c0c3fe7efa5ac95ba1644febfb2c2acab757fcda") + (revision "0")) (package - (name "sbcl-float-features") - (version (git-version "1.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/float-features") + (url "https://github.com/sheepduke/clop") (commit commit))) - (file-name (git-file-name "float-features" version)) + (file-name (git-file-name "cl-clop" version)) (sha256 - (base32 "0vqm9xhn2i4vbjrxnp4hr1l3lydjflhjykdz6cmqg2j48c5kh3g3")))) + (base32 "1q7rlizr8gcbfz4a9660gdbw7d2zbld18akjpibg54j7jh5kb8gc")))) (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)))) - -(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-cache-while - (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7") - (revision "1")) - (package - (name "sbcl-cache-while") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/charje/cache-while") - (commit commit))) - (file-name (git-file-name "cache-while" version)) - (sha256 - (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3")))) - (build-system asdf-build-system/sbcl) - (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-cache-while - (sbcl-package->cl-source-package sbcl-cache-while)) - -(define-public ecl-cache-while - (sbcl-package->ecl-package sbcl-cache-while)) - -(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-type-r - (sbcl-package->cl-source-package sbcl-type-r)) - -(define-public ecl-type-r - (sbcl-package->ecl-package sbcl-type-r)) - -(define-public sbcl-trivialib-type-unify - (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99") - (revision "1")) - (package - (name "sbcl-trivialib-type-unify") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/guicho271828/trivialib.type-unify") - (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 cl-trivialib-type-unify - (sbcl-package->cl-source-package sbcl-trivialib-type-unify)) - -(define-public ecl-trivialib-type-unify - (sbcl-package->ecl-package sbcl-trivialib-type-unify)) - -(define-public sbcl-cl-unification - (let ((commit "01079f34d197495880aa49ab727d63774d83035c") - (revision "1")) - (package - (name "sbcl-cl-unification") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-unification/cl-unification") - (commit commit))) - (file-name (git-file-name "cl-unification" version)) - (sha256 - (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (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 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 cl-unification - (sbcl-package->cl-source-package sbcl-cl-unification)) - -(define-public sbcl-specialized-function - (let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247") - (revision "3")) - (package - (name "sbcl-specialized-function") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/numcl/specialized-function") - (commit commit))) - (file-name (git-file-name "specialized-function" version)) - (sha256 - (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 - `(("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-fiveam))))) - -(define-public cl-specialized-function - (sbcl-package->cl-source-package sbcl-specialized-function)) - -(define-public ecl-specialized-function - (sbcl-package->ecl-package sbcl-specialized-function)) - -(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") - (revision "1")) - (package - (name "sbcl-constantfold") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/numcl/constantfold") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06")))) - (build-system asdf-build-system/sbcl) - (synopsis "Support library for numcl") - (description - "Support library for numcl. Registers a function as an -additional form that is considered as a candidate for a constant.") - (home-page "https://github.com/numcl/constantfold") - (license license:lgpl3+) - (inputs - `(("trivia" ,sbcl-trivia) - ("alexandria" ,sbcl-alexandria) - ("iterate" ,sbcl-iterate) - ("lisp-namespace" ,sbcl-lisp-namespace))) - (native-inputs - (list sbcl-fiveam))))) - -(define-public cl-constantfold - (sbcl-package->cl-source-package sbcl-constantfold)) - -(define-public ecl-constantfold - (sbcl-package->ecl-package sbcl-constantfold)) - -(define-public sbcl-gtype - (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18") - (revision "2")) - (package - (name "sbcl-gtype") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/numcl/gtype") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h")))) - (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))))) - -(define-public cl-gtype - (sbcl-package->cl-source-package sbcl-gtype)) - -(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-numcl - (let ((commit "a28f612d072e5f93137584de5155a42243b3bd6b") - (revision "3")) - (package - (name "sbcl-numcl") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/numcl/numcl") - (commit commit))) - (file-name (git-file-name "numcl" version)) - (sha256 - (base32 "15m4spbgayawnw5jjz04zfp0jnk9g6hgq5fmr648hzjzj50j1d78")))) - (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)) (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") + (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 - "This package is a Python Numpy clone implemented in pure Common Lisp.") - (license license:lgpl3+)))) - -(define-public cl-numcl - (sbcl-package->cl-source-package sbcl-numcl)) - -(define-public ecl-numcl - (sbcl-package->ecl-package sbcl-numcl)) - -(define-public sbcl-pzmq - (let ((commit "6f7b2ca02c23ea53510a9b0e0f181d5364ce9d32") - (revision "2")) - (package - (name "sbcl-pzmq") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/orivej/pzmq") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "19mdhxhzzghlmff1fic4chg5iz0psglkim09z6dgpijm26biny05")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("bordeaux-threads" ,sbcl-bordeaux-threads) - ("fiveam" ,sbcl-fiveam) - ("let-plus" ,sbcl-let-plus))) - (inputs - `(("cffi" ,sbcl-cffi) - ("zeromq" ,zeromq))) - (arguments - `(#:phases (modify-phases %standard-phases - (add-after 'unpack 'fix-paths - (lambda* (#:key inputs #:allow-other-keys) - (substitute* "c-api.lisp" - (("\"libzmq") - (string-append "\"" - (assoc-ref inputs "zeromq") - "/lib/libzmq"))) - #t))))) - (synopsis "Common Lisp bindings for the ZeroMQ library") - (description "This Common Lisp library provides bindings for the ZeroMQ -lightweight messaging kernel.") - (home-page "https://github.com/orivej/pzmq") - (license license:unlicense)))) - -(define-public cl-pzmq - (sbcl-package->cl-source-package sbcl-pzmq)) - -(define-public ecl-pzmq - (sbcl-package->ecl-package sbcl-pzmq)) - -(define-public sbcl-clss - (let ((revision "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/clss") - (commit commit))) - (sha256 - (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv")) - (file-name (git-file-name name version)))) - (inputs - (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-clss - (sbcl-package->cl-source-package sbcl-clss)) - -(define-public ecl-clss - (sbcl-package->ecl-package sbcl-clss)) - -(define-public sbcl-lquery - (let ((revision "1") - (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d")) - (package - (name "sbcl-lquery") - (version (git-version "3.2.1" revision commit)) - (source - (origin - (method git-fetch) - (uri - (git-reference - (url "https://github.com/Shinmera/lquery") - (commit commit))) - (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)) - (build-system asdf-build-system/sbcl) - (synopsis "Library to allow jQuery-like HTML/DOM manipulation") - (description "@code{lQuery} is a DOM manipulation library written in -Common Lisp, inspired by and based on the jQuery syntax and -functions. It uses Plump and CLSS as DOM and selector engines. The -main idea behind lQuery is to provide a simple interface for crawling -and modifying HTML sites, as well as to allow for an alternative -approach to templating.") - (home-page "https://github.com/Shinmera/lquery") - (license license:zlib)))) - -(define-public cl-lquery - (sbcl-package->cl-source-package sbcl-lquery)) - -(define-public ecl-lquery - (sbcl-package->ecl-package sbcl-lquery)) - -(define-public sbcl-cl-mysql - (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9") - (revision "1")) - (package - (name "sbcl-cl-mysql") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hackinghat/cl-mysql") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr")))) - (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") - (description - "@code{cl-mysql} is a Common Lisp implementation of a MySQL wrapper.") - (home-page "http://www.hackinghat.com/index.php/cl-mysql") + "Clop is a Common Lisp library for parsing strings in the TOML +configuration file format.") (license license:expat)))) -(define-public cl-mysql - (sbcl-package->cl-source-package sbcl-cl-mysql)) +(define-public cl-clop + (sbcl-package->cl-source-package sbcl-clop)) -(define-public ecl-cl-mysql - (sbcl-package->ecl-package sbcl-cl-mysql)) +(define-public ecl-clop + (sbcl-package->ecl-package sbcl-clop)) -(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-db3 - (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d") - (revision "1")) +(define-public sbcl-closer-mop + (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc") + (revision "3")) (package - (name "sbcl-db3") + (name "sbcl-closer-mop") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pcostanza/closer-mop") + (commit commit))) + (sha256 + (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16")) + (file-name (git-file-name "cl-closer-mop" version )))) + (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)))) + +(define-public cl-closer-mop + (sbcl-package->cl-source-package sbcl-closer-mop)) + +(define-public ecl-closer-mop + (sbcl-package->ecl-package sbcl-closer-mop)) + +(define-public sbcl-clostrum + (let ((commit "c85d38bde9d093f1f132574e9b98b8d64683cd51") + (revision "0")) + (package + (name "sbcl-clostrum") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dimitri/cl-db3") + (url "https://github.com/s-expressionists/Clostrum") (commit commit))) - (file-name (git-file-name "cl-db3" version)) + (file-name (git-file-name "cl-clostrum" commit)) (sha256 - (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5")))) + (base32 "10alsdnpzbgic75xghwjp414sqwg4npvp69zn0r4l8ms0ki9zr1x")))) (build-system asdf-build-system/sbcl) - (home-page "https://github.com/dimitri/cl-db3") - (synopsis "Common Lisp library to read dBase III database files") + (native-inputs (list sbcl-fiveam)) + (home-page "https://github.com/s-expressionists/Clostrum") + (synopsis "First Class Global Environments") (description - "This is a Common Lisp library for processing data found in dBase III -database files (dbf and db3 files).") - (license license:public-domain)))) + "This package provides first-class global environments for +Common Lisp.") + (license license:bsd-2)))) -(define-public ecl-db3 - (sbcl-package->ecl-package sbcl-db3)) +(define-public cl-clostrum + (sbcl-package->cl-source-package sbcl-clostrum)) -(define-public cl-db3 - (sbcl-package->cl-source-package sbcl-db3)) +(define-public ecl-clostrum + (sbcl-package->ecl-package sbcl-clostrum)) -(define-public sbcl-dbi - (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227") - (revision "2")) +(define sbcl-closure-common + (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c") + (revision "1")) (package - (name "sbcl-dbi") - (version (git-version "0.9.5" 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/fukamachi/cl-dbi") + (url "https://github.com/sharplispers/closure-common") (commit commit))) - (file-name (git-file-name "cl-dbi" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg")))) - (build-system asdf-build-system/sbcl) - (native-inputs - `(("alexandria" ,sbcl-alexandria) - ("rove" ,sbcl-rove) - ("trivial-types" ,sbcl-trivial-types))) + (base32 + "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n")))) (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") + `(("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-closure-template + ;; There are no releases since 2015. + (let ((commit "f1983aa525045691e128027d2a2d74831c873d6e") + (revision "0")) + (package + (name "sbcl-closure-template") + (version (git-version "0.2.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/archimag/cl-closure-template") + (commit commit))) + (file-name (git-file-name "cl-closure-template" version)) + (sha256 + (base32 "16h0fs6bjjd4n9pbkwcprpgyj26vsw2akk3q08m7xmsmqi05dppv")))) + (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") (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") + "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-dbi - (sbcl-package->cl-source-package sbcl-dbi)) +(define-public cl-closure-template + (sbcl-package->cl-source-package sbcl-closure-template)) -(define-public ecl-dbi - (sbcl-package->ecl-package sbcl-dbi)) - -(define-public sbcl-uffi - (package - (name "sbcl-uffi") - (version "2.1.2") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://git.kpe.io/uffi.git") - (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)))) - (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") - (description - "UFFI provides a universal foreign function interface (FFI) - for Common Lisp.") - (home-page "https://quickdocs.org/uffi/") - (license license:llgpl))) - -(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 ecl-closure-template + (sbcl-package->ecl-package sbcl-closure-template)) (define-public sbcl-clsql (package @@ -14337,102 +11116,2809 @@ interfaces as well as a functional and an object oriented interface.") ((#:asd-systems asd-systems '()) `(cons "clsql-cffi" ,asd-systems))))))) -(define-public sbcl-sycamore - (let ((commit "fd2820fec165ad514493426dea209728f64e6d18")) +(define-public sbcl-clss + (let ((revision "2") + (commit "f62b849189c5d1be378f0bd3d403cda8d4fe310b")) (package - (name "sbcl-sycamore") - (version "0.0.20120604") + (name "sbcl-clss") + (version (git-version "0.3.1" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/Shinmera/clss") + (commit commit))) + (sha256 + (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv")) + (file-name (git-file-name name version)))) + (inputs + (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-clss + (sbcl-package->cl-source-package sbcl-clss)) + +(define-public ecl-clss + (sbcl-package->ecl-package sbcl-clss)) + +(define-public sbcl-cluffer + (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a")) + (package + (name "sbcl-cluffer") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/ndantam/sycamore/") + (url "https://github.com/robert-strandh/cluffer") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7")))) + (base32 + "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj")))) (build-system asdf-build-system/sbcl) (inputs - (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: + (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)))) -@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-cluffer + (sbcl-package->cl-source-package sbcl-cluffer)) -(define-public cl-sycamore - (sbcl-package->cl-source-package sbcl-sycamore)) +(define-public ecl-cluffer + (sbcl-package->ecl-package sbcl-cluffer)) -(define-public ecl-sycamore - (sbcl-package->ecl-package sbcl-sycamore)) - -(define-public sbcl-funds - (let ((commit "39d425818876b898c20780a678803df506df8424") - (revision "2")) +(define-public sbcl-clump + (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a")) (package - (name "sbcl-funds") - (version (git-version "1" revision commit)) + (name "sbcl-clump") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/charJe/funds") + (url "https://github.com/robert-strandh/Clump") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "13y1jhvnpzrs9daz6f3z67w6h2y21ggb10j3j4vnc5p3m8i7ps4p")))) + (base32 + "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh")))) + (inputs + (list sbcl-acclimation)) (build-system asdf-build-system/sbcl) - (synopsis "Purely functional data structure library in Common Lisp") + (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)))) + +(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-cluster") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/robert-strandh/Cluster") + (commit commit))) + (file-name (git-file-name "cl-cluster" commit)) + (sha256 + (base32 "0ixbr3wm7d3m8mgzasd95rxvs9kip6ngr5s1zk7j3604mcfssqyi")))) + (build-system asdf-build-system/sbcl) + (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 - "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)))) + "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 cl-funds - (sbcl-package->cl-source-package sbcl-funds)) +(define-public cl-cluster + (sbcl-package->cl-source-package sbcl-cluster)) -(define-public ecl-funds - (sbcl-package->ecl-package sbcl-funds)) +(define-public ecl-cluster + (sbcl-package->ecl-package sbcl-cluster)) -(define-public sbcl-trivial-package-local-nicknames +(define-public sbcl-clx + (let ((commit "38400456d66823e417d1d27d339b09885e25eb59") + (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)))) + +(define-public cl-clx + (sbcl-package->cl-source-package sbcl-clx)) + +(define-public ecl-clx + (sbcl-package->ecl-package sbcl-clx)) + +(define-public sbcl-clx-truetype + (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8") + (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)))) + +(define-public cl-clx-truetype + (sbcl-package->cl-source-package sbcl-clx-truetype)) + +(define-public ecl-clx-truetype + (sbcl-package->ecl-package sbcl-clx-truetype)) + +(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-cmd + (let ((commit "0164d574ba236e2001ee1d9dba3f4774c7512a8c") + (revision "8")) + (package + (name "sbcl-cmd") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/cmd/") + (commit commit))) + (file-name (git-file-name "cl-cmd" version)) + (sha256 + (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 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 + "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-cmd + (sbcl-package->cl-source-package sbcl-cmd)) + +(define-public ecl-cmd + (sbcl-package->ecl-package sbcl-cmd)) + +(define-public sbcl-cmn (package - (name "sbcl-trivial-package-local-nicknames") - (version "0.2") - (home-page "https://github.com/phoe/trivial-package-local-nicknames") + (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-coalton") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/coalton-lang/coalton") + (commit commit))) + (file-name (git-file-name "cl-coalton" version)) + (sha256 + (base32 "08qzj3v4fvn9h87whyqg650rpap8lva7jr94d1akv6m2z62l5q68")))) + (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") + (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)))) + +(define-public cl-coalton + (sbcl-package->cl-source-package sbcl-coalton)) + +(define-public ecl-coalton + (sbcl-package->ecl-package sbcl-coalton)) + +(define-public sbcl-coleslaw + (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40") + (revision "0")) + (package + (name "sbcl-coleslaw") + (version (git-version "0.9.7" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/coleslaw-org/coleslaw") + (commit commit))) + (file-name (git-file-name "cl-coleslaw" version)) + (sha256 + (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws")))) + (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)) + (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 + "Coleslaw is a static site generator written in Common Lisp.") + (license license:bsd-2)))) + +(define-public cl-coleslaw + (sbcl-package->cl-source-package sbcl-coleslaw)) + +(define-public ecl-coleslaw + (sbcl-package->ecl-package sbcl-coleslaw)) + +(define-public sbcl-collectors + (let ((commit "4c5e70cf399381de8fb485d4ed5a5c8fd7555146") + (revision "2")) + (package + (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-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-collectors + (sbcl-package->cl-source-package sbcl-collectors)) + +(define-public ecl-collectors + (sbcl-package->ecl-package sbcl-collectors)) + +(define-public sbcl-colored + (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb") + (revision "1")) + (package + (name "sbcl-colored") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/colored/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k")))) + (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)))) + +(define-public cl-colored + (sbcl-package->cl-source-package sbcl-colored)) + +(define-public ecl-colored + (sbcl-package->ecl-package sbcl-colored)) + +(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-colorize + (sbcl-package->cl-source-package sbcl-colorize)) + +(define-public ecl-colorize + (sbcl-package->ecl-package sbcl-colorize)) + +(define-public sbcl-com.gigamonkeys.binary-data + (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee") + (revision "0")) + (package + (name "sbcl-com.gigamonkeys.binary-data") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gigamonkey/monkeylib-binary-data") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw")))) + (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") + (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)))) + +(define-public cl-com.gigamonkeys.binary-data + (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data)) + +(define-public ecl-com.gigamonkeys.binary-data + (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data)) + +(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 home-page) - (commit "16b7ad4c2b120f50da65154191f468ea5598460e"))) - (file-name (git-file-name name version)) + (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 "18qc27xkjzdcqrilpk3pm7djldwq5rm3ggd5h9cr8hqcd54i2fqg")))) + (base32 "140xnz2v0v3hfg3dp2fhidw8ns6lxd3a5knm07wqdp48ksg119wy")))) (build-system asdf-build-system/sbcl) - (synopsis "Common Lisp compatibility library for package local nicknames") + (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-command-line-args + (sbcl-package->cl-source-package sbcl-command-line-args)) + +(define-public ecl-command-line-args + (sbcl-package->ecl-package sbcl-command-line-args)) + +(define-public sbcl-command-line-arguments + (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe") + (revision "1")) + (package + (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/fare/command-line-arguments") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq")))) + (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)))) + +(define-public cl-command-line-arguments + (sbcl-package->cl-source-package sbcl-command-line-arguments)) + +(define-public ecl-command-line-arguments + (sbcl-package->ecl-package sbcl-command-line-arguments)) + +(define-public sbcl-common-lisp-jupyter + (let ((commit "ba9f0e746b9200d6fd6db647d7274448119ed01b") + (revision "3")) + (package + (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/yitzchak/common-lisp-jupyter") + (commit commit))) + (file-name (git-file-name "common-lisp-jupyter" commit)) + (sha256 + (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-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 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 cl-common-lisp-jupyter + (sbcl-package->cl-source-package sbcl-common-lisp-jupyter)) + +(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 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.") + "This library validates superclasses according to a simple substitution +model, thereby greatly simplifying the definition of class mixins.") (license license:unlicense))) -(define-public cl-trivial-package-local-nicknames - (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames)) +(define-public cl-compatible-metaclasses + (sbcl-package->cl-source-package sbcl-compatible-metaclasses)) -(define-public ecl-trivial-package-local-nicknames - (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames)) +(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-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")))) + (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)))) + +(define-public cl-compiler-macro + (sbcl-package->cl-source-package sbcl-compiler-macro)) + +(define-public ecl-compiler-macro + (sbcl-package->ecl-package sbcl-compiler-macro)) + +(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-computable-reals") + (version (git-version "1.1.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/stylewarning/computable-reals") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0f12axi53x14l12dgf4a1lfq3p1fx7fh7sjfc0db3lk88ph9qfwl")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/stylewarning/computable-reals") + (synopsis "Arbitrary-precision, re-computing real-numbers in Common Lisp") + (description + "This library provides arbitrary precision (floating point) real +numbers in Common Lisp.") + (license license:bsd-3)))) + +(define-public cl-computable-reals + (sbcl-package->cl-source-package sbcl-computable-reals)) + +(define-public ecl-computable-reals + (sbcl-package->ecl-package sbcl-computable-reals)) + +(define-public sbcl-concrete-syntax-tree + (let ((commit "37291727196a3bc88a7be67c1427c52078d4b82c") + (revision "0")) + (package + (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/s-expressionists/Concrete-Syntax-Tree") + (commit commit))) + (file-name (git-file-name "cl-concrete-syntax-tree" commit)) + (sha256 + (base32 "15q9jyqsh2z921li9my8c840cj2ci7k217x5frfiyk0kymkx4rgv")))) + (build-system asdf-build-system/sbcl) + (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 + "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)))) + +(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-concurrent-hash-tables") + (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)) + (sha256 + (base32 "0wgbv3wl33rlfbywmjag0gk7igzfksmib30r8cbnd5n47ic09iip")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public cl-concurrent-hash-tables + (sbcl-package->cl-source-package sbcl-concurrent-hash-tables)) + +(define-public ecl-concurrent-hash-tables + (sbcl-package->ecl-package sbcl-concurrent-hash-tables)) + +(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-conium") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/conium") + (commit commit))) + (file-name (git-file-name "conium" version)) + (sha256 + (base32 "0y31za8xr8734p2pf8mrw1jd1fksh2d4y1p12wwjyn8hxxsvsx1w")))) + (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)))) + +(define-public cl-conium + (sbcl-package->cl-source-package sbcl-conium)) + +(define-public ecl-conium + (sbcl-package->ecl-package sbcl-conium)) + +(define-public sbcl-constantfold + (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4") + (revision "1")) + (package + (name "sbcl-constantfold") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/numcl/constantfold") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06")))) + (build-system asdf-build-system/sbcl) + (synopsis "Support library for numcl") + (description + "Support library for numcl. Registers a function as an +additional form that is considered as a candidate for a constant.") + (home-page "https://github.com/numcl/constantfold") + (license license:lgpl3+) + (inputs + `(("trivia" ,sbcl-trivia) + ("alexandria" ,sbcl-alexandria) + ("iterate" ,sbcl-iterate) + ("lisp-namespace" ,sbcl-lisp-namespace))) + (native-inputs + (list sbcl-fiveam))))) + +(define-public cl-constantfold + (sbcl-package->cl-source-package sbcl-constantfold)) + +(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-contextl") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pcostanza/contextl/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0")))) + (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). + +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-contextl + (sbcl-package->cl-source-package sbcl-contextl)) + +(define-public ecl-contextl + (sbcl-package->ecl-package sbcl-contextl)) + +(define-public sbcl-core-gp + (let ((commit "90ec1c4599a19c5a911be1f703f78d5108aee160") + (revision "1")) + (package + (name "sbcl-core-gp") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/jorgetavares/core-gp") + (commit commit))) + (file-name (git-file-name "cl-core-gp" version)) + (sha256 + (base32 "0nzlb2gwqisa1amlpl4zc5xxph2g3qwhfyaxchci67d31rzws6l3")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/jorgetavares/core-gp") + (synopsis "Common Lisp library for genetic programming") + (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)))) + +(define-public cl-core-gp + (sbcl-package->cl-source-package sbcl-core-gp)) + +(define-public ecl-core-gp + (sbcl-package->ecl-package sbcl-core-gp)) + +(define-public sbcl-croatoan + (let ((commit "282145ff9e9005fddc4241bc6827b3ab09c5bd25") + (revision "1")) + (package + (name "sbcl-croatoan") + (version (git-version "2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/McParen/croatoan") + (commit commit))) + (file-name (git-file-name "cl-croatoan" version)) + (sha256 + (base32 "021h2f2yj4j9gynr3k7qi36x94jm5b95p3vaddbaih96wyzgbmq5")))) + (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")))))))) + (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-croatoan + (sbcl-package->cl-source-package sbcl-croatoan)) + +(define-public ecl-croatoan + (sbcl-package->ecl-package sbcl-croatoan)) + +(define-public sbcl-crypto-shortcuts + (let ((commit "7efd22d80e867cd8c9f8f363d4fe7b51ee2dadc0") + (revision "1")) + (package + (name "sbcl-crypto-shortcuts") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/crypto-shortcuts") + (commit commit))) + (file-name (git-file-name "crypto-shortcuts" version)) + (sha256 + (base32 "0c0m0ar04jn7qf2v8c4sivamlzki03r13rnxy8b3n27rh9r6hgin")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-base64 sbcl-flexi-streams sbcl-ironclad)) + (synopsis "Collection of common cryptography functions") + (description + "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-crypto-shortcuts + (sbcl-package->cl-source-package sbcl-crypto-shortcuts)) + +(define-public ecl-crypto-shortcuts + (sbcl-package->ecl-package sbcl-crypto-shortcuts)) + +(define-public sbcl-css-lite + (let ((commit "6ee4e6212ed56943d665df163d2a834b122e6273") + (revision "0")) + (package + (name "sbcl-css-lite") + (version "0.01") + (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)))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/paddymul/css-lite") + (synopsis "CSS grammar for Lisp") + (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)))) + +(define-public cl-css-lite + (sbcl-package->cl-source-package sbcl-css-lite)) + +(define-public ecl-css-lite + (sbcl-package->ecl-package sbcl-css-lite)) + +(define-public sbcl-ctype + (let ((commit "4fc4c5ae44c435ed82556969f698005bee50101c")) + (package + (name "sbcl-ctype") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/s-expressionists/ctype") + (commit commit))) + (file-name (git-file-name "cl-ctype" 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-curry-compose-reader-macros + (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2") + (revision "0")) + (package + (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/eschulte/curry-compose-reader-macros") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-named-readtables)) + (synopsis "Reader macros for partial application and composition") + (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-custom-hash-table + (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa")) + (package + (name "sbcl-custom-hash-table") + (version (git-version "0.3" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/metawilm/cl-custom-hash-table") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5")))) + (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.") + (license license:expat)))) + +(define-public cl-custom-hash-table + (sbcl-package->cl-source-package sbcl-custom-hash-table)) + +(define-public ecl-custom-hash-table + (sbcl-package->ecl-package sbcl-custom-hash-table)) + +(define-public sbcl-cxml + (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf") + (revision "1")) + (package + (name "sbcl-cxml") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/cxml") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37")))) + (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)))) + +(define-public cl-cxml + (sbcl-package->cl-source-package sbcl-cxml)) + +(define-public ecl-cxml + (sbcl-package->ecl-package sbcl-cxml)) + +(define-public sbcl-cxml-rng + (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b") + (revision "1")) + (package + (name "sbcl-cxml-rng") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "http://www.lichteblau.com/git/cxml-rng.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql")))) + (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)))) + +(define-public cl-cxml-rng + (sbcl-package->cl-source-package sbcl-cxml-rng)) + +;; FIXME: Fails on ECL with +;; In function STRUCTURE-SET, the value of the first argument is +;; # +;; which is not of the expected type %TYPED-PATTERN. +;; (define-public ecl-cxml-rng +;; (sbcl-package->ecl-package sbcl-cxml-rng)) + +(define-public sbcl-daemon + (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597") + (revision "1")) + (package + (name "sbcl-daemon") + (version (git-version "0.0.4" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/snmsts/daemon") + (commit commit))) + (file-name (git-file-name "daemon" version)) + (sha256 + (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-trivial-features)) + (home-page "https://github.com/snmsts/daemon") + (synopsis "Daemonize Common Lisp processes") + (description + "DAEMON provides the functionality of daemonizing Common Lisp processes +on UNIX like platforms.") + (license license:expat)))) + +(define-public cl-daemon + (sbcl-package->cl-source-package sbcl-daemon)) + +(define-public ecl-daemon + (sbcl-package->ecl-package sbcl-daemon)) + +(define-public sbcl-data-format-validation + (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb") + (revision "1")) + (package + (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/willijar/cl-data-format-validation/") + (commit commit))) + (file-name (git-file-name "data-format-validation" version)) + (sha256 + (base32 + "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-ppcre)) + (synopsis "Validation and conversion between user and internal data") + (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)))) + +(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 cl-data-frame + (sbcl-package->cl-source-package sbcl-data-frame)) + +;; 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-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-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-data-sift + (let ((commit "fd617d8200cdcc1b87ecf45ab59bb38e8b16ef7e") + (revision "1")) + (package + (name "sbcl-data-sift") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/archimag/data-sift") + (commit commit))) + (file-name (git-file-name "cl-data-sift" version)) + (sha256 + (base32 "1v7gf0x4ibjzp0c56n9m77hxdgwcm9356zlk5n4l3fx4i0hj6146")))) + (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") + (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)))) + +(define-public cl-data-sift + (sbcl-package->cl-source-package sbcl-data-sift)) + +(define-public ecl-data-sift + (sbcl-package->ecl-package sbcl-data-sift)) + +(define-public sbcl-datafly + (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d") + (revision "1")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv")))) + (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 #: + ;; 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-datafly + (sbcl-package->cl-source-package sbcl-datafly)) + +(define-public ecl-datafly + (sbcl-package->ecl-package sbcl-datafly)) + +(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)))) + +(define-public cl-db3 + (sbcl-package->cl-source-package sbcl-db3)) + +(define-public ecl-db3 + (sbcl-package->ecl-package sbcl-db3)) + +(define-public sbcl-dbi + (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227") + (revision "2")) + (package + (name "sbcl-dbi") + (version (git-version "0.9.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/cl-dbi") + (commit commit))) + (file-name (git-file-name "cl-dbi" version)) + (sha256 + (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg")))) + (build-system asdf-build-system/sbcl) + (native-inputs + `(("alexandria" ,sbcl-alexandria) + ("rove" ,sbcl-rove) + ("trivial-types" ,sbcl-trivial-types))) + (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") + (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)))) + +(define-public cl-dbi + (sbcl-package->cl-source-package sbcl-dbi)) + +(define-public ecl-dbi + (sbcl-package->ecl-package sbcl-dbi)) + +(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-dbus + (sbcl-package->cl-source-package sbcl-dbus)) + +(define-public ecl-dbus + (sbcl-package->ecl-package sbcl-dbus)) + +(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))) + +(define-public cl-decimals + (sbcl-package->cl-source-package sbcl-decimals)) + +(define-public ecl-decimals + (sbcl-package->ecl-package sbcl-decimals)) + +(define-public sbcl-deeds + ;; taged branch is outdated + (let ((revision "1") + (commit "f5df54eac79b58a34030e0eb8acf3952c788410d")) + (package + (name "sbcl-deeds") + (version (git-version "1.1.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/deeds") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k")))) + (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)))) + +(define-public cl-deeds + (sbcl-package->cl-source-package sbcl-deeds)) + +(define-public ecl-deeds + (sbcl-package->ecl-package sbcl-deeds)) + +(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-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 cl-definitions-systems + (sbcl-package->cl-source-package sbcl-definitions-systems)) + +(define-public ecl-definitions-systems + (sbcl-package->ecl-package sbcl-definitions-systems)) + +(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 cl-deflate + (sbcl-package->cl-source-package sbcl-deflate)) + +(define-public ecl-deflate + (sbcl-package->ecl-package sbcl-deflate)) + +(define-public sbcl-defpackage-plus + (let ((revision "0") + (commit "5492e27e0bdb7b75fa5177ea4388519dc7a75f11")) + (package + (name "sbcl-defpackage-plus") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rpav/defpackage-plus") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq")))) + (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") + (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-defpackage-plus + (sbcl-package->cl-source-package sbcl-defpackage-plus)) + +(define-public ecl-defpackage-plus + (sbcl-package->ecl-package sbcl-defpackage-plus)) + +(define-public sbcl-defstar + (let ((commit "132829dac9f84fa7202a0c5793aa6accb8d2662a")) + (package + (name "sbcl-defstar") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "http://bitbucket.org/eeeickythump/defstar/") + (commit commit))) + (file-name (git-file-name "cl-defstar" version)) + (sha256 + (base32 "0n6m3aqvdfnsrhlhqjcy72d1i55lbkjg13ij5c7vw003p1n78wxi")))) + (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)))) + +(define-public cl-defstar + (sbcl-package->cl-source-package sbcl-defstar)) + +(define-public ecl-defstar + (sbcl-package->ecl-package sbcl-defstar)) + +(define-public sbcl-deploy + (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8") + (revision "2")) + (package + (name "sbcl-deploy") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/deploy") + (commit commit))) + (file-name (git-file-name "deploy" version)) + (sha256 + (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1")))) + (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") + (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-deploy + (sbcl-package->cl-source-package sbcl-deploy)) + +(define-public ecl-deploy + (sbcl-package->ecl-package sbcl-deploy)) + +(define-public sbcl-depot + (let ((commit "73822d9f480cbad00971b45ee80117297a67fb53") + (revision "1")) + (package + (name "sbcl-depot") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/depot/") + (commit commit))) + (sha256 + (base32 "1v42pirdwbxy8l8i9a2jmbpri8a62vh0r4vm25xwaak0y4gr71va")) + (file-name (git-file-name "depot" version)))) + (build-system asdf-build-system/sbcl) + (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/") + (license license:zlib)))) + +(define-public cl-depot + (sbcl-package->cl-source-package sbcl-depot)) + +(define-public ecl-depot + (sbcl-package->ecl-package sbcl-depot)) + +(define-public sbcl-dexador + (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5") + (revision "2")) + (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") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (git-file-name "cl-dexador" 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.") + (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 ecl-dexador + (sbcl-package->ecl-package sbcl-dexador)) + +(define-public sbcl-dfio + (let ((commit "5caf473acb9bc464839e87395724cbd941167915") + (revision "0")) + (package + (name "sbcl-dfio") + (version (git-version "1.0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Lisp-Stat/dfio") + (commit commit))) + (file-name (git-file-name "cl-dfio" version)) + (sha256 + (base32 "1p53r7773939jnap518xp4b4wfvc1kbrz9jp6yd40xq0jpf9pbqg")))) + (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)))) + +(define-public cl-dfio + (sbcl-package->cl-source-package sbcl-dfio)) + +;; This depends on ecl-data-frame, which doesn't work yet. +;; (define-public ecl-dfio +;; (sbcl-package->ecl-package sbcl-dfio)) + +(define-public sbcl-diff + (let ((commit "9c84befa598d4e07c3d223242b5b3f83cd94f301") + (revision "1")) + (package + (name "sbcl-diff") + (version (git-version "0.4" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/froydnj/diff") + (commit commit))) + (file-name (git-file-name "cl-diff" version)) + (sha256 + (base32 "1giafck8qfvb688kx5bn9g32rfc12jjywg8vdav36aqbd6lxf5z5")))) + (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") + (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-diff + (sbcl-package->cl-source-package sbcl-diff)) + +(define-public ecl-diff + (sbcl-package->ecl-package sbcl-diff)) + +(define-public sbcl-dissect + (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45")) + (package + (name "sbcl-dissect") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/dissect") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5")))) + (build-system asdf-build-system/sbcl) + (inputs + (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-dissect + (sbcl-package->cl-source-package sbcl-dissect)) + +(define-public ecl-dissect + (sbcl-package->ecl-package sbcl-dissect)) + +(define-public sbcl-distributions + (let ((commit "ea72622073ee7e005dfdc621ce1e5a83b22bb39e") + (revision "0")) + (package + (name "sbcl-distributions") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Lisp-Stat/distributions") + (commit commit))) + (file-name (git-file-name "cl-distributions" version)) + (sha256 + (base32 "1fkzigd0s0s0mvszgmv04yc8jp9gm4812445hfh6kpz6cjy5zpsk")))) + (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)) + +(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)))) + +(define-public cl-djula + (sbcl-package->cl-source-package sbcl-djula)) + +(define-public ecl-djula + (sbcl-package->ecl-package sbcl-djula)) + +(define-public sbcl-dns-client + (let ((commit "9f252e9c2bb61c57a6cd367e21ad366b0d3e87e0") + (revision "0")) + (package + (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/dns-client") + (commit commit))) + (file-name (git-file-name "cl-dns-client" version)) + (sha256 + (base32 "1b6g2wvydwmv1k68favjyq4gfalfxfyl5i0hyh640wdaz2rfvi4n")))) + (build-system asdf-build-system/sbcl) + (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-dns-client + (sbcl-package->cl-source-package sbcl-dns-client)) + +(define-public ecl-dns-client + (sbcl-package->ecl-package sbcl-dns-client)) + +(define-public sbcl-do-urlencode + (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a") + (revision "1")) + (package + (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/documentation-utils") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "098qhkqskmmrh4wix34mawf7p5c87yql28r51r75yjxj577k5idq")))) + (build-system asdf-build-system/sbcl) + (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-documentation-utils + (sbcl-package->cl-source-package sbcl-documentation-utils)) + +(define-public ecl-documentation-utils + (sbcl-package->ecl-package sbcl-documentation-utils)) + +(define-public sbcl-documentation-utils-extensions + (let ((commit "f67f8a05d583174662a594b79356b201c1d9d750")) + (package + (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/sirherrbatka/documentation-utils-extensions/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f")))) + (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") + (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)))) + +(define-public cl-documentation-utils-extensions + (sbcl-package->cl-source-package sbcl-documentation-utils-extensions)) + +(define-public ecl-documentation-utils-extensions + (sbcl-package->ecl-package sbcl-documentation-utils-extensions)) + +(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 ecl-doplus + (sbcl-package->ecl-package sbcl-doplus)) + +(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 ecl-drakma + (sbcl-package->ecl-package sbcl-drakma)) + +(define-public sbcl-draw-cons-tree + (let ((commit "04334f5885a85cd7127db8dda3f6d6686a0438b1") + (revision "0")) + (package + (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/phoe/draw-cons-tree") + (commit commit))) + (file-name (git-file-name "cl-draw-cons-tree" version)) + (sha256 + (base32 "1523bdkq8a5qn0qp9q7r16w47y6jb0hkfj7hbjfj6mg3xv001s3x")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam sbcl-split-sequence)) + (inputs + (list sbcl-alexandria)) + (synopsis "Draw an ascii picture of a cons tree") + (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)))) + +(define-public cl-draw-cons-tree + (sbcl-package->cl-source-package sbcl-draw-cons-tree)) + +(define-public ecl-draw-cons-tree + (sbcl-package->ecl-package sbcl-draw-cons-tree)) + +(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))) + +(define-public cl-dufy + (sbcl-package->cl-source-package sbcl-dufy)) + +(define-public ecl-dufy + (sbcl-package->ecl-package sbcl-dufy)) + +(define-public sbcl-duologue + (let ((commit "ea1ada244a81da65f85b548823c9a6d7c9c145e1") + (revision "0")) + (package + (name "sbcl-duologue") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mmontone/duologue") + (commit commit))) + (file-name (git-file-name "cl-duologue" version)) + (sha256 + (base32 "1yg7f27im9h0m6jihcay1p7alfhzm9hafwm5dw5hsyacy8f2cwk2")))) + (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-stefil)) + (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") + (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-dynamic-classes + (let ((commit "ebd7405603f67b16e8f2bc08ce8e2bcfcf439501") + (revision "0")) + (package + (name "sbcl-dynamic-classes") + (version (git-version "1.0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/dynamic-classes") + (commit commit))) + (file-name (git-file-name "dynamic-classes" version)) + (sha256 + (base32 "1k9lkchwyi2xhygp2v8ifq3kg1l3wcnihhzgr06jrivjxgdqpc1a")))) + (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)))) + +(define-public cl-dynamic-classes + (sbcl-package->cl-source-package sbcl-dynamic-classes)) + +(define-public ecl-dynamic-classes + (sbcl-package->ecl-package sbcl-dynamic-classes)) + +(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-dynamic-mixins + (sbcl-package->cl-source-package sbcl-dynamic-mixins)) + +(define-public ecl-dynamic-mixins + (sbcl-package->ecl-package sbcl-dynamic-mixins)) + +(define-public sbcl-eager-future2 + (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30")) + (package + (name "sbcl-eager-future2") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-bordeaux-threads sbcl-trivial-garbage)) + (synopsis "Futures promises synchronization mechanism for 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+)))) + +(define-public cl-eager-future2 + (sbcl-package->cl-source-package sbcl-eager-future2)) + +(define-public ecl-eager-future2 + (sbcl-package->ecl-package sbcl-eager-future2)) + +(define-public sbcl-easy-routes + (let ((commit "7832f8bf3d07825b5eb967a2ef04da7c40c18248") + (revision "0")) + (package + (name "sbcl-easy-routes") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mmontone/easy-routes") + (commit commit))) + (file-name (git-file-name "cl-easy-routes" version)) + (sha256 + (base32 "1banw54kz2llzb9h5sm47ckfc9l348m7qncm0npsy0w837rxkyzx")))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("easy-routes" + "easy-routes+djula" + "easy-routes+errors"))) + (native-inputs + (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 + "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 + +This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS +systems.") + (license license:expat)))) + +(define-public cl-easy-routes + (sbcl-package->cl-source-package sbcl-easy-routes)) + +(define-public ecl-easy-routes + (sbcl-package->ecl-package sbcl-easy-routes)) + +(define-public sbcl-eazy-gnuplot + (let ((commit "2eb900fe2557e6c066a9851c166e572c25bc0996") + (revision "0")) + (package + (name "sbcl-eazy-gnuplot") + (version (git-version "0.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/guicho271828/eazy-gnuplot") + (commit commit))) + (file-name (git-file-name "cl-eazy-gnuplot" version)) + (sha256 + (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 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 + "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 cl-eazy-gnuplot + (sbcl-package->cl-source-package sbcl-eazy-gnuplot)) + +(define-public ecl-eazy-gnuplot + (sbcl-package->ecl-package sbcl-eazy-gnuplot)) + +(define-public sbcl-eclector + (let ((commit "d499b09142c7e39b4ef52e821fa767d5a8d606a0") + (revision "0")) + (package + (name "sbcl-eclector") + (version (git-version "0.9.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)) + (sha256 + (base32 "1sg8wmdpm8pcjwk394way5vs2ya3r995lddmi51q9zfn9hmzb7gn")))) + (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") + (description + "Eclector is a portable Common Lisp reader that is highly customizable, +can recover from errors and can return concrete syntax trees. + +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. + +It can also produce instances of the concrete syntax tree classes provided by +the concrete syntax tree library.") + (license license:bsd-2)))) + +(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")) @@ -14476,39 +13962,6599 @@ multiple checkers, including Aspell and Hunspell.") (define-public ecl-enchant (sbcl-package->ecl-package sbcl-enchant)) -(define-public sbcl-cl-change-case - (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022") +(define-public sbcl-enhanced-boolean + (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)) + +(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 cl-enhanced-defclass + (sbcl-package->cl-source-package sbcl-enhanced-defclass)) + +(define-public ecl-enhanced-defclass + (sbcl-package->ecl-package sbcl-enhanced-defclass)) + +(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/fukamachi/envy") + (commit commit))) + (file-name (git-file-name "cl-envy" version)) + (sha256 + (base32 "1r0wgimd7z57x8cv69sw76w3y5l70hq50882a9nq5l4v64lg55fq")))) + (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 # + ;; 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)) + +(define-public ecl-envy + (sbcl-package->ecl-package sbcl-envy)) + +(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-esrap") + (version (git-version "0.18" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/scymtym/esrap") + (commit commit))) + (file-name (git-file-name "cl-esrap" version)) + (sha256 + (base32 "0gs0mfamldhaihnlk0qxg2q4bl8bamq68dif9js9fkl8apg3iykl")))) + (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/") + (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-evaled-when + (let ((commit "c59f8ab20b846cac81d4be80d056a3d65676e8eb") + (revision "0")) + (package + (name "sbcl-evaled-when") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Hexstream/evaled-when") + (commit commit))) + (file-name (git-file-name "cl-evaled-when" version)) + (sha256 + (base32 "07g1a50aairvsj57issb18si5a9r3skpbk05nlixmlj0mva3gkl3")))) + (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)))) + +(define-public cl-evaled-when + (sbcl-package->cl-source-package sbcl-evaled-when)) + +(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-cl-change-case") + (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")) + (package + (name "sbcl-exponential-backoff") + (version (git-version "0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/death/exponential-backoff") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/death/exponential-backoff") + (synopsis "Exponential backoff algorithm in Common Lisp") + (description + "An implementation of the exponential backoff algorithm in Common Lisp. +Inspired by the implementation found in Chromium. Read the header file to +learn about each of the parameters.") + (license license:expat)))) + +(define-public cl-exponential-backoff + (sbcl-package->cl-source-package sbcl-exponential-backoff)) + +(define-public ecl-exponential-backoff + (sbcl-package->ecl-package sbcl-exponential-backoff)) + +(define-public sbcl-external-program + (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749") + (revision "1")) + (package + (name "sbcl-external-program") + (version (git-version "0.0.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sellout/external-program") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-trivial-features)) + (native-inputs + (list sbcl-fiveam)) + (synopsis "Common Lisp library for running external programs") + (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)))) + +(define-public cl-external-program + (sbcl-package->cl-source-package sbcl-external-program)) + +(define-public ecl-external-program + (sbcl-package->ecl-package sbcl-external-program)) + +(define-public sbcl-fakenil + (package + (name "sbcl-fakenil") + (version "1.0") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Hexstream/fakenil") + (commit (string-append "v" version)))) + (file-name (git-file-name "cl-fakenil" version)) + (sha256 + (base32 "0ipqax3sgcs1dsgxz8d2pmfg324k6l35pn0nz89w5jl02fia61l3")))) + (build-system asdf-build-system/sbcl) + (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-fakenil + (sbcl-package->cl-source-package sbcl-fakenil)) + +(define-public ecl-fakenil + (sbcl-package->ecl-package sbcl-fakenil)) + +(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 cl-fare-csv + (sbcl-package->cl-source-package sbcl-fare-csv)) + +(define-public ecl-fare-csv + (sbcl-package->ecl-package sbcl-fare-csv)) + +(define-public sbcl-fare-mop + (let ((commit "538aa94590a0354f382eddd9238934763434af30") + (revision "1")) + (package + (name "sbcl-fare-mop") + (version (git-version "1.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fare/fare-mop") + (commit commit))) + (file-name (git-file-name "fare-mop" version)) + (sha256 + (base32 + "0maxs8392953fhnaa6zwnm2mdbhxjxipp4g4rvypm06ixr6pyv1c")))) + (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") + (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 ecl-fare-mop + (sbcl-package->ecl-package sbcl-fare-mop)) + +(define-public cl-fare-mop + (sbcl-package->cl-source-package sbcl-fare-mop)) + +(define-public sbcl-fare-quasiquote + (let ((commit "640d39a0451094071b3e093c97667b3947f43639") + (revision "1")) + (package + (name "sbcl-fare-quasiquote") + (build-system asdf-build-system/sbcl) + (version (git-version "1.0.1" revision commit)) + (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote") + (source + (origin + (method git-fetch) + (uri (git-reference + (url (string-append "https://gitlab.common-lisp.net/frideau/" + "fare-quasiquote.git")) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg")))) + (inputs + `(("fare-utils" ,sbcl-fare-utils) + ("named-readtables" ,sbcl-named-readtables) + ("optima" ,sbcl-optima))) + (arguments + ;; 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 + ;; 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-fare-quasiquote + (sbcl-package->cl-source-package sbcl-fare-quasiquote)) + +(define-public ecl-fare-quasiquote + (sbcl-package->ecl-package sbcl-fare-quasiquote)) + +(define-public sbcl-fare-utils + (let ((commit "66e9c6f1499140bc00ccc22febf2aa528cbb5724") + (revision "1")) + (package + (name "sbcl-fare-utils") + (version (git-version "1.0.0.5" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url + "https://gitlab.common-lisp.net/frideau/fare-utils.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-hu.dwim.stefil)) + (synopsis "Collection of utilities and data structures") + (description + "fare-utils is a small collection of utilities. It contains a lot of +basic everyday functions and macros.") + (home-page "https://gitlab.common-lisp.net/frideau/fare-utils") + ;; MIT License + (license license:expat)))) + +(define-public cl-fare-utils + (sbcl-package->cl-source-package sbcl-fare-utils)) + +(define-public ecl-fare-utils + (sbcl-package->ecl-package sbcl-fare-utils)) + +(define-public sbcl-fast-generic-functions + (let ((commit "9c307cd28af6453e45038ac3510de3123ff23743")) + (package + (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/marcoheisig/fast-generic-functions/") + (commit commit))) + (file-name (git-file-name "cl-fast-generic-functions" version)) + (sha256 + (base32 "16hf9bi2p5s77p3m3aqsihcd9iicqjhhxxpsarjv93c41qs54yad")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 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-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-fast-http + (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a") + (revision "2")) + (package + (name "sbcl-fast-http") (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/fukamachi/fast-http") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi")))) + (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") + (description + "@code{fast-http} is a HTTP request/response protocol parser for Common +Lisp.") + ;; Author specified the MIT license + (license license:expat)))) + +(define-public cl-fast-http + (sbcl-package->cl-source-package sbcl-fast-http)) + +(define-public ecl-fast-http + (sbcl-package->ecl-package sbcl-fast-http)) + +(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)))) + +(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 #. + '(#: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/Shinmera/feeder") + (commit commit))) + (file-name (git-file-name "feeder" version)) + (sha256 + (base32 "1dpbzhycg50snl3j01c8dh8gdvhfhz0hnfl54xy55a3wbr3m6rp7")))) + (build-system asdf-build-system/sbcl) + (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") + (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 cl-feeder + (sbcl-package->cl-source-package sbcl-feeder)) + +(define-public ecl-feeder + (sbcl-package->ecl-package sbcl-feeder)) + +(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)))) + +(define-public cl-ffa + (sbcl-package->cl-source-package sbcl-ffa)) + +(define-public ecl-ffa + (sbcl-package->ecl-package sbcl-ffa)) + +(define-public sbcl-file-attributes + (let ((commit "bbde396438f37d676de9775239115410bec4da2d")) + (package + (name "sbcl-file-attributes") + (version (git-version "1.0.0" "2" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/file-attributes/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0n8q818ry2shggjfhp8gjby8v5mla9pg97c5g19pcglpnwim7a74")))) + (build-system asdf-build-system/sbcl) + (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") + (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)))) + +(define-public ecl-file-attributes + (sbcl-package->ecl-package sbcl-file-attributes)) + +(define-public cl-file-attributes + (sbcl-package->cl-source-package sbcl-file-attributes)) + +(define-public sbcl-file-notify + (let ((commit "f12dc2f2aae5fee13355cd93a8cae0c4c412b76d") + (revision "0")) + (package + (name "sbcl-file-notify") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/file-notify") + (commit commit))) + (file-name (git-file-name "cl-file-notify" version)) + (sha256 + (base32 "0788d98rqm1krl8nbfh8qshvyf6g336i9bqrdhkx06cfvbh0wcny")))) + (build-system asdf-build-system/sbcl) + (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-file-notify + (sbcl-package->cl-source-package sbcl-file-notify)) + +(define-public ecl-file-notify + (sbcl-package->ecl-package sbcl-file-notify)) + +(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 cl-file-select + (sbcl-package->cl-source-package sbcl-file-select)) + +(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-filesystem-utils") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/filesystem-utils/") + (commit commit))) + (file-name (git-file-name "cl-filesystem-utils" version)) + (sha256 + (base32 "1zv2i2gndnbs7hz3bgkkq1qfx604wbndpc7qqlqvg23fssn9w59f")))) + (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)))) + +(define-public cl-filesystem-utils + (sbcl-package->cl-source-package sbcl-filesystem-utils)) + +(define-public ecl-filesystem-utils + (sbcl-package->ecl-package sbcl-filesystem-utils)) + +(define-public sbcl-filtered-functions + (let ((commit "130f69e7b9e1051bf569ef63364b09a3873f0ced")) + (package + (name "sbcl-filtered-functions") + (version (git-version "0.2.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pcostanza/filtered-functions") + (commit commit))) + (file-name (git-file-name "cl-filtered-functions" version)) + (sha256 + (base32 "0m13k8pl0gfll8ss83c0z3gax7zrrw2i4s26451jfbka1xr4fgy9")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-closer-mop)) + (home-page "https://github.com/pcostanza/filtered-functions") + (synopsis "Extension of CLOS generic function invocation") + (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)))) + +(define-public cl-filtered-functions + (sbcl-package->cl-source-package sbcl-filtered-functions)) + +(define-public ecl-filtered-functions + (sbcl-package->ecl-package sbcl-filtered-functions)) + +(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 "cl-change-case" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if")))) + (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-find-port + (sbcl-package->cl-source-package sbcl-find-port)) + +(define-public ecl-find-port + (sbcl-package->ecl-package sbcl-find-port)) + +(define-public sbcl-flamegraph + (let ((commit "1ed7a718eae88bd35e1649a1c716d46c59dc0a24") + (revision "0")) + (package + (name "sbcl-flamegraph") + (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") + (commit commit))) + (file-name (git-file-name "cl-flamegraph" version)) + (sha256 + (base32 "1aj7hhvav9j9c66ssy11ry3p6xqb912yafi91g6sin6pdx84c2lw")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode)) + (list sbcl-alexandria)) + (home-page "https://github.com/40ants/cl-flamegraph") + (synopsis "Generate flamegraphs of Common Lisp code") + (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}.") + (license license:bsd-3)))) + +(define-public cl-flamegraph + (sbcl-package->cl-source-package sbcl-flamegraph)) + +(define-public sbcl-flare + (let ((commit "4f9f17a4fc5b368c2a1988b9a20288695b8d8c48") + (revision "1")) + (package + (name "sbcl-flare") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/flare") + (commit commit))) + (file-name (git-file-name "flare" version)) + (sha256 + (base32 "00nm3sjngbflj2gd5q0xs2m136w4kix6krww23nk64pkkyq2fs86")))) + (build-system asdf-build-system/sbcl) + (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") + (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)))) + +(define-public cl-flare + (sbcl-package->cl-source-package sbcl-flare)) + +(define-public ecl-flare + (sbcl-package->ecl-package sbcl-flare)) + +(define-public sbcl-flexi-streams + (let ((commit "74a1027311371a57258eba1bc908e050f5702277") + (revision "0")) + (package + (name "sbcl-flexi-streams") + (version (git-version "1.0.19" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/flexi-streams") + (commit commit))) + (file-name (git-file-name "cl-flexi-streams" version)) + (sha256 + (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-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-flexi-streams + (sbcl-package->cl-source-package sbcl-flexi-streams)) + +(define-public ecl-flexi-streams + (sbcl-package->ecl-package sbcl-flexi-streams)) + +(define-public sbcl-flexichain + ;; There are no releases. + (let ((commit "9af644a6323f303a936a391b956babcbfe7b0c67") + (revision "2")) + (package + (name "sbcl-flexichain") + (version (git-version "1.5.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/robert-strandh/Flexichain") + (commit commit))) + (file-name (git-file-name "cl-flexichain" version)) + (sha256 + (base32 "1ivkffnkc1iqmpl1p1rgyfbbgjmjcid4iszvdql1jjz324lq94g6")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-trivial-garbage)) + (home-page "https://github.com/robert-strandh/Flexichain.git") + (synopsis "Dynamically add elements to or remove them from sequences") + (description + "This package provides an implementation of the flexichain protocol, +allowing client code to dynamically add elements to, and delete elements from +a sequence (or chain) of such elements.") + (license license:lgpl2.1+)))) + +(define-public ecl-flexichain + (sbcl-package->ecl-package sbcl-flexichain)) + +(define-public cl-flexichain + (sbcl-package->cl-source-package sbcl-flexichain)) + +(define-public sbcl-float-features + (let ((commit "c1f86aea91cfaa3aa59799162be23ef8a12b199d") + (revision "2")) + (package + (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/float-features") + (commit commit))) + (file-name (git-file-name "float-features" version)) + (sha256 + (base32 "0vqm9xhn2i4vbjrxnp4hr1l3lydjflhjykdz6cmqg2j48c5kh3g3")))) + (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-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. + +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)))) + +(define-public cl-flow + (sbcl-package->cl-source-package sbcl-flow)) + +(define-public ecl-flow + (sbcl-package->ecl-package sbcl-flow)) + +(define-public sbcl-flute + (let ((commit "90ebcd6e82f637f49b6de7d625ccc51ec4c92900") + (revision "1")) + (package + (name "sbcl-flute") + (version (git-version "0.2-dev" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ailisp/flute") + (commit commit))) + (file-name (git-file-name "cl-flute" version)) + (sha256 + (base32 "0q8jhp040cvpppyn820mm6a550yfxyr1lar298x13c42mm807f4f")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 + "Flute is an easily composable HTML5 generation library in Common +Lisp.") + (license license:expat)))) + +(define-public cl-flute + (sbcl-package->cl-source-package sbcl-flute)) + +(define-public ecl-flute + (sbcl-package->ecl-package sbcl-flute)) + +(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-fn + (sbcl-package->cl-source-package sbcl-fn)) + +(define-public ecl-fn + (sbcl-package->ecl-package sbcl-fn)) + +(define-public sbcl-fof + (let ((commit "522879e7da110ecf2e841998b197b34062c54b29") + (revision "1")) + (package + (name "sbcl-fof") + (version (git-version "0.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.com/ambrevar/fof") + (commit commit))) + (file-name (git-file-name "cl-fof" version)) + (sha256 + (base32 "0ipy51q2fw03xk9rqcyzbq2b9c32npc1gl3c53rdjywpak7zwwg6")))) + (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") + (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+)))) + +(define-public cl-fof + (sbcl-package->cl-source-package sbcl-fof)) + +(define-public ecl-fof + (sbcl-package->ecl-package sbcl-fof)) + +(define-public sbcl-font-discovery + (let ((commit "5101ca79151055f3ec9839aae73b8af42b884528") + (revision "1")) + (package + (name "sbcl-font-discovery") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/font-discovery") + (commit commit))) + (file-name (git-file-name "font-discovery" version)) + (sha256 + (base32 "1p9wkwc23rnif8vcjaj5ih1fmr5g57sidqjlz08qw6k0z4f6bia1")))) + (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)))) + +(define-public cl-font-discovery + (sbcl-package->cl-source-package sbcl-font-discovery)) + +(define-public ecl-font-discovery + (sbcl-package->ecl-package sbcl-font-discovery)) + +(define-public sbcl-for + (let ((commit "a39782991292e44ee3b5e2e25cddaa8115f6d363") + (revision "1")) + (package + (name "sbcl-for") + (version (git-version "1.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/for") + (commit commit))) + (file-name (git-file-name "cl-for" version)) + (sha256 + (base32 "07jdwqkyb3qd65mng60cs723z7p0bv2769hhalz4c0mfzn8qrn99")))) + (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") + (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)))) + +(define-public cl-for + (sbcl-package->cl-source-package sbcl-for)) + +(define-public ecl-for + (sbcl-package->ecl-package sbcl-for)) + +(define-public sbcl-forge + (let ((commit "012324e251d91436f4a610e2fe2eb50674c3c3ce") + (revision "1")) + (package + (name "sbcl-forge") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/forge/") + (commit commit))) + (sha256 + (base32 "006vi2ihrn28pzrwa8b7axmv98bdaxzx7lacnh9pbacbjg3b7hb0")) + (file-name (git-file-name "forge" version)))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("forge-support" + "forge-communication" + "forge"))) + (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)))) + +(define-public cl-forge + (sbcl-package->cl-source-package sbcl-forge)) + +(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 ecl-form-fiddle + (sbcl-package->ecl-package sbcl-form-fiddle)) + +(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-format-colors + (sbcl-package->cl-source-package sbcl-format-colors)) + +(define-public ecl-format-colors + (sbcl-package->ecl-package sbcl-format-colors)) + +(define-public sbcl-formgrep + (let ((commit "91238cdbdd0ad815ff5d574d032b4a502febd190") + (revision "0")) + (package + (name "sbcl-formgrep") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/death/formgrep") + (commit commit))) + (file-name (git-file-name "cl-formgrep" version)) + (sha256 + (base32 "1rqzkmz6nddg5ywvs3v0k8cvxdwas38mfwgbr3rs4fdsbps90k9r")))) + (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") + (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-formgrep + (sbcl-package->cl-source-package sbcl-formgrep)) + +(define-public ecl-formgrep + (sbcl-package->ecl-package sbcl-formgrep)) + +(define-public sbcl-fset + (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852") + (revision "1")) + (package + (name "sbcl-fset") + (version (git-version "1.3.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/slburson/fset") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy")) + (snippet '(begin + ;; Remove obsolete copy of system definition. + (delete-file "Code/fset.asd") + #t)))) + (build-system asdf-build-system/sbcl) + (inputs + (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)))) + +(define-public cl-fset + (sbcl-package->cl-source-package sbcl-fset)) + +(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 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 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-funds") + (version (git-version "1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/charJe/funds") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "13y1jhvnpzrs9daz6f3z67w6h2y21ggb10j3j4vnc5p3m8i7ps4p")))) + (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)))) + +(define-public cl-funds + (sbcl-package->cl-source-package sbcl-funds)) + +(define-public ecl-funds + (sbcl-package->ecl-package sbcl-funds)) + +(define-public sbcl-fxml + ;; No release. + (let ((commit "a0e73bb48ef03adea94a55986cc27f522074c8e1")) + (package + (name "sbcl-fxml") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/fxml/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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 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 You are parsing potentially ill-formed XML. +@item You are parsing potentially malicious XML. +@item You need to use Klacks with namespaces. +@end itemize + +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-fxml + (sbcl-package->cl-source-package sbcl-fxml)) + +(define-public sbcl-garbage-pools + (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790") + (revision "1")) + (package + (name "sbcl-garbage-pools") + (version (git-version "0.1.2" 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 cl-garbage-pools + (sbcl-package->cl-source-package sbcl-garbage-pools)) + +(define-public ecl-garbage-pools + (sbcl-package->ecl-package sbcl-garbage-pools)) + +(define-public sbcl-geco + (let ((commit "db13c9384491092975f46f6a837ccdc04681a93a") + (revision "1")) + (package + (name "sbcl-geco") + (version (git-version "2.1.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/gpwwjr/GECO") + (commit commit))) + (file-name (git-file-name "cl-geco" version)) + (sha256 + (base32 "1ncaf9ab7jz59zmga0p97blsjjb1m6db0qih57wipfhqdb5ylz17")))) + (build-system asdf-build-system/sbcl) + (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 cl-geco + (sbcl-package->cl-source-package sbcl-geco)) + +(define-public ecl-geco + (sbcl-package->ecl-package sbcl-geco)) + +(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-generic-comparability + (let ((commit "53fc2846319a6eb46b36581e203e1f1542a8acff") + (revision "1")) + (package + (name "sbcl-generic-comparability") + (version (git-version "1.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pnathan/generic-comparability") + (commit commit))) + (file-name (git-file-name "generic-comparability" version)) + (sha256 + (base32 "01ma0cwirxarwwmdwflnh8kmysmr2smh5kyvzhb2074ljxg8yq2p")))) + (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)))) + +(define-public cl-generic-comparability + (sbcl-package->cl-source-package sbcl-generic-comparability)) + +(define-public ecl-generic-comparability + (sbcl-package->ecl-package sbcl-generic-comparability)) + +(define-public sbcl-genhash + (let ((commit "220ae1af8361dbd2005177f2ee11072b6a33934f") + (revision "1")) + (package + (name "sbcl-genhash") + (version (git-version "1.7" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pnathan/genhash") + (commit commit))) + (file-name (git-file-name "cl-genhash" version)) + (sha256 + (base32 "1jnk1fix1zydhy0kn3cvlp6dy0241x7v8ahq001nlr6v152z1cwk")))) + (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)))) + +(define-public cl-genhash + (sbcl-package->cl-source-package sbcl-genhash)) + +(define-public ecl-genhash + (sbcl-package->ecl-package sbcl-genhash)) + +(define-public sbcl-germinal + (let ((commit "5bfb371ea57dae8985c0e1c6f184f0338487d684") + (revision "0")) + (package + (name "sbcl-germinal") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.carcosa.net/jmcbray/germinal") + (commit commit))) + (file-name (git-file-name "cl-germinal" version)) + (sha256 + (base32 "12jypa8m10825lp5yxfcm1fyk3r4ziwcri7ndxa0m5dz0y7hggck")))) + (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)))) + +(define-public cl-germinal + (sbcl-package->cl-source-package sbcl-germinal)) + +(define-public ecl-germinal + (sbcl-package->ecl-package sbcl-germinal)) + +(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+)))) + +(define-public cl-gettext + (sbcl-package->cl-source-package sbcl-gettext)) + +(define-public ecl-gettext + (sbcl-package->ecl-package sbcl-gettext)) + +(define-public sbcl-glkit + (let ((commit "0d8e7c5fed4231f2177afcf0f3ff66f196ed6a46")) + (package + (name "sbcl-glkit") + (version (git-version "0.0" "1" 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)) + (sha256 + (base32 "1x3y5jcr1f0v9sgn3y5b7b8fhgd6vv37nz73016gdwh511idi8jn")))) + (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)))) + +(define-public cl-glkit + (sbcl-package->cl-source-package sbcl-glkit)) + +(define-public ecl-glkit + (sbcl-package->ecl-package sbcl-glkit)) + +(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) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d")))) + (build-system asdf-build-system/sbcl) + (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. + +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-global-vars + (sbcl-package->cl-source-package sbcl-global-vars)) + +(define-public ecl-global-vars + (sbcl-package->ecl-package sbcl-global-vars)) + +(define-public sbcl-glop + (let ((commit "45e722ab4a0cd2944d550bf790206b3326041e38") + (revision "1")) + (package + (name "sbcl-glop") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lispgames/glop") + (commit commit))) + (file-name (git-file-name "glop" version)) + (sha256 + (base32 "1nm35kvigflfjlmsa8zwdajc61f02fh4sq08jv0wnqylhx8yg2bv")))) + (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") + (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-glop + (sbcl-package->cl-source-package sbcl-glop)) + +(define-public ecl-glop + (sbcl-package->ecl-package sbcl-glop)) + +(define-public sbcl-glsl-packing + (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a") + (revision "1")) + (package + (name "sbcl-glsl-packing") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/3b/glsl-packing/") + (commit commit))) + (file-name (git-file-name "glsl-packing" version)) + (sha256 + (base32 "0k2f1771wd9kdrcasldy1r00k5bdgi9fd07in52zmjggc0i7dd80")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria)) + (home-page "https://github.com/3b/glsl-packing/") + (synopsis "Common Lisp utilities to calculate OpenGL layouts") + (description + "This is a Common Lisp library to calculate std140 or std430 layouts for +a glsl UBO/SSBO.") + (license license:expat)))) + +(define-public cl-glsl-packing + (sbcl-package->cl-source-package sbcl-glsl-packing)) + +(define-public ecl-glsl-packing + (sbcl-package->ecl-package sbcl-glsl-packing)) + +(define-public sbcl-glsl-spec + (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d") + (revision "1")) + (package + (name "sbcl-glsl-spec") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/cbaggers/glsl-spec") + (commit commit))) + (file-name (git-file-name "glsl-spec" version)) + (sha256 + (base32 "01ipspr22fgfj3w8wq2y81lzrjc4vpfiwnr3dqhjlpzzra46am8c")))) + (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") + (description + "This package contains the specification of all functions and variables +from GLSL as data.") + (license license:unlicense)))) + +(define-public cl-glsl-spec + (sbcl-package->cl-source-package sbcl-glsl-spec)) + +(define-public ecl-glsl-spec + (sbcl-package->ecl-package sbcl-glsl-spec)) + +(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-glsl-toolkit + (sbcl-package->cl-source-package sbcl-glsl-toolkit)) + +(define-public ecl-glsl-toolkit + (sbcl-package->ecl-package sbcl-glsl-toolkit)) + +(define-public sbcl-glyphs + (let ((commit "1ff5714e8c1dca327bc604dfe3e3d1f4b7755373")) + (package + (name "sbcl-glyphs") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ahungry/glyphs/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "17kai1anbkk5dj5sbrsin2fc019cmcbglb900db60v38myj0y0wf")))) + (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") + (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-golden-utils + (let ((commit "e43914ad2bdb0c8e1b1f10ef591aafc3c55b89e7") + (revision "4")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name "cl-golden-utils" version)) + (sha256 + (base32 "09vq29wjr3x7h3fshwxg8h1psy4p73yl61cjljarpqjhsgz7lmbp")))) + (build-system asdf-build-system/sbcl) + (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-golden-utils + (sbcl-package->cl-source-package sbcl-golden-utils)) + +(define-public ecl-golden-utils + (sbcl-package->ecl-package sbcl-golden-utils)) + +(define-public sbcl-graph + (let ((commit "78bf9ec930d8eae4f0861b5be76765fb1e45e24f") + (revision "0")) + (package + (name "sbcl-graph") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/eschulte/graph") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1qpij4xh8bqwc2myahpilcbh916v7vg0acz2fij14d3y0jm02h0g")))) + (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") + (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-graph + (sbcl-package->cl-source-package sbcl-graph)) + +(define-public ecl-graph + (sbcl-package->ecl-package sbcl-graph)) + +(define-public sbcl-green-threads + (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840") + (revision "1")) + (package + (name "sbcl-green-threads") + (version (git-version "0.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/thezerobit/green-threads") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("cl-async-future" ,sbcl-cl-async-future) + ("cl-cont" ,sbcl-cl-cont))) + (native-inputs + (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-green-threads + (sbcl-package->cl-source-package sbcl-green-threads)) + +(define-public ecl-green-threads + (sbcl-package->ecl-package sbcl-green-threads)) + +(define-public sbcl-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-gsll + (sbcl-package->cl-source-package sbcl-gsll)) + +(define-public ecl-gsll + (sbcl-package->ecl-package sbcl-gsll)) + +(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-gtype + (let ((commit "2442e32485635525af278ebd8fa69a27d5b8cf18") + (revision "2")) + (package + (name "sbcl-gtype") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/numcl/gtype") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0hbkfdw00v7bsa6zbric34p5w6hfwxycccg8wc2faq0cxhsvpv9h")))) + (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))))) + +(define-public cl-gtype + (sbcl-package->cl-source-package sbcl-gtype)) + +(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-harmony + (let ((commit "0b57483cc0341936c201b620f82a8542c606991f") + (revision "0")) + (package + (name "sbcl-harmony") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/harmony") + (commit commit))) + (file-name (git-file-name "cl-harmony" version)) + (sha256 + (base32 "0pqmfi3yi3gi7b7dyayrb621hp60rn7hasq0cl0fis3vg0fp5dja")))) + (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") + (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)))) + +(define-public cl-harmony + (sbcl-package->cl-source-package sbcl-harmony)) + +(define-public ecl-harmony + (sbcl-package->ecl-package sbcl-harmony)) + +(define-public sbcl-hash-set + (let ((commit "6feb20de457f14e24a83815be1097aa02cca5986") + (revision "0")) + (package + (name "sbcl-hash-set") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/samebchase/hash-set") + (commit commit))) + (file-name (git-file-name "cl-hash-set" version)) + (sha256 + (base32 "0a966y9yfarhmki4wwzg371ziaygnp13yc6r13w9zz327fkhz8na")))) + (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)))) + +(define-public cl-hash-set + (sbcl-package->cl-source-package sbcl-hash-set)) + +(define-public ecl-hash-set + (sbcl-package->ecl-package sbcl-hash-set)) + +(define-public sbcl-hdf5-cffi + (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c") + (revision "1")) + (package + (name "sbcl-hdf5-cffi") + (version (git-version "1.8.18" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hdfgroup/hdf5-cffi") + (commit commit))) + (file-name (git-file-name "cl-hdf5-cffi" version)) + (sha256 + (base32 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf")))) + (build-system asdf-build-system/sbcl) + (synopsis "Common Lisp bindings for the HDF5 library") + (description + "@code{hdf5-cffi} is a CFFI wrapper for the HDF5 library.") + (home-page "https://github.com/hdfgroup/hdf5-cffi") + (license (license:non-copyleft + (string-append "https://github.com/HDFGroup/hdf5-cffi/raw/" + commit + "/LICENSE"))) + (inputs + (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-hdf5-cffi + (sbcl-package->cl-source-package sbcl-hdf5-cffi)) + +(define-public ecl-hdf5-cffi + (sbcl-package->ecl-package sbcl-hdf5-cffi)) + +(define-public sbcl-helambdap + (let ((commit "5bf65f57a36ee094cadb096caca6e90eb3ba46c4") + (revision "0")) + (package + (name "sbcl-helambdap") + (version (git-version "20220103" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.code.sf.net/p/helambdap/code") + (commit commit))) + (file-name (git-file-name "cl-helambdap" version)) + (sha256 + (base32 "1kzapbf9l2bw8i9m9sxv0dfnkksrxq81d5hbn34pm25abk0i937j")))) + (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") + (license license:expat)))) + +(define-public cl-helambdap + (sbcl-package->cl-source-package sbcl-helambdap)) + +(define-public sbcl-history-tree + (package + (name "sbcl-history-tree") + (version "0.1.2") + (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)) + (sha256 + (base32 "1n3q6aqh0wm24pksj8371j5iinxpzy2kcnz97kmpndm1yhv4x5f2")))) + (build-system asdf-build-system/sbcl) + (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 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))) + +(define-public cl-history-tree + (sbcl-package->cl-source-package sbcl-history-tree)) + +(define-public ecl-history-tree + (sbcl-package->ecl-package sbcl-history-tree)) + +(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-html-entities + (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb")) + (package + (name "sbcl-html-entities") + (version (git-version "0.02" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/BnMcGn/html-entities/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr")))) + (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)))) + +(define-public cl-html-entities + (sbcl-package->cl-source-package sbcl-html-entities)) + +(define-public ecl-html-entities + (sbcl-package->ecl-package sbcl-html-entities)) + +(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. + +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))) + +(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-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-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 cl-hu.dwim.asdf + (sbcl-package->cl-source-package sbcl-hu.dwim.asdf)) + +(define-public ecl-hu.dwim.asdf + (sbcl-package->ecl-package sbcl-hu.dwim.asdf)) + +(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-hu.dwim.common-lisp") + (version "2021-01-27") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hu-dwim/hu.dwim.common-lisp/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk")))) + (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.defclass-star + (let ((commit "3086878a485074f9b2913c58267a9b764cd632fd")) + (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)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hu-dwim/hu.dwim.defclass-star") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "19ipds9r71qymfdp4izg0l7zmvinp06adr8rdalhaq7v7mzpg83z")))) + (build-system asdf-build-system/sbcl) + (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: + +@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 + +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)) + +(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-hu.dwim.graphviz") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hu-dwim/hu.dwim.graphviz") + (commit commit))) + (file-name (git-file-name "cl-hu.dwim.graphviz" version)) + (sha256 + (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-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 package provides CFFI bindings to the Graphviz library in Common +Lisp.") + (license license:public-domain)))) + +(define-public cl-hu.dwim.graphviz + (sbcl-package->cl-source-package sbcl-hu.dwim.graphviz)) + +(define-public ecl-hu.dwim.graphviz + (sbcl-package->ecl-package sbcl-hu.dwim.graphviz)) + +(define-public sbcl-hunchenissr + (let ((commit "7df702f2e110999a2f31c7ebad81bfc39ac06670") + (revision "1")) + (package + (name "sbcl-hunchenissr") + (version (git-version "1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/interactive-ssr/hunchenissr") + (commit commit))) + (file-name (git-file-name "hunchenissr" version)) + (sha256 + (base32 "0826qrvk64pjspdklns29dv3zhzfhd6k42fq030xajv8a7hkcxda")))) + (build-system asdf-build-system/sbcl) + (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 + "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-hunchenissr + (sbcl-package->cl-source-package sbcl-hunchenissr)) + +(define-public ecl-hunchenissr + (sbcl-package->ecl-package sbcl-hunchenissr)) + +(define-public sbcl-hunchenissr-routes + (let ((commit "2e831975dc2a6c030f1b518747cf429be8484b31") + (revision "1")) + (package + (name "sbcl-hunchenissr-routes") + (version (git-version "0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/interactive-ssr/hunchenissr-routes") + (commit commit))) + (file-name (git-file-name "hunchenissr-routes" version)) + (sha256 + (base32 "1xyqacihxwk4vnffqlg93czmalscglp6sh3bwy3qwb7hdxv6yxz6")))) + (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") + (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)))) + +(define-public cl-hunchenissr-routes + (sbcl-package->cl-source-package sbcl-hunchenissr-routes)) + +(define-public ecl-hunchenissr-routes + (sbcl-package->ecl-package sbcl-hunchenissr-routes)) + +(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-hunchentoot") + (version (git-version "1.3.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/edicl/hunchentoot") + (commit commit))) + (file-name (git-file-name "cl-hunchentoot" version)) + (sha256 + (base32 "1h7ggmmzvgwr4p6j3ai0dqrw30q5309l13w4c03gqrapvwrb65l0")))) + (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") + (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)))) + +(define-public cl-hunchentoot + (sbcl-package->cl-source-package sbcl-hunchentoot)) + +(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-hunchentoot-errors + (let ((commit "69eb3bcea59ed1ccf3dd1960e6d48fb21f1dadab") + (revision "0")) + (package + (name "sbcl-hunchentoot-errors") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mmontone/hunchentoot-errors") + (commit commit))) + (file-name (git-file-name "cl-hunchentoot-errors" version)) + (sha256 + (base32 "0fab7s8qhhs713cw014qqvzm5z61wmxm2fcbkarhg41cz3li9k1j")))) + (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") + (description + "This package provides a functionality augmenting Hunchentoot error +pages and logs with request and session information.") + (license license:expat)))) + +(define-public cl-hunchentoot-errors + (sbcl-package->cl-source-package sbcl-hunchentoot-errors)) + +(define-public ecl-hunchentoot-errors + (sbcl-package->ecl-package sbcl-hunchentoot-errors)) + +(define-public sbcl-hypergeometrica + (let ((commit "db723ceb343d89a1c8d7f9174cf3a76fa91522b5") + (revision "0")) + (package + (name "sbcl-hypergeometrica") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/stylewarning/hypergeometrica") + (commit commit))) + (file-name (git-file-name "cl-hypergeometrica" version)) + (sha256 + (base32 "1dfd6w9djgfh7f4z79d8qsyggrwkjlqhs9rxpzpzv092nlwg3l35")))) + (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") + (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 + +On top of multiplication, one can build checkpointed algorithms for computing +various classical constants, like @math{\\pi}.") + (license license:bsd-3)))) + +(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-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://codeberg.org/glv/cl-in-memory-streams") + (commit commit))) + (file-name (git-file-name "cl-in-memory-streams" version)) + (sha256 + (base32 "1fls1jnkf86wimip6f95y496sc4rxpsh2y65lgqsqpi0yda5xl2f")))) + (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+)))) + +(define-public cl-in-memory-streams + (sbcl-package->cl-source-package sbcl-in-memory-streams)) + +(define-public ecl-in-memory-streams + (sbcl-package->ecl-package sbcl-in-memory-streams)) + +(define-public sbcl-incless + (let ((commit "395accf484ffdff70f20b941f322e8329c585ca7") + (revision "0")) + (package + (name "sbcl-incless") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/s-expressionists/Incless") + (commit commit))) + (file-name (git-file-name "cl-incless" commit)) + (sha256 + (base32 "14bkb5zx8xq6wv6dsqi041dwq9scvw3kdjlnkfs2ndazj0rb2a1k")))) + (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") + (description + "@code{cl-incless} implements print-object methods for many standard +classes.") + (license license:bsd-2)))) + +(define-public cl-incless + (sbcl-package->cl-source-package sbcl-incless)) + +(define-public ecl-incless + (sbcl-package->ecl-package sbcl-incless)) + +(define-public sbcl-inferior-shell + (let ((commit "15c2d04a7398db965ea1c3ba2d49efa7c851f2c2") + (revision "1")) + (package + (name "sbcl-inferior-shell") + (version (git-version "2.0.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fare/inferior-shell") + (commit commit))) + (file-name (git-file-name "inferior-shell" version)) + (sha256 + (base32 "02qx37zzk5j4xmwh77k2qa2wvnzvaj6qml5dh2q7b6b1ljvgcj4m")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (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 + "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-inferior-shell + (sbcl-package->cl-source-package sbcl-inferior-shell)) + +(define-public ecl-inferior-shell + (sbcl-package->ecl-package sbcl-inferior-shell)) + +(define-public sbcl-infix-math + (let ((commit "f5155ae9709e518061ace79887d78f8e79c61cac") + (revision "0")) + (package + (name "sbcl-infix-math") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/infix-math") + (commit commit))) + (file-name (git-file-name "cl-infix-math" version)) + (sha256 + (base32 "1h6p254xl793wfq3qla5y95k6zimy477f8brblx6ran3rg3bydbg")))) + (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") + (description + "Infix-Math is a library that provides a special-purpose syntax for +transcribing mathematical formulas into Lisp.") + (license license:expat)))) + +(define-public cl-infix-math + (sbcl-package->cl-source-package sbcl-infix-math)) + +(define-public ecl-infix-math + (sbcl-package->ecl-package sbcl-infix-math)) + +(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-inheriting-readers + (sbcl-package->cl-source-package sbcl-inheriting-readers)) + +(define-public ecl-inheriting-readers + (sbcl-package->ecl-package sbcl-inheriting-readers)) + +(define-public sbcl-interface + (let ((commit "6d8bd74214053debcbc0b174d65ea73c271c1563") + (revision "0")) + (package + (name "sbcl-interface") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/stylewarning/interface") + (commit commit))) + (file-name (git-file-name "cl-interface" version)) + (sha256 + (base32 "0h1bckhyig2znl6nrd3agjzz7knrm2kyh2vfyk7j60kzki9rpzxy")))) + (build-system asdf-build-system/sbcl) + (inputs (list sbcl-alexandria sbcl-global-vars)) + (synopsis "System for defining interfaces") + (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)))) + +(define-public cl-interface + (sbcl-package->cl-source-package sbcl-interface)) + +(define-public ecl-interface + (sbcl-package->ecl-package sbcl-interface)) + +(define-public sbcl-introspect-environment + (let ((commit "8fb20a1a33d29637a22943243d1482a20c32d6ae") + (revision "2")) + (package + (name "sbcl-introspect-environment") + (build-system asdf-build-system/sbcl) + (version (git-version "0.1" revision commit)) + (home-page "https://github.com/Bike/introspect-environment") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (git-file-name "cl-introspect-environment" 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-iolib + (let ((commit "010b7a6bdd2e918ebf2ec85edd3853179f01cb30") + (revision "0")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name "cl-iolib" version)) + (sha256 + (base32 "1qqy2yhprkmdn2vmi69akf818q3n99gv8cacv6456af0wjm5p1ga")))) + (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.") + (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 ecl-iolib + (sbcl-package->ecl-package sbcl-iolib)) + +(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-ironclad + (sbcl-package->cl-source-package sbcl-ironclad)) + +(define-public ecl-ironclad + (sbcl-package->ecl-package sbcl-ironclad)) + +(define-public sbcl-issr-core + (let ((commit "64e3b07a63a7ca3ad70ba42474f98ac4513580aa") + (revision "1")) + (package + (name "sbcl-issr-core") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/interactive-ssr/core") + (commit commit))) + (file-name (git-file-name "issr-core" version)) + (sha256 + (base32 "1bajb09crzadkirdpd6jrpcc55irjd4sxzavygr25l85pafyhniw")))) + (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") + (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 cl-issr-core + (sbcl-package->cl-source-package sbcl-issr-core)) + +(define-public ecl-issr-core + (sbcl-package->ecl-package sbcl-issr-core)) + +(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-ixf + (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183") + (revision "1")) + (package + (name "sbcl-ixf") + (version (git-version "0.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)) + (sha256 + (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa")))) + (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") + (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)))) + +(define-public cl-ixf + (sbcl-package->cl-source-package sbcl-ixf)) + +(define-public ecl-ixf + (sbcl-package->ecl-package sbcl-ixf)) + +(define-public sbcl-jonathan + (let ((commit "1f448b4f7ac8265e56e1c02b32ce383e65316300") + (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-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://github.com/shamazmazum/jpeg-turbo/") + (commit commit))) + (file-name (git-file-name "cl-jpeg-turbo" version)) + (sha256 + (base32 "1andd1ibbk3224idnpsnrn96flr5d1wm9ja3di57fs04wn577sag")))) + (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)))) + +(define-public cl-jpeg-turbo + (sbcl-package->cl-source-package sbcl-jpeg-turbo)) + +(define-public ecl-jpeg-turbo + (sbcl-package->ecl-package sbcl-jpeg-turbo)) + +(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: + +@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-jpl-util") + (version "20151005") + (source + (origin + (method git-fetch) + (uri (git-reference + ;; Quicklisp uses this fork. + (url "https://github.com/hawkir/cl-jpl-util") + (commit commit))) + (file-name + (git-file-name "jpl-util" version)) + (sha256 + (base32 + "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz")))) + (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)))) + +(define-public cl-jpl-util + (sbcl-package->cl-source-package sbcl-jpl-util)) + +(define-public ecl-jpl-util + (sbcl-package->ecl-package sbcl-jpl-util)) + +(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-jsown + (let ((commit "744c4407bef58dfa876d9da0b5c0205d869e7977")) + (package + (name "sbcl-jsown") + (version (git-version "1.0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/madnificent/jsown") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0gadvmf1d9bq35s61z76psrsnzwwk12svi66jigf491hv48wigw7")))) + (build-system asdf-build-system/sbcl) + (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. + +@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-jsown + (sbcl-package->cl-source-package sbcl-jsown)) + +(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-kdlcl") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/chee/kdlcl") + (commit commit))) + (file-name (git-file-name "cl-kdlcl" version)) + (sha256 + (base32 "0bqqxkd6s420ld2hmhvbbvpzss0m2kimmxaqhz7j1ksmq86bvvmj")))) + (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)))) + +(define-public cl-kdlcl + (sbcl-package->cl-source-package sbcl-kdlcl)) + +(define-public ecl-kdlcl + (sbcl-package->ecl-package sbcl-kdlcl)) + +(define-public sbcl-kebab + (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b") + (revision "1")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b")))) + (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))) + (native-inputs + (list sbcl-prove)) + (arguments + ;; Tests passes but the phase fails with + ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #. + `(#: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 cl-kebab + (sbcl-package->cl-source-package sbcl-kebab)) + +(define-public ecl-kebab + (sbcl-package->ecl-package sbcl-kebab)) + +(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") + (description + "KMRCL is a collection of utilities used by a number of Kevin +Rosenberg's Common Lisp packages.") + (license license:llgpl)))) + +(define-public cl-kmrcl + (sbcl-package->cl-source-package sbcl-kmrcl)) + +(define-public ecl-kmrcl + (sbcl-package->ecl-package sbcl-kmrcl)) + +(define-public sbcl-kons-9 + (let ((commit "fe0b3228ca28c316457d35f9e7c67edc83b2a4cc") + (revision "0")) + (package + (name "sbcl-kons-9") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/kaveh808/kons-9") + (commit commit))) + (file-name (git-file-name "cl-kons-9" version)) + (sha256 + (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-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-lack + (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b") + (revision "1")) + (package + (name "sbcl-lack") + (version (git-version "0.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/lack") + (commit commit))) + (file-name (git-file-name "lack" version)) + (sha256 + (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85")))) + (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") + (description + "Lack is a Common Lisp library which allows web applications to be +constructed of modular components. It was originally a part of Clack, however +it's going to be rewritten as an individual project since Clack v2 with +performance and simplicity in mind.") + (license license:llgpl)))) + +(define-public cl-lack + (sbcl-package->cl-source-package sbcl-lack)) + +(define-public ecl-lack + (sbcl-package->ecl-package sbcl-lack)) + +(define-public sbcl-lambda-fiddle + (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch + (revision "1")) + (package + (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/lambda-fiddle") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand")))) + (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-language-codes + (let ((commit "e7aa0e37cb97a3d37d6bc7316b479d01bff8f42e")) + (package + (name "sbcl-language-codes") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/language-codes") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0py176ibmsc01n5r0q1bs1ykqf5jwdbh8kx0j1a814l9y51241v0")))) + (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)))) + +(define-public cl-language-codes + (sbcl-package->cl-source-package sbcl-language-codes)) + +(define-public ecl-language-codes + (sbcl-package->ecl-package sbcl-language-codes)) + +(define-public sbcl-langutils + (let ((commit "38beec7a82eeb35b0bfb0824a41d13ed94fc648b") + (revision "0")) + (package + (name "sbcl-langutils") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eslick/cl-langutils") + (commit commit))) + (file-name (git-file-name "cl-langutils" version)) + (sha256 + (base32 "15y9x5wkg3fqndc04w2sc650fnwimxp4gjgpv9xvvdm9x4v433x6")))) + (build-system asdf-build-system/sbcl) + (arguments '(#:tests? #f)) ; There are no tests. + (inputs + (list sbcl-stdutils + sbcl-s-xml-rpc)) + (home-page "https://langutils.common-lisp.dev/") + (synopsis "Common Lisp natural language processing toolkit") + (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)))) + +(define-public cl-langutils + (sbcl-package->cl-source-package sbcl-langutils)) + +(define-public ecl-langutils + (sbcl-package->ecl-package sbcl-langutils)) + +(define-public sbcl-lass + (let ((commit "1f2418dbf2d8d6f5892171057616b2ca9d6e5008") + (revision "1")) + (package + (name "sbcl-lass") + (version (git-version "0.6.0" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/Shinmera/LASS") + (commit commit))) + (file-name (git-file-name "cl-lass" version)) + (sha256 + (base32 "1wax2kykc9ff0sk2linp9v8fcsm5ay6idpq365vivady9fh504r5")))) + (build-system asdf-build-system/sbcl) + (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)) + +(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-legion + (sbcl-package->cl-source-package sbcl-legion)) + +(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-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)))) + +(define-public cl-legit + (sbcl-package->cl-source-package sbcl-legit)) + +(define-public ecl-legit + (sbcl-package->ecl-package sbcl-legit)) + +(define-public sbcl-let-over-lambda + (let ((commit "481b2e3ab4646186451dfdd2062113203287d520") + (revision "1")) + (package + (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/thephoeron/let-over-lambda") + (commit commit))) + (file-name (git-file-name "cl-let-over-lambda" 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 + ;; #: + ;; Component LET-OVER-LAMBDA-ASD::LET-OVER-LAMBDA-TEST not found, + ;; required by # + `(#: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)))) + +(define-public cl-let-over-lambda + (sbcl-package->cl-source-package sbcl-let-over-lambda)) + +(define-public ecl-let-over-lambda + (sbcl-package->ecl-package sbcl-let-over-lambda)) + +(define-public sbcl-let-plus + (let ((commit "455e657e077235829b197f7ccafd596fcda69e30") + (revision "2")) + (package + (name "sbcl-let-plus") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/let-plus") + (commit commit))) + (sha256 + (base32 "00c0nq6l4zb692rzsc9aliqzj3avrssfyz4bhxzl7f1jsz3m29jb")) + (file-name (git-file-name "cl-let-plus" version)))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria sbcl-anaphora)) + (native-inputs + (list sbcl-lift)) + (synopsis "Destructuring extension of let*") + (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)) + +(define-public ecl-let-plus + (sbcl-package->ecl-package sbcl-let-plus)) + +(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-linedit + (let ((commit "0561c97dfca2f5854fcc66558a567a9875ddcb8f") + (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)))) + +(define-public cl-linedit + (sbcl-package->cl-source-package sbcl-linedit)) + +(define-public ecl-linedit + (sbcl-package->ecl-package sbcl-linedit)) + +(define-public sbcl-lisp-namespace + (let ((commit "699fccb6727027343bb5fca69162a3113996edfc") + (revision "2")) + (package + (name "sbcl-lisp-namespace") + (build-system asdf-build-system/sbcl) + (version (git-version "0.1" revision commit)) + (home-page "https://github.com/guicho271828/lisp-namespace") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (git-file-name "cl-lisp-namespace" version)) + (sha256 + (base32 "1p5db9mab4whapy1pl38ajw5fkrrdw266n05mnhf4xx2fb9sbx6p")))) + (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.") + (license license:llgpl)))) + +(define-public cl-lisp-namespace + (sbcl-package->cl-source-package sbcl-lisp-namespace)) + +(define-public ecl-lisp-namespace + (sbcl-package->ecl-package sbcl-lisp-namespace)) + +(define-public sbcl-lisp-pay + (let ((commit "c4de776f0a284709931ff3674160ced3b41bd000") + (revision "0")) + (package + (name "sbcl-lisp-pay") + (version (git-version "0.0.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/K1D77A/lisp-pay") + (commit commit))) + (file-name (git-file-name "cl-lisp-pay" version)) + (sha256 + (base32 "09r6qy4fipriqa0d6g9qm6dq992lr58vh24g5j0adm19i5fnjavh")))) + (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.") + (license license:expat)))) + +(define-public cl-lisp-pay + (sbcl-package->cl-source-package sbcl-lisp-pay)) + +(define-public ecl-lisp-pay + (sbcl-package->ecl-package sbcl-lisp-pay)) + +(define-public sbcl-lisp-stat + (let ((commit "357a0d2b5f68a5ff925776235c2b7455e12b78ba") + (revision "0")) + (package + (name "sbcl-lisp-stat") + (version (git-version "1.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Lisp-Stat/lisp-stat") + (commit commit))) + (file-name (git-file-name "cl-lisp-stat" version)) + (sha256 + (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-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 cl-lisp-stat + (sbcl-package->cl-source-package sbcl-lisp-stat)) + +;; 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-lispbuilder-sdl + (let ((commit "589b3c6d552bbec4b520f61388117d6c7b3de5ab")) + (package + (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/lispbuilder/lispbuilder") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0zga59fjlhq3mhwbf80qwqwpkjkxqnn2mhxajlb8563vhn3dbafp")))) + (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") + (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 cl-lispbuilder-sdl + (sbcl-package->cl-source-package sbcl-lispbuilder-sdl)) + +(define-public ecl-lispbuilder-sdl + (sbcl-package->ecl-package sbcl-lispbuilder-sdl)) + +(define-public sbcl-list-named-class + (let ((commit "2955791a7469131bcab42d800883f27993ee1d62") + (revision "0")) + (package + (name "sbcl-list-named-class") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/phoe/list-named-class") + (commit commit))) + (file-name (git-file-name "cl-list-named-class" version)) + (sha256 + (base32 "1bdi9q9wvfj66jji3n9hpjrj9271ial2awsb0xw80bmy6wqbg8kq")))) + (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.") + (license license:expat)))) + +(define-public cl-list-named-class + (sbcl-package->cl-source-package sbcl-list-named-class)) + +(define-public ecl-list-named-class + (sbcl-package->ecl-package sbcl-list-named-class)) + +(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-livesupport") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/cbaggers/livesupport") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg")))) + (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)))) + +(define-public cl-livesupport + (sbcl-package->cl-source-package sbcl-livesupport)) + +(define-public ecl-livesupport + (sbcl-package->ecl-package sbcl-livesupport)) + +(define-public sbcl-lla + (let ((commit "ded805d1e9b1493e17b601116ba9bd8a3de3024f") + (revision "1")) + (package + (name "sbcl-lla") + (version (git-version "0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tpapp/lla") + (commit commit))) + (file-name (git-file-name "cl-lla" version)) + (sha256 + (base32 "0n9vc7dnyjbbsv1n7rd8sylwda5fsdf8f890g4nachanyx0xps9k")))) + (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") + (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)))) + +(define-public cl-lla + (sbcl-package->cl-source-package sbcl-lla)) + +(define-public ecl-lla + (sbcl-package->ecl-package sbcl-lla)) + +(define-public sbcl-lmdb + (let ((commit "f439b707939a52769dc9747838ff4a616fab14a3") + (revision "0")) + (package + (name "sbcl-lmdb") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/antimer/lmdb") + (commit commit))) + (file-name (git-file-name "cl-lmdb" version)) + (sha256 + (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 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 + "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-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 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-log4cl") + (version (git-version "1.1.4" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/log4cl") + (commit commit))) + (file-name (git-file-name "cl-log4cl" version)) + (sha256 + (base32 "0n119sy35k9yl4n18az1sw9a7saa5jh3v44863b305by1p5xdy7k")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-stefil)) + (inputs + (list sbcl-bordeaux-threads)) + (home-page "https://github.com/7max/log4cl") + (synopsis "Common Lisp logging framework, modeled after Log4J") + (description + "This is a Common Lisp logging framework that can log at various levels +and mix text with expressions.") + (license license:asl2.0)))) + +(define-public cl-log4cl + (sbcl-package->cl-source-package sbcl-log4cl)) + +(define-public ecl-log4cl + (sbcl-package->ecl-package sbcl-log4cl)) + +(define-public sbcl-lorem-ipsum + (let ((commit "04a1839a03b53c954e799b9cf570ac915b032ce8") + (revision "0")) + (package + (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/sharplispers/lparallel/") + (commit commit))) + (file-name (git-file-name "cl-lparallel" version)) + (sha256 + (base32 "0nv2dx8cl25g68icqhw95yr5mygm86lcjzmzijql51na1p60g6y9")))) + (build-system asdf-build-system/sbcl) + (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") + (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)))) + +(define-public cl-lparallel + (sbcl-package->cl-source-package sbcl-lparallel)) + +(define-public ecl-lparallel + (sbcl-package->ecl-package sbcl-lparallel)) + +(define-public sbcl-lquery + (let ((revision "1") + (commit "8048111c6b83956daa632e7a3ffbd8c9c203bd8d")) + (package + (name "sbcl-lquery") + (version (git-version "3.2.1" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/Shinmera/lquery") + (commit commit))) + (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)) + (build-system asdf-build-system/sbcl) + (synopsis "Library to allow jQuery-like HTML/DOM manipulation") + (description "@code{lQuery} is a DOM manipulation library written in +Common Lisp, inspired by and based on the jQuery syntax and +functions. It uses Plump and CLSS as DOM and selector engines. The +main idea behind lQuery is to provide a simple interface for crawling +and modifying HTML sites, as well as to allow for an alternative +approach to templating.") + (home-page "https://github.com/Shinmera/lquery") + (license license:zlib)))) + +(define-public cl-lquery + (sbcl-package->cl-source-package sbcl-lquery)) + +(define-public ecl-lquery + (sbcl-package->ecl-package sbcl-lquery)) + +(define-public sbcl-ltk + (let ((commit "ff14a781d211c19c35e65a7ecaece67dda0b3ebb") + (revision "0")) + (package + (name "sbcl-ltk") + (version (git-version "0.992" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/herth/ltk") + (commit commit))) + (file-name (git-file-name "cl-ltk" version)) + (sha256 + (base32 "0f1xgsj2j7bq21cq2pa9rw3ybxd9vyknisl6z307lxx7lvhm3xac")))) + (build-system asdf-build-system/sbcl) + (inputs + (list imagemagick tk)) + (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") + (description + "LTK is a Common Lisp binding for the Tk graphics toolkit. It is +written in pure Common Lisp and does not require any Tk knowledge for its +usage.") + (home-page "http://www.peter-herth.de/ltk/") + (license license:llgpl)))) + +(define-public cl-ltk + (sbcl-package->cl-source-package sbcl-ltk)) + +(define-public ecl-ltk + (sbcl-package->ecl-package sbcl-ltk)) + +(define-public sbcl-lunamech-matrix-api + (let ((commit "aa54a820149584c237b03d500ad83397fe25dc92") + (revision "0")) + (package + (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/K1D77A/lunamech-matrix-api") + (commit commit))) + (file-name (git-file-name "cl-lunamech-matrix-api" version)) + (sha256 + (base32 "0a664qq4m5gk4iv5ck63gmsl3218jhjsalawklj56wn2pw0cf8a0")))) + (build-system asdf-build-system/sbcl) + (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.") + (license license:expat)))) + +(define-public cl-lunamech-matrix-api + (sbcl-package->cl-source-package sbcl-lunamech-matrix-api)) + +(define-public ecl-lunamech-matrix-api + (sbcl-package->ecl-package sbcl-lunamech-matrix-api)) + +(define-public sbcl-lw-compat + ;; No release since 2013. + (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d")) + (package + (name "sbcl-lw-compat") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pcostanza/lw-compat/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav")))) + (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.") + (license license:expat)))) + +(define-public cl-lw-compat + (sbcl-package->cl-source-package sbcl-lw-compat)) + +(define-public ecl-lw-compat + (sbcl-package->ecl-package sbcl-lw-compat)) + +(define-public sbcl-lzlib + (let ((commit "22767ca12d1c1bd59a7ae1f9c5ef7d2e937206bb") + (revision "2")) + (package + (name "sbcl-lzlib") + (version (git-version "2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/cl-lzlib") + (commit commit))) + (file-name (git-file-name "cl-lzlib" version)) + (sha256 + (base32 "1dxzlkay7aqcs65h2f7j7rl4sdjija60dshlahzyllfw174p9d3m")))) + (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") + (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 cl-lzlib + (sbcl-package->cl-source-package sbcl-lzlib)) + +(define-public ecl-lzlib + (sbcl-package->ecl-package sbcl-lzlib)) + +(define-public sbcl-machine-state + (let ((commit "3d258eea63942e7d2fd7212f1ad8bbcf505634a2") + (revision "2")) + (package + (name "sbcl-machine-state") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/machine-state") + (commit commit))) + (file-name (git-file-name "cl-machine-state" version)) + (sha256 + (base32 "1fjf2v8agx75qnna1n8fn54lvb01w1rk1vddi3p45a2xw1kwhzml")))) + (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 cl-machine-state + (sbcl-package->cl-source-package sbcl-machine-state)) + +(define-public ecl-machine-state + (sbcl-package->ecl-package sbcl-machine-state)) + +(define-public sbcl-magic-ed + (let ((commit "30bb27832d4e3e362578e7320934638f9889a8c4") + (revision "1")) + (package + (name "sbcl-magic-ed") + (version (git-version "0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sanel/magic-ed") + (commit commit))) + (file-name (git-file-name "cl-magic-ed" version)) + (sha256 + (base32 "1j6il4lif0dy6hqiz6n91yl8dvii9pk1i9vz0faq5mnr42mr7i5f")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/sanel/magic-ed") + (synopsis "Editing facility for Common Lisp REPL") + (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)))) + +(define-public cl-magic-ed + (sbcl-package->cl-source-package sbcl-magic-ed)) + +(define-public ecl-magic-ed + (sbcl-package->ecl-package sbcl-magic-ed)) + +(define-public sbcl-magicffi + (let ((commit "d88f2f280c31f639e4e05be75215d8a8dce6aef2")) + (package + (name "sbcl-magicffi") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dochang/magicffi/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0p6ysa92fk34bhxpw7bycbfgw150fv11z9x8jr9xb4lh8cm2hvp6")))) + (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)))) + +(define-public ecl-magicffi + (sbcl-package->ecl-package sbcl-magicffi)) + +(define-public cl-magicffi + (sbcl-package->cl-source-package sbcl-magicffi)) + +(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-maiden") + (version (git-version "3.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/maiden/") + (commit commit))) + (sha256 + (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-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 maiden + (sbcl-package->cl-source-package sbcl-maiden)) + +(define-public sbcl-maidenhead + (let ((commit "4b9c38e4845dda56ae7fb0355c5260c9ade0ac12") + (revision "1")) + (package + (name "sbcl-maidenhead") + (version (git-version "1.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/maidenhead") + (commit commit))) + (file-name (git-file-name "cl-maidenhead" version)) + (sha256 + (base32 "10pcx2ngyj6lkfbg1b58lzcm02xl1a3smnad5lvvw30pbalwcq46")))) + (build-system asdf-build-system/sbcl) (native-inputs (list sbcl-fiveam)) (synopsis - "Convert Common Lisp strings between camelCase, PascalCase and more") + "Convert coordinates between latitude/longitude and Maidenhead") (description - "@code{cl-change-case} is a library to convert strings between -camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.") + "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 cl-maidenhead + (sbcl-package->cl-source-package sbcl-maidenhead)) + +(define-public ecl-maidenhead + (sbcl-package->ecl-package sbcl-maidenhead)) + +(define-public sbcl-make-hash + ;; no tagged branch + (let ((revision "1") + (commit "ae0909cd8e697520a1085fac6f54ac2b448ebd21")) + (package + (name "sbcl-make-hash") + (version (git-version "1.0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/genovese/make-hash") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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-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-map-set + (let ((commit "7b4b545b68b8") + (revision "1")) + (package + (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/moderninterpreters/markup") + (commit commit))) + (file-name (git-file-name "markup-reader" version)) + (sha256 + (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj")))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:asd-systems '("markup"))) + (native-inputs + (list sbcl-fiveam)) + (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 cl-markup-reader + (sbcl-package->cl-source-package sbcl-markup-reader)) + +(define-public ecl-markup-reader + (sbcl-package->ecl-package sbcl-markup-reader)) + +(define-public sbcl-marray + (let ((commit "0352f316b6830f0b119088ba9be836e4726bd7d8") + (revision "0")) + (package + (name "sbcl-marray") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/death/marray") + (commit commit))) + (file-name (git-file-name "cl-marray" version)) + (sha256 + (base32 "0l4kvzpiw14vqhlsaflp3c7y51vznjjgbdi0q3axqk1wxvzy1zlx")))) + (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") + (description + "MARRAY is a library which provides access to memory-mapped files +through Common Lisp arrays.") + (license license:expat)))) + +(define-public cl-marray + (sbcl-package->cl-source-package sbcl-marray)) + +;; 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-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-mathkit + (let ((commit "fd884f94b36ef5e9bc19459ad0b3cda6303d2a2a")) + (package + (name "sbcl-mathkit") + (version (git-version "0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lispgames/mathkit/") + (commit commit))) + (file-name (git-file-name "cl-mathkit" version)) + (sha256 + (base32 "174y6ndmf52h8sml87qjfl48llmynvdizzk2h0mr85zbaysx73i3")))) + (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") + (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)))) + +(define-public cl-mathkit + (sbcl-package->cl-source-package sbcl-mathkit)) + +(define-public ecl-mathkit + (sbcl-package->ecl-package sbcl-mathkit)) + +(define-public sbcl-maxpc + (let ((commit "e5e58d053039517d30fd59ab2d128256b87790d5") + (revision "1")) + (package + (name "sbcl-maxpc") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eugeneia/maxpc") + (commit commit))) + (file-name (git-file-name name 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-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-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))) + +(define-public cl-md5 + (sbcl-package->cl-source-package sbcl-md5)) + +(define-public ecl-md5 + (package + (inherit (sbcl-package->ecl-package sbcl-md5)) + (inputs + (list ecl-flexi-streams)))) + +(define-public sbcl-messagebox + (let ((commit "ea3688d9a9954bee7079c0173bc7b3f327021e9f") + (revision "1")) + (package + (name "sbcl-messagebox") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/messagebox") + (commit commit))) + (file-name (git-file-name "messagebox" version)) + (sha256 + (base32 "0jkbzlca0wvspgsfj0b0hjwlyyy8jlywsldsbkp79q48fc3aa8jd")))) + (build-system asdf-build-system/sbcl) + (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") + (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)))) + +(define-public cl-messagebox + (sbcl-package->cl-source-package sbcl-messagebox)) + +(define-public ecl-messagebox + (sbcl-package->ecl-package sbcl-messagebox)) + +(define-public sbcl-meta + (let ((commit "74faea662139fbbfb9c99341aaed989f5b0e9da3") + (revision "0")) + (package + (name "sbcl-meta") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/frideau/meta") + (commit commit))) + (file-name (git-file-name "cl-meta" version)) + (sha256 + (base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 recursive-descent parser DSL for Common Lisp. +It's intended as a simpler alternative to parser generators.") + (license license:bsd-2)))) + +(define-public cl-meta + (sbcl-package->cl-source-package sbcl-meta)) + +(define-public ecl-meta + (sbcl-package->ecl-package sbcl-meta)) + +(define-public sbcl-metabang-bind + (let ((commit "08196426cb099db0623e6cae2aeca566e0b788b2") + (revision "2")) + (package + (name "sbcl-metabang-bind") + (version (git-version "0.8.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/metabang-bind") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "14g7k3zhm8cd6bssc5mm5h6iq1dv5lfhiq33aimcmj5a6vbiq47d")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-lift)) + (synopsis "Macro that generalizes @code{multiple-value-bind} etc.") + (description + "Bind extends the idea of of let and destructing to provide a uniform +syntax for all your accessor needs. It combines @code{let}, +@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure +editing, property or association-lists, and @code{multiple-value-bind} and a +whole lot more into a single form.") + (home-page "https://common-lisp.net/project/metabang-bind/") + ;; MIT License + (license license:expat)))) + +(define-public cl-metabang-bind + (sbcl-package->cl-source-package sbcl-metabang-bind)) + +(define-public ecl-metabang-bind + (sbcl-package->ecl-package sbcl-metabang-bind)) + +(define-public sbcl-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)))) + +(define-public cl-metacopy + (sbcl-package->cl-source-package sbcl-metacopy)) + +(define-public ecl-metacopy + (sbcl-package->ecl-package sbcl-metacopy)) + +(define-public sbcl-metatilities-base + (let ((commit "ef04337759972fd622c9b27b53149f3d594a841f") + (revision "2")) + (package + (name "sbcl-metatilities-base") + (version (git-version "0.6.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/metatilities-base") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "069rk5ncwvjnnzvvky6xiriynl72yzvjpnzl6jw9jf3b8na14zrk")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-lift)) + (synopsis "Core of the metatilities Common Lisp library") + (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/") + (license license:expat)))) + +(define-public cl-metatilities-base + (sbcl-package->cl-source-package sbcl-metatilities-base)) + +(define-public ecl-metatilities-base + (sbcl-package->ecl-package sbcl-metatilities-base)) + +(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") + (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)))) + +(define-public cl-metering + (sbcl-package->cl-source-package sbcl-metering)) + +(define-public ecl-metering + (sbcl-package->ecl-package sbcl-metering)) + +(define-public sbcl-mgl-gpr + (let ((commit "cb6ce51e2f87bf1d589f3703c13eea6e25780afe") + (revision "1")) + (package + (name "sbcl-mgl-gpr") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/melisgl/mgl-gpr") + (commit commit))) + (file-name (git-file-name "cl-mgl-gpr" version)) + (sha256 + (base32 "0w51dqixh277k6sl8bqvvp1400y6kd1l5h3d9q2f40l9bpxy8gjx")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-cl-random sbcl-mgl-pax)) + (home-page "https://melisgl.github.io/mgl-gpr/") + (synopsis "Common Lisp library of evolutionary algorithms") + (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.") + (license license:expat)))) + +(define-public cl-mgl-gpr + (sbcl-package->cl-source-package sbcl-mgl-gpr)) + +(define-public ecl-mgl-gpr + (sbcl-package->ecl-package sbcl-mgl-gpr)) + +(define-public sbcl-mgl-pax + (let ((commit "6782eb041c152721972420dfafa192692d16b7ce") + (revision "1")) + (package + (name "sbcl-mgl-pax") + (version (git-version "0.3.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/melisgl/mgl-pax") + (commit commit))) + (sha256 + (base32 "0fjbzc2fn17m80lfsc8121sa0bk7fg42fqlwhm01sk1fj4s48pma")) + (file-name (git-file-name "cl-mgl-pax" version)))) + (build-system asdf-build-system/sbcl) + ;; (native-inputs + ;; (list sbcl-try)) + (inputs + (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 + "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/") + (license license:expat)))) + +(define-public cl-mgl-pax + (sbcl-package->cl-source-package sbcl-mgl-pax)) + +(define-public ecl-mgl-pax + (sbcl-package->ecl-package sbcl-mgl-pax)) + +(define-public sbcl-mgrs + (let ((commit "c06f268f9ccb00dfc94c8a07771ce1ca82df26a2") + (revision "1")) + (package + (name "sbcl-mgrs") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/mgrs") + (commit commit))) + (file-name (git-file-name "cl-mgrs" version)) + (sha256 + (base32 "1n4kd734qjj7mrcg0q28hml3npam1rm067iwljwc87zshnxh5gmn")))) + (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+)))) + +(define-public cl-mgrs + (sbcl-package->cl-source-package sbcl-mgrs)) + +(define-public ecl-mgrs + (sbcl-package->ecl-package sbcl-mgrs)) + +(define-public sbcl-misc-extensions + (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a") + (revision "1")) + (package + (name "sbcl-misc-extensions") + (version (git-version "3.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/misc-extensions/devel.git") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0")))) + (build-system asdf-build-system/sbcl) + (synopsis "Collection of small macros and extensions for Common Lisp") + (description + "This project is intended as a catchall for small, general-purpose +extensions to Common Lisp. It contains: + +@itemize +@item @code{new-let}, a macro that combines and generalizes @code{let}, +@code{let*} and @code{multiple-value-bind}, +@item @code{gmap}, an iteration macro that generalizes @code{map}. +@end itemize\n") + (home-page "https://common-lisp.net/project/misc-extensions/") + (license license:public-domain)))) + +(define-public cl-misc-extensions + (sbcl-package->cl-source-package sbcl-misc-extensions)) + +(define-public ecl-misc-extensions + (sbcl-package->ecl-package sbcl-misc-extensions)) + +(define-public sbcl-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. + +@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-change-case - (sbcl-package->cl-source-package sbcl-cl-change-case)) +(define-public cl-mito + (sbcl-package->cl-source-package sbcl-mito)) -(define-public ecl-cl-change-case - (sbcl-package->ecl-package sbcl-cl-change-case)) +(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-mmap") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/mmap") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q")))) + (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") + (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)))) + +(define-public cl-mmap + (sbcl-package->cl-source-package sbcl-mmap)) + +(define-public ecl-mmap + (sbcl-package->ecl-package sbcl-mmap)) + +(define-public sbcl-modf + (let ((commit "dea93fe62c6bf7f66f32f52ac0c555aedbf7abad") + (revision "0")) + (package + (name "sbcl-modf") + (version (git-version "0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/smithzvk/modf") + (commit commit))) + (file-name (git-file-name "cl-modf" version)) + (sha256 + (base32 + "1aap7ldy7lv942khp026pgndgdzfkkqa9xcq1ykinrmflrgdazay")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 cl-modf + (sbcl-package->cl-source-package sbcl-modf)) + +(define-public ecl-modf + (sbcl-package->ecl-package sbcl-modf)) (define-public sbcl-modularize (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba") @@ -14611,6 +20657,103 @@ compliance control.") (define-public cl-modularize-interfaces (sbcl-package->cl-source-package sbcl-modularize-interfaces)) +(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-montezuma + (let ((commit "ee2129eece7065760de4ebbaeffaadcb27644738") + (revision "1")) + (package + (name "sbcl-montezuma") + (version (git-version "0.1.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/montezuma") + (commit commit))) + (file-name (git-file-name "cl-montezuma" version)) + (sha256 + (base32 "0svmvsbsirydk3c1spzfvj8qmkzcs9i69anpfvk1843i62wb7x2c")))) + (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") + (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 + +(define-public cl-montezuma + (sbcl-package->cl-source-package sbcl-montezuma)) + +(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-moptilities (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41")) (package @@ -14668,76 +20811,137 @@ MOP easier to use.") ;; 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") - (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") +(define-public sbcl-mssql + (let ((commit "045602a19a32254108f2b75871049293f49731eb") (revision "1")) (package - (name "sbcl-clx-xembed") - (version (git-version "0.1" revision commit)) - (home-page "https://github.com/laynor/clx-xembed") + (name "sbcl-mssql") + (version (git-version "0.0.3" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/laynor/clx-xembed") + (url "https://github.com/archimag/cl-mssql") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-mssql" version)) (sha256 - (base32 "1abx4v36ycmfjdwpjk4hh8058ya8whwia7ds9vd96q2qsrs57f12")))) + (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm")))) (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)))) + `(("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 + "@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 cl-clx-xembed - (sbcl-package->cl-source-package sbcl-clx-xembed)) +(define-public cl-mssql + (sbcl-package->cl-source-package sbcl-mssql)) -(define-public ecl-clx-xembed - (sbcl-package->ecl-package sbcl-clx-xembed)) +(define-public ecl-mssql + (sbcl-package->ecl-package sbcl-mssql)) + +(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-multilang-documentation") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/multilang-documentation") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "13y5jskx8n2b7kimpfarr8v777w3b7zj5swg1b99nj3hk0843ixw")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public cl-multilang-documentation + (sbcl-package->cl-source-package sbcl-multilang-documentation)) + +(define-public ecl-multilang-documentation + (sbcl-package->ecl-package sbcl-multilang-documentation)) + +(define-public sbcl-music-spelling + (let ((commit "a2d492af440ad30a21042140cf8ffce4b73fbd42") + (revision "0")) + (package + (name "sbcl-music-spelling") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ntrocado/music-spelling") + (commit commit))) + (file-name (git-file-name "cl-music-spelling" version)) + (sha256 + (base32 "0fgahb0jjr4sp2739d55gylmx8alsghnx3spyaqfqci4cxfrys52")))) + (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)))) + +(define-public cl-music-spelling + (sbcl-package->cl-source-package sbcl-music-spelling)) + +(define-public ecl-music-spelling + (sbcl-package->ecl-package sbcl-music-spelling)) (define-public sbcl-mw-equiv (let ((commit "3ae871458685b1ef7cd6a996ee22c8c5e738a03d") @@ -14791,41 +20995,2668 @@ equality.") (define-public ecl-mw-equiv (sbcl-package->ecl-package sbcl-mw-equiv)) -(define-public sbcl-quantile-estimator +(define-public sbcl-myway + (let ((commit "286230082a11f879c18b93f17ca571c5f676bfb7") + (revision "1")) + (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)) + +(define-public sbcl-nactivitypub (package - (name "sbcl-quantile-estimator") - (version "0.0.1") + (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. + +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-nactivitypub + (sbcl-package->cl-source-package sbcl-nactivitypub)) + +(define-public ecl-nactivitypub + (sbcl-package->ecl-package sbcl-nactivitypub)) + +(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 cl-named-readtables + (sbcl-package->cl-source-package sbcl-named-readtables)) + +(define-public ecl-named-readtables + (sbcl-package->ecl-package sbcl-named-readtables)) + +(define-public sbcl-napa-fft3 + (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236") + (revision "0")) + (package + (name "sbcl-napa-fft3") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pkhuong/Napa-FFT3") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/pkhuong/Napa-FFT3") + (synopsis "Fast Fourier Transform routines in Common Lisp") + (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)))) + +(define-public cl-napa-fft3 + (sbcl-package->cl-source-package sbcl-napa-fft3)) + +(define-public sbcl-nasdf + (let ((commit "ab7a018f3a67a999c72710644b10b4545130c139")) + (package + (name "sbcl-nasdf") + (version "0.1.8") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/atlas-engineer/ntemplate") + (commit commit))) + (file-name (git-file-name "cl-ntemplate" version)) + (sha256 + (base32 "15j7kqxvn0blr0i2xgk0il0ia91p28clfqxdh00vlp423v9a2wbx")))) + (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. + +@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 cl-nasdf + (sbcl-package->cl-source-package sbcl-nasdf)) + +(define-public ecl-nasdf + (sbcl-package->ecl-package sbcl-nasdf)) + +(define-public sbcl-nclasses + (package + (name "sbcl-nclasses") + (version "0.6.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/deadtrickster/quantile-estimator.cl") - (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5"))) + (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. + +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 cl-nclasses + (sbcl-package->cl-source-package sbcl-nclasses)) + +(define-public ecl-nclasses + (sbcl-package->ecl-package sbcl-nclasses)) + +(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)) + +(define-public ecl-ndebug + (sbcl-package->ecl-package sbcl-ndebug)) + +(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. + +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 ecl-net.didierverna.asdf-flv + (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv)) + +(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. + +@item On read error, existing files are backed up. + +@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-nfiles + (package + (inherit (sbcl-package->cl-source-package sbcl-nfiles)) + (inputs + (cons (list "iolib" cl-iolib) + (package-inputs sbcl-nfiles))))) + +(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 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: + +@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") + (license license:expat))) + +(define-public cl-nhooks + (sbcl-package->cl-source-package sbcl-nhooks)) + +(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-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 cl-nibbles + (sbcl-package->cl-source-package sbcl-nibbles)) + +(define-public ecl-nibbles + (sbcl-package->ecl-package sbcl-nibbles)) + +(define-public sbcl-ningle + (let ((commit "2e85675bbb668d6ef341514fc9f22391a0f506b1") + (revision "2")) + (package + (name "sbcl-ningle") + (version (git-version "0.3.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/ningle") + (commit commit))) + (file-name (git-file-name "cl-ningle" version)) + (sha256 + (base32 "0s9nn8ml1j4839rycvdjcbsynkqnhxw1zmrgpjz48smscwdf1f8p")))) + (build-system asdf-build-system/sbcl) + (arguments + '(#:tests? #f)) ; TODO: pull in clack-test + (native-inputs + (list sbcl-prove)) + (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-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. + +@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. + +@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. + +@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-nodgui") + (version (git-version "0.6.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/cage/nodgui.git") + (commit commit))) + (file-name (git-file-name "cl-nodgui" version)) + (sha256 + (base32 "0j98mcq0mn3wrlqm3j29pv530q0pkq00sk6liai97an51i1n08g6")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public cl-nodgui + (sbcl-package->cl-source-package sbcl-nodgui)) + +(define-public ecl-nodgui + (sbcl-package->ecl-package sbcl-nodgui)) + +(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-numcl") + (version (git-version "0.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/numcl/numcl") + (commit commit))) + (file-name (git-file-name "numcl" version)) + (sha256 + (base32 "15m4spbgayawnw5jjz04zfp0jnk9g6hgq5fmr648hzjzj50j1d78")))) + (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)) + (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+)))) + +(define-public cl-numcl + (sbcl-package->cl-source-package sbcl-numcl)) + +(define-public ecl-numcl + (sbcl-package->ecl-package sbcl-numcl)) + +(define-public sbcl-numerical-utilities + (let ((commit "44f45ba952b35675640630e40cf90df6f8279746") + (revision "0")) + (package + (name "sbcl-numerical-utilities") + (version (git-version "1.2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Lisp-Stat/numerical-utilities") + (commit commit))) + (file-name (git-file-name "cl-numerical-utilities" version)) + (sha256 + (base32 "1dwz8zxhqzi31qp863zj1cn1lgljny14snycb9nk871qs121kmsd")))) + (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") + (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)))) + +(define-public cl-numerical-utilities + (sbcl-package->cl-source-package sbcl-numerical-utilities)) + +(define-public ecl-numerical-utilities + (sbcl-package->ecl-package sbcl-numerical-utilities)) + +(define-public sbcl-numpy-file-format + (let ((commit "e440c7bbc0d86b9abf73acb0fa665b77b82a6c98") + (revision "2")) + (package + (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 cl-numpy-file-format + (sbcl-package->cl-source-package sbcl-numpy-file-format)) + +(define-public ecl-numpy-file-format + (sbcl-package->ecl-package sbcl-numpy-file-format)) + +(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 cl-object-class + (sbcl-package->cl-source-package sbcl-object-class)) + +(define-public ecl-object-class + (sbcl-package->ecl-package sbcl-object-class)) + +(define-public sbcl-olc + (let ((commit "0269ed747477d967f7d9331964906b6a0f18a9c4") + (revision "1")) + (package + (name "sbcl-olc") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/olc") + (commit commit))) + (file-name (git-file-name "cl-olc" version)) + (sha256 + (base32 "02r6w9kfa6v4a12y2azmyjkxbn54r1y18c6a024vq4y6zp20fqnz")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (synopsis + "Convert coordinates between latitude/longitude and Open Location Code") + (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+)))) + +(define-public cl-olc + (sbcl-package->cl-source-package sbcl-olc)) + +(define-public ecl-olc + (sbcl-package->ecl-package sbcl-olc)) + +(define-public sbcl-one-more-re-nightmare + (let ((commit "5b0b02e59f90964baf5737abd13300fa82f27667") + (revision "1")) + (package + (name "sbcl-one-more-re-nightmare") + (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") + (commit commit))) + (file-name (git-file-name "cl-one-more-re-nightmare" version)) + (sha256 + (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-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)) + (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 + "Opticl is a Common Lisp library for representing, processing, loading, +and saving 2-dimensional pixel-based images.") + (license license:bsd-2)))) + +(define-public cl-opticl + (sbcl-package->cl-source-package sbcl-opticl)) + +(define-public ecl-opticl + (sbcl-package->ecl-package sbcl-opticl)) + +(define-public sbcl-opticl-core + (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999") + (revision "0")) + (package + (name "sbcl-opticl-core") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/slyrus/opticl-core") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public cl-opticl-core + (sbcl-package->cl-source-package sbcl-opticl-core)) + +(define-public ecl-opticl-core + (sbcl-package->ecl-package sbcl-opticl-core)) + +(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/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)))) + +(define-public cl-org-sampler + (sbcl-package->cl-source-package sbcl-org-sampler)) + +(define-public ecl-org-sampler + (sbcl-package->ecl-package sbcl-org-sampler)) + +(define-public sbcl-origin + (let ((commit "d646134302456408d6d43580bb05299f1695ab8e") + (revision "1")) + (package + (name "sbcl-origin") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.mfiano.net/mfiano/origin") + (commit commit))) + (file-name (git-file-name "origin" version)) + (sha256 + (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (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 + "This is a native Common Lisp graphics math library with an emphasis on +performance and correctness.") + (license license:expat)))) + +(define-public ecl-origin + (sbcl-package->ecl-package sbcl-origin)) + +(define-public cl-origin + (sbcl-package->cl-source-package sbcl-origin)) + +(define-public sbcl-osc + (let ((commit "f647738ccc22925ed740a8ca9132fda76a05baeb") + (revision "0")) + (package + (name "sbcl-osc") + (version (git-version "0.9" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/zzkt/osc") + (commit commit))) + (file-name (git-file-name "cl-osc" 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+)))) + +(define-public cl-osc + (sbcl-package->cl-source-package sbcl-osc)) + +(define-public ecl-osc + (sbcl-package->ecl-package sbcl-osc)) + +(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") + (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-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-overlord") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/overlord/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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 '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 + "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. + +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. + +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 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-parenscript") + (version (git-version "2.7.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/parenscript/parenscript") + (commit commit))) + (file-name (git-file-name "parenscript" version)) + (sha256 + (base32 + "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf")))) + (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") + (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)))) + +(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-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 (string-append + "https://gitlab.common-lisp.net/parse-declarations/" + "parse-declarations.git")) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd")))) + (build-system asdf-build-system/sbcl) + (arguments + `(#:asd-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-parse-float + (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c") + (revision "2")) + (package + (name "sbcl-parse-float") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/soemraws/parse-float") + (commit commit))) + (sha256 + (base32 "0jd2spawc3v8vzqf8ky4cngl45jm65fhkrdf20mf6dcbn3mzpkmr")) + (file-name (git-file-name "proc-parse" version)))) + (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)) + (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)))) + +(define-public cl-parse-float + (sbcl-package->cl-source-package sbcl-parse-float)) + +(define-public ecl-parse-float + (sbcl-package->ecl-package sbcl-parse-float)) + +(define-public sbcl-parse-js + (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6") + (revision "1")) + (package + (name "sbcl-parse-js") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "http://marijn.haverbeke.nl/git/parse-js") + (commit commit))) + (file-name (git-file-name "cl-parse-js" version)) + (sha256 + (base32 + "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39")))) + (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 - "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9")))) + "0sk06ib1bhqv9y39vwnnw44vmbc4b0kvqm37xxmkxd4dwchq82d7")))) (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") + (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 - "Common Lisp implementation of Graham Cormode and S. -Muthukrishnan's Effective Computation of Biased Quantiles over Data -Streams in ICDE’05.") + "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-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)))) + +(define-public cl-parser-combinators + (sbcl-package->cl-source-package sbcl-parser-combinators)) + +(define-public ecl-parser-combinators + (sbcl-package->ecl-package sbcl-parser-combinators)) + +(define-public sbcl-path-parse + (let ((commit "86183f3752374435f8933394b4c5d8e75a37a113") + (revision "1")) + (package + (name "sbcl-path-parse") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eudoxia0/path-parse") + (commit commit))) + (file-name (git-file-name "cl-path-parse" version)) + (sha256 + (base32 "10mxm6q62cfpv3hw2w8k968ba8a1xglqdkwlkqs4l4nby3b11aaq")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 package provides a function to parse the @code{PATH} environment +variable portably in Common Lisp.") + (license license:expat)))) + +(define-public cl-path-parse + (sbcl-package->cl-source-package sbcl-path-parse)) + +(define-public ecl-path-parse + (sbcl-package->ecl-package sbcl-path-parse)) + +(define-public sbcl-pathname-utils + (let ((commit "f28068a79825f37002e96d13dfd739172382bf94") + (revision "3")) + (package + (name "sbcl-pathname-utils") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/pathname-utils") + (commit commit))) + (file-name (git-file-name "cl-pathname-utils" version)) + (sha256 + (base32 "10xs0wnnkbdiirr1cb7q7hzi2zmksfsrj0p7yws0j1l215vz8qs8")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-parachute)) + (inputs + (list sbcl-trivial-features)) + (home-page "https://shinmera.github.io/pathname-utils/") + (synopsis "Collection of utilities to help with pathname operations") + (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 cl-pathname-utils + (sbcl-package->cl-source-package sbcl-pathname-utils)) + +(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: #. + ;; + #:tests? #f)))) + +(define-public sbcl-percent-encoding + (let ((commit "c1224e22bc8048fbd3ebbc9329715a0c1b673170") + (revision "1")) + (package + (name "sbcl-percent-encoding") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/llibra/percent-encoding") + (commit commit))) + (file-name (git-file-name "percent-encoding" version)) + (sha256 + (base32 "0q1lh3sa6mkjr5gcdkgimkpc29rgf9cjhv90f61h8ridj28grq0h")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (inputs + (list sbcl-anaphora sbcl-babel)) + (synopsis "RFC 3986 percent-encoding library") + (description + "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))) + +(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-periods + (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949") + (revision "2")) + (package + (name "sbcl-periods") + (version (git-version "0.0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/jwiegley/periods") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk")))) + (build-system asdf-build-system/sbcl) + (inputs + `(("local-time" ,sbcl-local-time) + ("series" ,sbcl-series))) + (arguments + '(#:asd-systems '("periods" + "periods-series"))) + (synopsis "Common Lisp library for manipulating date/time objects") + (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") + (license license:bsd-3)))) + +(define-public cl-periods + (sbcl-package->cl-source-package sbcl-periods)) + +(define-public ecl-periods + (sbcl-package->ecl-package sbcl-periods)) + +(define-public sbcl-phos + (let ((commit "6620b82b091cdfed655e1093ef045dbe518d5474")) + (package + (name "sbcl-phos") + (version (git-version "0.0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/omar-polo/phos") + (commit commit))) + (file-name (git-file-name "phos" version)) + (sha256 + (base32 + "1zwci86rkbaiix0w2gd5q6nr8v2vv945pkvwp0j240iyzd4hfxr3")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 cl-phos + (sbcl-package->cl-source-package sbcl-phos)) + +(define-public ecl-phos + (sbcl-package->ecl-package sbcl-phos)) + +(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-pileup") + (version (git-version "1.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/nikodemus/pileup") + (commit commit))) + (file-name (git-file-name "cl-pileup" version)) + (sha256 + (base32 "01gvshpxil0ggjgfmgcymbgmpsfaxy6aggm0bywkn40rck3038vb")))) + (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") + (description + "@code{Pileup} is a portable, performant, and thread-safe binary heap +for Common Lisp.") + (license license:expat)))) + +(define-public cl-pileup + (sbcl-package->cl-source-package sbcl-pileup)) + +(define-public ecl-pileup + (sbcl-package->ecl-package sbcl-pileup)) + +(define-public sbcl-piping + (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656") + (revision "1")) + (package + (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 cl-piping + (sbcl-package->cl-source-package sbcl-piping)) + +(define-public ecl-piping + (sbcl-package->ecl-package sbcl-piping)) + +(define-public sbcl-plump + (let ((commit "0c3e0b57b43b6e0c5794b6a902f1cf5bee2a2927") + (revision "3")) + (package + (name "sbcl-plump") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/Shinmera/plump") + (commit commit))) + (file-name (git-file-name "cl-plump" version)) + (sha256 + (base32 "1fyb66pqvr1iy31ah9638ihs8cax17zkxk0zq14jy7x5l9rq1qlf")))) + (build-system asdf-build-system/sbcl) + (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/") + (license license:zlib)))) + +(define-public cl-plump + (sbcl-package->cl-source-package sbcl-plump)) + +(define-public ecl-plump + (sbcl-package->ecl-package sbcl-plump)) + +(define-public sbcl-plump-sexp + (let ((commit "bbcf75e9ecda8fe7603098ab8c15828407bb4f08") + (revision "0")) + (package + (name "sbcl-plump-sexp") + (version (git-version "0.1.0" revision 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)) + (sha256 + (base32 + "0zm9h0assjb8766z2v6l1k1s60y90y6f8smrl1dczwqlvc8xyln5")))) + (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)))) + +(define-public cl-plump-sexp + (sbcl-package->cl-source-package sbcl-plump-sexp)) + +(define-public ecl-plump-sexp + (sbcl-package->ecl-package sbcl-plump-sexp)) + +(define-public sbcl-png + (let ((commit "11b965fe378fd0561abe3616b18ff03af5179648") + (revision "1")) + (package + (name "sbcl-png") + (version (git-version "0.6" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ljosa/cl-png") + (commit commit))) + (file-name (git-file-name "cl-png" version)) + (sha256 + (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 + `(("cffi" ,sbcl-cffi) + ("libpng" ,libpng))) + (home-page "https://github.com/ljosa/cl-png") + (synopsis "Read and write PNG file format") + (description + "This package provides a @code{PNG} Common Lisp system to operate with +Portable Network Graphics file format.") + (license license:lgpl2.1)))) + +(define-public ecl-png + (sbcl-package->ecl-package sbcl-png)) + +(define-public cl-png + (sbcl-package->cl-source-package sbcl-png)) + +(define-public sbcl-png-read + (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88") + (revision "1")) + (package + (name "sbcl-png-read") + (version (git-version "0.3.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Ramarren/png-read") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0vyczbcwskrygrf1hgrsnk0jil8skmvf1kiaalw5jps4fjrfdkw0")))) + (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") + (license license:bsd-3)))) + +(define-public cl-png-read + (sbcl-package->cl-source-package sbcl-png-read)) + +(define-public ecl-png-read + (sbcl-package->ecl-package sbcl-png-read)) + +(define-public sbcl-pngload + (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f") + (revision "2")) + (package + (name "sbcl-pngload") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.mfiano.net/mfiano/pngload.git") + (commit commit))) + (file-name (git-file-name "pngload" version)) + (sha256 + (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1")))) + (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") + (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)))) + +(define-public cl-pngload + (sbcl-package->cl-source-package sbcl-pngload)) + +(define-public ecl-pngload + (sbcl-package->ecl-package sbcl-pngload)) + +(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 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-quantile-estimator - (sbcl-package->cl-source-package sbcl-quantile-estimator)) +(define-public cl-polymorphic-functions + (sbcl-package->cl-source-package sbcl-polymorphic-functions)) -(define-public ecl-quantile-estimator - (sbcl-package->ecl-package sbcl-quantile-estimator)) +(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-portable-condition-system") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/phoe/portable-condition-system") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "099lb9f4bavj95wik99wla5rf6fk1gdw9pvn0cqlaf0wf20csd3h")))) + (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") + (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 cl-portable-condition-system + (sbcl-package->cl-source-package sbcl-portable-condition-system)) + +(define-public ecl-portable-condition-system + (sbcl-package->ecl-package sbcl-portable-condition-system)) + +(define-public sbcl-portable-threads + (let ((commit "aa26bf38338a6b068bf8bfb3375d8d8c3b0a28df")) + (package + (name "sbcl-portable-threads") + (version (git-version "2.3" "2" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/binghe/portable-threads/") + (commit commit))) + (file-name (git-file-name "portable-threads" version)) + (sha256 + (base32 "058ksi07vfdmhrf5mdlc833s82m1rcqfja2266520m3r8bzs8bvs")))) + (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") + (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)) + +(define-public ecl-portable-threads + (sbcl-package->ecl-package sbcl-portable-threads)) + +(define-public sbcl-portal + (let ((commit "416589fa04cb239971422a1272acba236c8333be") + (revision "2")) + (package + (name "sbcl-portal") + (version (git-version "1.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/charJe/portal") + (commit commit))) + (file-name (git-file-name "portal" version)) + (sha256 + (base32 "1012jc068qdd8df6mmbn8vmmqlniqm5j2jbyrraw3yz8c13c8280")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-arrows + sbcl-cl-base64 + sbcl-cl-str + sbcl-flexi-streams + sbcl-global-vars + sbcl-ironclad + sbcl-parse-float + sbcl-usocket)) + (home-page "https://github.com/charJe/portal") + (synopsis "Portable Websocket Server for Common Lisp") + (description + "This is a websocket server for Common Lisp using usockets to be +portable between implementations and operating systems. It has a programming +interface that allows for multiple websocket apps per server using Common Lisp +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 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-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-pp-toml") + (version (git-version "1.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/pnathan/pp-toml") + (commit commit))) + (file-name (git-file-name "cl-pp-toml" version)) + (sha256 + (base32 "136d7jzz7l2ck9wwld0ac46jmpm94lvja6m50sy73s232slka2hg")))) + (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") + (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)))) + +(define-public cl-pp-toml + (sbcl-package->cl-source-package sbcl-pp-toml)) + +(define-public ecl-pp-toml + (sbcl-package->ecl-package sbcl-pp-toml)) + +(define-public sbcl-ppath + (let ((commit "eb1a8173b4d1d691ea9a7699412123462f58c3ce")) + (package + (name "sbcl-ppath") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (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 "cl-printv" version)) + (sha256 + (base32 "07agyzkwp3w2r4d2anrmr8h00yngpr5dq9mjd3m4kzhn1jcmilfb")))) + (build-system asdf-build-system/sbcl) + (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)))) + +(define-public ecl-printv + (sbcl-package->ecl-package sbcl-printv)) + +(define-public cl-printv + (sbcl-package->cl-source-package sbcl-printv)) + +(define-public sbcl-priority-queue + (let ((commit "011b8d52ef7ba7f8e6bc26608eedef222b38aaa8") + (revision "0")) + (package + (name "sbcl-priority-queue") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/dsorokin/priority-queue") + (commit commit))) + (file-name (git-file-name "cl-priority-queue" version)) + (sha256 + (base32 "0y5a1fid8xzzl58hfdj64n8mrzq0kr06a0lnmdjpgi0czc3x0jcy")))) + (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)))) + +(define-public cl-priority-queue + (sbcl-package->cl-source-package sbcl-priority-queue)) + +(define-public ecl-priority-queue + (sbcl-package->ecl-package sbcl-priority-queue)) + +(define-public sbcl-proc-parse + (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd")) + (package + (name "sbcl-proc-parse") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/proc-parse") + (commit commit))) + (sha256 + (base32 + "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh")) + (file-name (git-file-name "proc-parse" version)))) + (build-system asdf-build-system/sbcl) + (inputs + `(("alexandria" ,sbcl-alexandria) + ("babel" ,sbcl-babel))) + (native-inputs + (list sbcl-prove)) + (arguments + '(#:asd-systems '("proc-parse-test" + "proc-parse"))) + (synopsis "Procedural vector parser") + (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)))) + +(define-public cl-proc-parse + (sbcl-package->cl-source-package sbcl-proc-parse)) + +(define-public ecl-proc-parse + (sbcl-package->ecl-package sbcl-proc-parse)) (define-public sbcl-prometheus (package @@ -14903,1285 +23734,307 @@ state transition of promise objects in your control, making it easy to integrate.") (license license:zlib)))) -(define-public ecl-promise - (sbcl-package->ecl-package sbcl-promise)) - (define-public cl-promise (sbcl-package->cl-source-package sbcl-promise)) -(define-public sbcl-uuid - (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8")) +(define-public ecl-promise + (sbcl-package->ecl-package sbcl-promise)) + +(define-public sbcl-prompter + (let ((commit "7890ed5d02e70aba01ceb964c6ee4f40776e7dc0") + (revision "0")) (package - (name "sbcl-uuid") - (version (git-version "2012.12.26" "1" commit)) + (name "sbcl-prompter") + (version (git-version "0.1.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/dardoria/uuid") + (url "https://github.com/atlas-engineer/prompter") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-prompter" version)) (sha256 (base32 - "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f")))) + "0r15a6cagyp5x8aqx92ln2anni737h73bdshkvpzrac04ajss4md")))) (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") + (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 - "Common Lisp implementation of UUIDs according to RFC4122.") - (license license:llgpl)))) + "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-uuid - (sbcl-package->cl-source-package sbcl-uuid)) +(define-public cl-prompter + (sbcl-package->cl-source-package sbcl-prompter)) -(define-public ecl-uuid - (sbcl-package->ecl-package sbcl-uuid)) +(define-public ecl-prompter + (sbcl-package->ecl-package sbcl-prompter)) -(define-public sbcl-dissect - (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45")) +(define-public sbcl-purgatory + (let ((commit "3afd8f6bb4093ffb2f39ffdedf11278b3617fff9") + (revision "1")) (package - (name "sbcl-dissect") - (version (git-version "1.0.0" "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/Shinmera/dissect") + (url "https://notabug.org/cage/purgatory") (commit commit))) - (file-name (git-file-name name version)) + (file-name (git-file-name "cl-purgatory" version)) (sha256 - (base32 - "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5")))) - (build-system asdf-build-system/sbcl) - (inputs - (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-dissect - (sbcl-package->cl-source-package sbcl-dissect)) - -(define-public ecl-dissect - (sbcl-package->ecl-package sbcl-dissect)) - -(define-public sbcl-exponential-backoff - (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f")) - (package - (name "sbcl-exponential-backoff") - (version (git-version "0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/death/exponential-backoff") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/death/exponential-backoff") - (synopsis "Exponential backoff algorithm in Common Lisp") - (description - "An implementation of the exponential backoff algorithm in Common Lisp. -Inspired by the implementation found in Chromium. Read the header file to -learn about each of the parameters.") - (license license:expat)))) - -(define-public cl-exponential-backoff - (sbcl-package->cl-source-package sbcl-exponential-backoff)) - -(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")))) + (base32 "0iy2jdgrwqrq9cph7bwf79d8l4zdsgcd9sfcn0lclzai2v0yizp9")))) (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)))) + 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 cl-sxql - (sbcl-package->cl-source-package sbcl-sxql)) +(define-public cl-purgatory + (sbcl-package->cl-source-package sbcl-purgatory)) -(define-public ecl-sxql - (sbcl-package->ecl-package sbcl-sxql)) +(define-public ecl-purgatory + (sbcl-package->ecl-package sbcl-purgatory)) -(define-public sbcl-cl-ascii-table - (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2") - (revision "1")) - (package - (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/telephil/cl-ascii-table") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s")))) - (build-system asdf-build-system/sbcl) - (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-ascii-table - (sbcl-package->cl-source-package sbcl-cl-ascii-table)) - -(define-public ecl-cl-ascii-table - (sbcl-package->ecl-package sbcl-cl-ascii-table)) - -(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-acclimation - (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5")) - (package - (name "sbcl-acclimation") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/robert-strandh/Acclimation") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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. - -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-acclimation - (sbcl-package->cl-source-package sbcl-acclimation)) - -(define-public ecl-acclimation - (sbcl-package->ecl-package sbcl-acclimation)) - -(define-public sbcl-clump - (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a")) - (package - (name "sbcl-clump") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/robert-strandh/Clump") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh")))) - (inputs - (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. - -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)))) - -(define-public cl-clump - (sbcl-package->cl-source-package sbcl-clump)) - -(define-public ecl-clump - (sbcl-package->ecl-package sbcl-clump)) - -(define-public sbcl-cluffer - (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a")) - (package - (name "sbcl-cluffer") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/robert-strandh/cluffer") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj")))) - (build-system asdf-build-system/sbcl) - (inputs - (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-cluffer - (sbcl-package->cl-source-package sbcl-cluffer)) - -(define-public ecl-cluffer - (sbcl-package->ecl-package sbcl-cluffer)) - -(define-public sbcl-cl-libsvm-format - (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb") - (revision "0")) - (package - (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/masatoi/cl-libsvm-format") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-prove)) - (inputs - (list sbcl-alexandria)) - (synopsis "LibSVM data format reader for Common Lisp") - (description - "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-libsvm-format - (sbcl-package->cl-source-package sbcl-cl-libsvm-format)) - -(define-public ecl-cl-libsvm-format - (sbcl-package->ecl-package sbcl-cl-libsvm-format)) - -(define-public sbcl-cl-online-learning - (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964") - (revision "1")) - (package - (name "sbcl-cl-online-learning") - (version (git-version "0.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/masatoi/cl-online-learning") - (commit commit))) - (file-name (git-file-name "cl-online-learning" version)) - (sha256 - (base32 - "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9")))) - (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") - (description - "This library contains a collection of machine learning algorithms for -online linear classification written in Common Lisp.") - (license license:expat)))) - -(define-public cl-online-learning - (sbcl-package->cl-source-package sbcl-cl-online-learning)) - -(define-public ecl-cl-online-learning - (sbcl-package->ecl-package sbcl-cl-online-learning)) - -(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 "https://github.com/Shirakumo/cl-mpg123") - (commit commit))) - (file-name (git-file-name "cl-mpg123" version)) - (sha256 - (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 '("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)))))))) - (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") - (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)))) - -(define-public ecl-cl-mpg123 - (sbcl-package->ecl-package sbcl-cl-mpg123)) - -(define-public cl-mpg123 - (sbcl-package->cl-source-package sbcl-cl-mpg123)) - -(define-public sbcl-cl-out123 - (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7") +(define-public sbcl-puri + (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b") (revision "2")) (package - (name "sbcl-cl-out123") - (version (git-version "1.0.0" 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/Shirakumo/cl-out123") + (url "http://git.kpe.io/puri.git") (commit commit))) - (file-name (git-file-name "cl-out123" version)) + (file-name (git-file-name "puri" version)) (sha256 - (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w")) + (base32 "0gq2rsr0aihs0z20v4zqvmdl4szq53b52rh97pvnmwrlbn4mapmd")) (modules '((guix build utils))) (snippet - '(begin - ;; Remove bundled pre-compiled libraries. - (delete-file-recursively "static"))))) - (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") - (description - "This is a bindings library to @code{libout123} which allows easy -cross-platform audio playback.") - (license license:zlib)))) - -(define-public ecl-cl-out123 - (sbcl-package->ecl-package sbcl-cl-out123)) - -(define-public cl-out123 - (sbcl-package->cl-source-package sbcl-cl-out123)) - -(define-public sbcl-cl-portaudio - (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f") - (revision "1")) - (package - (name "sbcl-cl-portaudio") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/filonenko-mikhail/cl-portaudio") - (commit commit))) - (file-name (git-file-name "cl-portaudio" version)) - (sha256 - (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb")))) - (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") - (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-portaudio - (sbcl-package->cl-source-package sbcl-cl-portaudio)) - -(define-public ecl-cl-portaudio - (sbcl-package->ecl-package sbcl-cl-portaudio)) - -(define-public sbcl-cl-random-forest - (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91") - (revision "1")) - (package - (name "sbcl-cl-random-forest") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/masatoi/cl-random-forest") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 - "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq")))) + ;; The useless bundled debian folder drags `make' into the closure. + `(begin + (delete-file-recursively "debian") + #t)))) (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-ptester)) + (home-page "http://puri.kpe.io/") + (synopsis "Portable URI Library") (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 portable Universal Resource Identifier library for Common +Lisp programs. It parses URI according to the RFC 2396 specification.") + (license license:llgpl)))) -(define-public cl-random-forest - (sbcl-package->cl-source-package sbcl-cl-random-forest)) +(define-public cl-puri + (sbcl-package->cl-source-package sbcl-puri)) -(define-public ecl-cl-random-forest - (sbcl-package->ecl-package sbcl-cl-random-forest)) +(define-public ecl-puri + (sbcl-package->ecl-package sbcl-puri)) -(define-public sbcl-bordeaux-fft - (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e") - (revision "0")) - (package - (name "sbcl-bordeaux-fft") - (version (git-version "1.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ahefner/bordeaux-fft") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf")))) - (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+)))) - -(define-public cl-bordeaux-fft - (sbcl-package->cl-source-package sbcl-bordeaux-fft)) - -(define-public ecl-bordeaux-fft - (sbcl-package->ecl-package sbcl-bordeaux-fft)) - -(define-public sbcl-napa-fft3 - (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236") - (revision "0")) - (package - (name "sbcl-napa-fft3") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pkhuong/Napa-FFT3") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/pkhuong/Napa-FFT3") - (synopsis "Fast Fourier Transform routines in Common Lisp") - (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)))) - -(define-public cl-napa-fft3 - (sbcl-package->cl-source-package sbcl-napa-fft3)) - -(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://github.com/fisxoj/cl-tga") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/fisxoj/cl-tga") - (synopsis "TGA file loader for Common Lisp") - (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)))) - -(define-public cl-tga - (sbcl-package->cl-source-package sbcl-cl-tga)) - -(define-public ecl-cl-tga - (sbcl-package->ecl-package sbcl-cl-tga)) - -(define-public sbcl-com.gigamonkeys.binary-data - (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee") - (revision "0")) - (package - (name "sbcl-com.gigamonkeys.binary-data") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/gigamonkey/monkeylib-binary-data") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw")))) - (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") - (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)))) - -(define-public cl-com.gigamonkeys.binary-data - (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data)) - -(define-public ecl-com.gigamonkeys.binary-data - (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data)) - -(define-public sbcl-deflate +(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-deflate") + (name "sbcl-py-configparser") (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)) + (method url-fetch) + (uri (string-append + "https://common-lisp.net/project/py-configparser/releases/" + "py-configparser-" version ".tar.gz")) (sha256 - (base32 "1jpdjnxh6cw2d8hk70r2sxn92is52s9b855irvwkdd777fdciids")))) + (base32 "0i4rqz5cv7d7c2w81x5lwy05s6fbi3zikf4k5kpi3bkx3cabwdxj")))) (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.") + (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-deflate - (sbcl-package->cl-source-package sbcl-deflate)) +(define-public cl-py-configparser + (sbcl-package->cl-source-package sbcl-py-configparser)) -(define-public ecl-deflate - (sbcl-package->ecl-package sbcl-deflate)) +(define-public ecl-py-configparser + (sbcl-package->ecl-package sbcl-py-configparser)) -(define-public sbcl-skippy - (let ((commit "e456210202ca702c792292c5060a264d45e47090") - (revision "0")) +(define-public sbcl-py4cl + (let ((commit "2f2a008dd6162d4446803971292fe1b323fe0dd5") + (revision "2")) (package - (name "sbcl-skippy") - (version (git-version "1.3.12" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/xach/skippy") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj")))) - (build-system asdf-build-system/sbcl) - (home-page "https://xach.com/lisp/skippy/") - (synopsis "Common Lisp library for GIF images") - (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)) - -(define-public ecl-skippy - (sbcl-package->ecl-package sbcl-skippy)) - -(define-public sbcl-cl-freetype2 - (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04") - (revision "1")) - (package - (name "sbcl-cl-freetype2") - (version (git-version "1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/cl-freetype2") - (commit commit))) - (file-name (git-file-name "cl-freetype2" version)) - (sha256 - (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q")))) - (build-system asdf-build-system/sbcl) - (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 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-freetype2 - (sbcl-package->cl-source-package sbcl-cl-freetype2)) - -(define-public ecl-cl-freetype2 - (sbcl-package->ecl-package sbcl-cl-freetype2)) - -(define-public sbcl-opticl-core - (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999") - (revision "0")) - (package - (name "sbcl-opticl-core") + (name "sbcl-py4cl") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/slyrus/opticl-core") + (url "https://github.com/bendudson/py4cl") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-opticl-core - (sbcl-package->cl-source-package sbcl-opticl-core)) - -(define-public ecl-opticl-core - (sbcl-package->ecl-package sbcl-opticl-core)) - -(define-public sbcl-retrospectiff - (let ((commit "2fbf8c687799487654d988c7036d19d75a7fc67d") - (revision "1")) - (package - (name "sbcl-retrospectiff") - (version (git-version "0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/slyrus/retrospectiff") - (commit commit))) - (file-name (git-file-name "cl-retrospectiff" version)) - (sha256 - (base32 "1vfcbfzhkm2wkxnjg7y6gg93wlib9cqpbdbhyqcm5kc7170ci3vz")))) + (base32 + "1zx1kpfpd8mi1qaa7gr32mki6nvl6pqcs3437fvn4xa3yf7ybsha")) + (modules '((guix build utils))))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-fiveam)) + (list sbcl-clunit)) (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 - "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-retrospectif - (sbcl-package->cl-source-package sbcl-retrospectiff)) - -(define-public ecl-retrospectiff - (sbcl-package->ecl-package sbcl-retrospectiff)) - -(define-public sbcl-mmap - (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7") - (revision "0")) - (package - (name "sbcl-mmap") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/mmap") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0qd0xp20i1pcfn12kkapv9pirb6hd4ns7kz4zf1mmjwykpsln96q")))) - (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") - (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)))) - -(define-public cl-mmap - (sbcl-package->cl-source-package sbcl-mmap)) - -(define-public ecl-mmap - (sbcl-package->ecl-package sbcl-mmap)) - -(define-public sbcl-marray - (let ((commit "0352f316b6830f0b119088ba9be836e4726bd7d8") - (revision "0")) - (package - (name "sbcl-marray") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/death/marray") - (commit commit))) - (file-name (git-file-name "cl-marray" version)) - (sha256 - (base32 "0l4kvzpiw14vqhlsaflp3c7y51vznjjgbdi0q3axqk1wxvzy1zlx")))) - (build-system asdf-build-system/sbcl) + (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-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") + (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 - "MARRAY is a library which provides access to memory-mapped files -through Common Lisp arrays.") + "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-marray - (sbcl-package->cl-source-package sbcl-marray)) +(define-public cl-py4cl + (sbcl-package->cl-source-package sbcl-py4cl)) -;; ECL support not implemented yet. -;; (define-public ecl-marray -;; (sbcl-package->ecl-package sbcl-marray)) +(define-public ecl-py4cl + (sbcl-package->ecl-package sbcl-py4cl)) -(define-public sbcl-3bz - (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad") - (revision "1")) +(define-public sbcl-pythonic-string-reader + (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a")) (package - (name "sbcl-3bz") - (version (git-version "0.0.0" 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/3b/3bz") + (url "https://github.com/smithzvk/pythonic-string-reader/") (commit commit))) - (file-name (git-file-name name version)) (sha256 - (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4")))) + (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j")) + (file-name (git-file-name "pythonic-string-reader" version)))) (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") - (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.") - (license license:expat)))) + (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-3bz - (sbcl-package->cl-source-package sbcl-3bz)) +(define-public cl-pythonic-string-reader + (sbcl-package->cl-source-package sbcl-pythonic-string-reader)) -(define-public ecl-3bz - (sbcl-package->ecl-package sbcl-3bz)) +(define-public ecl-pythonic-string-reader + (sbcl-package->ecl-package sbcl-pythonic-string-reader)) -(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-pngload - (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f") +(define-public sbcl-pzmq + (let ((commit "6f7b2ca02c23ea53510a9b0e0f181d5364ce9d32") (revision "2")) (package - (name "sbcl-pngload") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://git.mfiano.net/mfiano/pngload.git") - (commit commit))) - (file-name (git-file-name "pngload" version)) - (sha256 - (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1")))) - (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") - (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)))) - -(define-public cl-pngload - (sbcl-package->cl-source-package sbcl-pngload)) - -(define-public ecl-pngload - (sbcl-package->ecl-package sbcl-pngload)) - -(define-public sbcl-opticl - (let ((commit "f6fc4dc5fa61ae3f2527b77e4bda99001ba37dcb") - (revision "1")) - (package - (name "sbcl-opticl") + (name "sbcl-pzmq") (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)) - (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 - "Opticl is a Common Lisp library for representing, processing, loading, -and saving 2-dimensional pixel-based images.") - (license license:bsd-2)))) - -(define-public cl-opticl - (sbcl-package->cl-source-package sbcl-opticl)) - -(define-public ecl-opticl - (sbcl-package->ecl-package sbcl-opticl)) - -(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/dkochmanski/cl-dejavu") - (commit commit))) - (file-name (git-file-name "cl-dejavu" version)) - (sha256 - (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0")))) - (build-system asdf-build-system/sbcl) - (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-dejavu - (sbcl-package->cl-source-package sbcl-cl-dejavu)) - -(define-public ecl-dejavu - (sbcl-package->ecl-package sbcl-cl-dejavu)) - -(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") - (revision "1")) - (package - (name "sbcl-cl-inflector") - (version (git-version "0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/AccelerationNet/cl-inflector") + (url "https://github.com/orivej/pzmq") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y")))) + (base32 "19mdhxhzzghlmff1fic4chg5iz0psglkim09z6dgpijm26biny05")))) (build-system asdf-build-system/sbcl) (native-inputs - (list sbcl-lisp-unit2)) + `(("bordeaux-threads" ,sbcl-bordeaux-threads) + ("fiveam" ,sbcl-fiveam) + ("let-plus" ,sbcl-let-plus))) (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)))) + `(("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-inflector - (sbcl-package->cl-source-package sbcl-cl-inflector)) +(define-public cl-pzmq + (sbcl-package->cl-source-package sbcl-pzmq)) -(define-public ecl-cl-inflector - (sbcl-package->ecl-package sbcl-cl-inflector)) - -(define-public sbcl-ixf - (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183") - (revision "1")) - (package - (name "sbcl-ixf") - (version (git-version "0.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)) - (sha256 - (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa")))) - (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") - (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)))) - -(define-public ecl-ixf - (sbcl-package->ecl-package sbcl-ixf)) - -(define-public cl-ixf - (sbcl-package->cl-source-package sbcl-ixf)) +(define-public ecl-pzmq + (sbcl-package->ecl-package sbcl-pzmq)) (define-public sbcl-qbase64 (package @@ -16213,704 +24066,185 @@ and decoder for Common Lisp.") (define-public ecl-qbase64 (sbcl-package->ecl-package sbcl-qbase64)) -(define-public sbcl-lw-compat - ;; No release since 2013. - (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d")) +(define-public sbcl-qmynd + (let ((commit "7e56daf73f0ed5f49a931c01af75fb874bcf3445") + (revision "1")) (package - (name "sbcl-lw-compat") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pcostanza/lw-compat/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav")))) - (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.") - (license license:expat)))) - -(define-public cl-lw-compat - (sbcl-package->cl-source-package sbcl-lw-compat)) - -(define-public ecl-lw-compat - (sbcl-package->ecl-package sbcl-lw-compat)) - -(define-public sbcl-contextl - ;; No release since 2013. - (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb") - (revision "2")) - (package - (name "sbcl-contextl") + (name "sbcl-qmynd") (version (git-version "1.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/pcostanza/contextl/") + (url "https://github.com/qitab/qmynd") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0")))) + (base32 + "06gw5wxcpdclb6a5i5k9lbmdlyqsp182czrm9bm1cpklzbj0ihrl")))) (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-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. -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/}.") +It's a part of QITAB umbrella project.") (license license:expat)))) -(define-public cl-contextl - (sbcl-package->cl-source-package sbcl-contextl)) +(define-public cl-qmynd + (sbcl-package->cl-source-package sbcl-qmynd)) -(define-public ecl-contextl - (sbcl-package->ecl-package sbcl-contextl)) +(define-public ecl-qmynd + (sbcl-package->ecl-package sbcl-qmynd)) -(define-public sbcl-hu.dwim.common-lisp - (let ((commit "90558195773383142a57a16687d5e7f4adea6418")) - (package - (name "sbcl-hu.dwim.common-lisp") - (version "2021-01-27") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.common-lisp/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk")))) - (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 +(define-public sbcl-quantile-estimator (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.defclass-star - (let ((commit "3086878a485074f9b2913c58267a9b764cd632fd")) - (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)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hu-dwim/hu.dwim.defclass-star") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "19ipds9r71qymfdp4izg0l7zmvinp06adr8rdalhaq7v7mzpg83z")))) - (build-system asdf-build-system/sbcl) - (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: - -@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 - -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)) - -(define-public ecl-hu.dwim.defclass-star - (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star)) - -(define-public sbcl-livesupport - (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a") - (revision "1")) - (package - (name "sbcl-livesupport") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/cbaggers/livesupport") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1rvnl0mncylbx63608pz5llss7y92j7z3ydambk9mcnjg2mjaapg")))) - (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)))) - -(define-public cl-livesupport - (sbcl-package->cl-source-package sbcl-livesupport)) - -(define-public ecl-livesupport - (sbcl-package->ecl-package sbcl-livesupport)) - -(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/fukamachi/envy") - (commit commit))) - (file-name (git-file-name "cl-envy" version)) - (sha256 - (base32 "1r0wgimd7z57x8cv69sw76w3y5l70hq50882a9nq5l4v64lg55fq")))) - (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 # - ;; 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)) - -(define-public ecl-envy - (sbcl-package->ecl-package sbcl-envy)) - -(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. - -@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-mito - (sbcl-package->cl-source-package sbcl-mito)) - -(define-public ecl-mito - (sbcl-package->ecl-package sbcl-mito)) - -(define-public sbcl-kebab - (let ((commit "e7f77644c4e46131e7b8039d191d35fe6211f31b") - (revision "1")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0j5haabnvj0vz0rx9mwyfsb3qzpga9nickbjw8xs6vypkdzlqv1b")))) - (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))) - (native-inputs - (list sbcl-prove)) - (arguments - ;; Tests passes but the phase fails with - ;; Component KEBAB-ASD::KEBAB-TEST not found, required by #. - `(#: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 cl-kebab - (sbcl-package->cl-source-package sbcl-kebab)) - -(define-public ecl-kebab - (sbcl-package->ecl-package sbcl-kebab)) - -(define-public sbcl-datafly - (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d") - (revision "1")) - (package - (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 home-page) - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv")))) - (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 #: - ;; 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-datafly - (sbcl-package->cl-source-package sbcl-datafly)) - -(define-public ecl-datafly - (sbcl-package->ecl-package sbcl-datafly)) - -(define-public sbcl-do-urlencode - (let ((commit "199846441dad5dfac5478b8dee4b4e20d107af6a") - (revision "1")) - (package - (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-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-project - (let ((commit "151107014e534fc4666222d57fec2cc8549c8814") - (revision "1")) - (package - (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 name version)) - (sha256 - (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y")))) - (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)))) - -(define-public cl-project - (sbcl-package->cl-source-package sbcl-cl-project)) - -(define-public ecl-cl-project - (sbcl-package->ecl-package sbcl-cl-project)) - -(define-public sbcl-caveman - (let ((commit "35cd8bc6c322f9d88498405fc26168a1fb42ae1c") ; No release since 2012 - (revision "2")) - (package - (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 - (url "https://github.com/fukamachi/caveman/") - (commit commit))) - (file-name (git-file-name "cl-caveman" version)) - (sha256 - (base32 "1wvjm9m1fnapg0r9imhhcwgnhhqkkccnj3c0iw9yg1f72d7zhm2w")))) - (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 #: - ;; 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: - -@itemize -@item Be extensible. -@item Be practical. -@item Don't force anything. -@end itemize\n") - (license license:llgpl)))) - -(define-public cl-caveman - (package - (inherit - (sbcl-package->cl-source-package sbcl-caveman)) - (propagated-inputs - `(("ningle" ,cl-ningle))))) - -(define-public ecl-caveman - (sbcl-package->ecl-package sbcl-caveman)) - -(define-public sbcl-lambda-fiddle - (let ((commit "d16bba55acf6065b412f64ab8fdff679a4a32b1e") ;; no tagged branch - (revision "1")) - (package - (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/lambda-fiddle") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1zarj1pqjqmk95kdx1axkgpwy2wq3canczk7f9z5hvaw5an6gand")))) - (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") + (name "sbcl-quantile-estimator") + (version "0.0.1") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/rpgoldman/xmls") - (commit version))) - (file-name (git-file-name "cl-xmls" version)) + (url "https://github.com/deadtrickster/quantile-estimator.cl") + (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5"))) + (file-name (git-file-name name version)) (sha256 - (base32 "10406sgap9kdaip7blxldnv6kabiczd6890jgic4pacsrfx6jypk")))) - (native-inputs - (list sbcl-fiveam)) + (base32 + "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9")))) (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 + '(#: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-xmls - (sbcl-package->cl-source-package sbcl-xmls)) +(define-public cl-quantile-estimator + (sbcl-package->cl-source-package sbcl-quantile-estimator)) -(define-public ecl-xmls - (sbcl-package->ecl-package sbcl-xmls)) +(define-public ecl-quantile-estimator + (sbcl-package->ecl-package sbcl-quantile-estimator)) -(define-public sbcl-geco - (let ((commit "db13c9384491092975f46f6a837ccdc04681a93a") - (revision "1")) +(define-public sbcl-queues + (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94")) (package - (name "sbcl-geco") - (version (git-version "2.1.2" 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/gpwwjr/GECO") + (url "https://github.com/oconnore/queues") (commit commit))) - (file-name (git-file-name "cl-geco" version)) + (file-name (git-file-name "queues" version)) (sha256 - (base32 "1ncaf9ab7jz59zmga0p97blsjjb1m6db0qih57wipfhqdb5ylz17")))) - (build-system asdf-build-system/sbcl) - (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 cl-geco - (sbcl-package->cl-source-package sbcl-geco)) - -(define-public ecl-geco - (sbcl-package->ecl-package sbcl-geco)) - -(define-public sbcl-html-entities - (let ((commit "4af018048e891f41d77e7d680ed3aeb639e1eedb")) - (package - (name "sbcl-html-entities") - (version (git-version "0.02" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/BnMcGn/html-entities/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1b2yl6lf6vis17y4n5s505p7ica96bdafcl6vydy1hg50fy33nfr")))) + (base32 + "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv")))) (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.") + `(("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 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-html-entities - (sbcl-package->cl-source-package sbcl-html-entities)) +(define-public cl-queues + (sbcl-package->cl-source-package sbcl-queues)) -(define-public ecl-html-entities - (sbcl-package->ecl-package sbcl-html-entities)) +(define-public ecl-queues + (sbcl-package->ecl-package sbcl-queues)) + +(define-public sbcl-quicklisp-stats + (let ((commit "953b45c2212ae513d48a611d3dd09c846a6102cd") + (revision "0")) + (package + (name "sbcl-quicklisp-stats") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/phoe/quicklisp-stats") + (commit commit))) + (file-name (git-file-name "cl-quicklisp-stats" version)) + (sha256 + (base32 "0v8dgmlgd283n1g486q4sj2mghgdvgywg2nqp43nnrfc04mkvgc0")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-drakma + sbcl-split-sequence)) + (arguments + `(#:tests? #f)) ; There are no tests. + (synopsis "Fetches and operates on Quicklisp download statistics") + (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/") + (license license:expat)))) + +(define-public cl-quicklisp-stats + (sbcl-package->cl-source-package sbcl-quicklisp-stats)) + +(define-public ecl-quicklisp-stats + (sbcl-package->ecl-package sbcl-quicklisp-stats)) + +(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")) @@ -16956,2320 +24290,35 @@ function @code{?} is abbreviation wrapper for @code{quicksearch}.") (define-public ecl-quicksearch (sbcl-package->ecl-package sbcl-quicksearch)) -(define-public sbcl-agutil - (let ((commit "df188d754d472da9faa1601a48f1f37bb7b34d68")) - (package - (name "sbcl-agutil") - (version (git-version "0.0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/alex-gutev/agutil/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf")))) - (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)))) - -(define-public cl-agutil - (sbcl-package->cl-source-package sbcl-agutil)) - -(define-public ecl-agutil - (sbcl-package->ecl-package sbcl-agutil)) - -(define-public sbcl-custom-hash-table - (let ((commit "f26983133940f5edf826ebbc8077acc04816ddfa")) - (package - (name "sbcl-custom-hash-table") - (version (git-version "0.3" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/metawilm/cl-custom-hash-table") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5")))) - (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.") - (license license:expat)))) - -(define-public cl-custom-hash-table - (sbcl-package->cl-source-package sbcl-custom-hash-table)) - -(define-public ecl-custom-hash-table - (sbcl-package->ecl-package sbcl-custom-hash-table)) - -(define-public sbcl-concurrent-hash-tables - (let ((commit "6ad539b8970ff94b1e1369b59065ed7d0660904c") - (revision "1")) - (package - (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/no-defun-allowed/concurrent-hash-tables") - (commit commit))) - (file-name (git-file-name "cl-concurrent-hash-tables" version)) - (sha256 - (base32 "0wgbv3wl33rlfbywmjag0gk7igzfksmib30r8cbnd5n47ic09iip")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-concurrent-hash-tables - (sbcl-package->cl-source-package sbcl-concurrent-hash-tables)) - -(define-public ecl-concurrent-hash-tables - (sbcl-package->ecl-package sbcl-concurrent-hash-tables)) - -(define-public sbcl-collectors - (let ((commit "4c5e70cf399381de8fb485d4ed5a5c8fd7555146") - (revision "2")) - (package - (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-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-collectors - (sbcl-package->cl-source-package sbcl-collectors)) - -(define-public ecl-collectors - (sbcl-package->ecl-package sbcl-collectors)) - -(define-public sbcl-cl-environments +(define-public sbcl-quri (package - (name "sbcl-cl-environments") - (version "0.4") + (name "sbcl-quri") + (version "0.7.0") (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 cl-environments - (sbcl-package->cl-source-package sbcl-cl-environments)) - -(define-public ecl-cl-environments - (sbcl-package->ecl-package sbcl-cl-environments)) - -(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. - -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-static-dispatch - (sbcl-package->cl-source-package sbcl-static-dispatch)) - -(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 . - '(#: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")) - (package - (name "sbcl-defpackage-plus") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/defpackage-plus") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq")))) - (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") - (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-defpackage-plus - (sbcl-package->cl-source-package sbcl-defpackage-plus)) - -(define-public ecl-defpackage-plus - (sbcl-package->ecl-package sbcl-defpackage-plus)) - -(define-public sbcl-deploy - (let ((commit "9b20e64fe924b9e31832304d87a3a72c383dc6d8") - (revision "2")) - (package - (name "sbcl-deploy") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/deploy") - (commit commit))) - (file-name (git-file-name "deploy" version)) - (sha256 - (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1")))) - (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") - (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-deploy - (sbcl-package->cl-source-package sbcl-deploy)) - -(define-public ecl-deploy - (sbcl-package->ecl-package sbcl-deploy)) - -(define-public sbcl-deeds - ;; taged branch is outdated - (let ((revision "1") - (commit "f5df54eac79b58a34030e0eb8acf3952c788410d")) - (package - (name "sbcl-deeds") - (version (git-version "1.1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/deeds") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k")))) - (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)))) - -(define-public cl-deeds - (sbcl-package->cl-source-package sbcl-deeds)) - -(define-public ecl-deeds - (sbcl-package->ecl-package sbcl-deeds)) - -(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 ecl-eventbus - (sbcl-package->ecl-package sbcl-eventbus)) - -(define-public cl-eventbus - (sbcl-package->cl-source-package sbcl-eventbus)) - -(define-public sbcl-make-hash - ;; no tagged branch - (let ((revision "1") - (commit "ae0909cd8e697520a1085fac6f54ac2b448ebd21")) - (package - (name "sbcl-make-hash") - (version (git-version "1.0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/genovese/make-hash") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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-claw-support - (package - (name "sbcl-claw-support") - (version "1.0.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/borodust/claw-support") - (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b"))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/borodust/claw-support") - (synopsis "Support routines for claw") - (description - "This package provides support routines for the @code{claw} Common Lisp -package.") - (license license:expat))) - -(define-public cl-claw-support - (sbcl-package->cl-source-package sbcl-claw-support)) - -(define-public ecl-claw-support - (sbcl-package->ecl-package sbcl-claw-support)) - -(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 cl-claw - (sbcl-package->cl-source-package sbcl-claw)) - -(define-public ecl-claw - (sbcl-package->ecl-package sbcl-claw)) - -(define-public sbcl-claw-utils - (let ((revision "0") - (commit "efe25016501973dc369f067a64c7d225802bc56f")) - (package - (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/borodust/claw-utils") - (commit commit))) - (file-name (git-file-name "claw-utils" version)) - (sha256 - (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5")))) - (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}.") - (license license:expat)))) - -(define-public cl-claw-utils - (sbcl-package->cl-source-package sbcl-claw-utils)) - -(define-public ecl-claw-utils - (sbcl-package->ecl-package sbcl-claw-utils)) - -(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 cl-array-operations - (sbcl-package->cl-source-package sbcl-array-operations)) - -(define-public ecl-array-operations - (sbcl-package->ecl-package sbcl-array-operations)) - -(define-public sbcl-clml - (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8") - (revision "0")) - (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)))) - -(define-public cl-clml - (sbcl-package->cl-source-package sbcl-clml)) - -(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-mgrs - (let ((commit "c06f268f9ccb00dfc94c8a07771ce1ca82df26a2") - (revision "1")) - (package - (name "sbcl-mgrs") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/mgrs") - (commit commit))) - (file-name (git-file-name "cl-mgrs" version)) - (sha256 - (base32 "1n4kd734qjj7mrcg0q28hml3npam1rm067iwljwc87zshnxh5gmn")))) - (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+)))) - -(define-public cl-mgrs - (sbcl-package->cl-source-package sbcl-mgrs)) - -(define-public ecl-mgrs - (sbcl-package->ecl-package sbcl-mgrs)) - -(define-public sbcl-maidenhead - (let ((commit "4b9c38e4845dda56ae7fb0355c5260c9ade0ac12") - (revision "1")) - (package - (name "sbcl-maidenhead") - (version (git-version "1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/maidenhead") - (commit commit))) - (file-name (git-file-name "cl-maidenhead" version)) - (sha256 - (base32 "10pcx2ngyj6lkfbg1b58lzcm02xl1a3smnad5lvvw30pbalwcq46")))) - (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+)))) - -(define-public cl-maidenhead - (sbcl-package->cl-source-package sbcl-maidenhead)) - -(define-public ecl-maidenhead - (sbcl-package->ecl-package sbcl-maidenhead)) - -(define-public sbcl-olc - (let ((commit "0269ed747477d967f7d9331964906b6a0f18a9c4") - (revision "1")) - (package - (name "sbcl-olc") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/olc") - (commit commit))) - (file-name (git-file-name "cl-olc" version)) - (sha256 - (base32 "02r6w9kfa6v4a12y2azmyjkxbn54r1y18c6a024vq4y6zp20fqnz")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (synopsis - "Convert coordinates between latitude/longitude and Open Location Code") - (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+)))) - -(define-public cl-olc - (sbcl-package->cl-source-package sbcl-olc)) - -(define-public ecl-olc - (sbcl-package->ecl-package sbcl-olc)) - -(define-public sbcl-regex - (let ((commit "fbc9a9f313b9edc1788f33d4b23a29151635ae22")) - (package - (name "sbcl-regex") - (version (git-version "1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/michaelw/regex/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0wq5wlafrxv13wg28hg5b10sc48b88swsvznpy2zg7x37m4nmm6a")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/michaelw/regex/") - (synopsis "Regular expression engine for Common Lisp") - (description - "This Common Lisp package provides a regular expression engine.") - (license license:bsd-2)))) - -(define-public cl-regex - (sbcl-package->cl-source-package sbcl-regex)) - -(define-public ecl-regex - (sbcl-package->ecl-package sbcl-regex)) - -(define-public sbcl-clawk - (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6")) - (package - (name "sbcl-clawk") - (version (git-version "4" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/clawk") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-regex)) - (home-page "https://github.com/sharplispers/clawk") - (synopsis "Common Lisp AWK") - (description - "CLAWK is an AWK implementation embedded into Common Lisp.") - (license license:bsd-2)))) - -(define-public cl-clawk - (sbcl-package->cl-source-package sbcl-clawk)) - -(define-public ecl-clawk - (sbcl-package->ecl-package sbcl-clawk)) - -(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) - (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") - (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)))) - -(define-public cl-clamp - (sbcl-package->cl-source-package sbcl-clamp)) - -(define-public ecl-clamp - (sbcl-package->ecl-package sbcl-clamp)) - -(define-public sbcl-trivial-shell - (let ((commit "e02ec191b34b52deca5d1c4ee99d4fa13b8772e0")) - (package - (name "sbcl-trivial-shell") - (version (git-version "0.2.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/trivial-shell") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "08mpkl5ij5sjfsyn8pq2kvsvpvyvr7ha1r8g1224fa667b8k2q85")))) - (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") - (description - "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-trivial-shell - (sbcl-package->cl-source-package sbcl-trivial-shell)) - -(define-public ecl-trivial-shell - (sbcl-package->ecl-package sbcl-trivial-shell)) - -(define-public sbcl-clesh - (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11")) - (package - (name "sbcl-clesh") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Neronus/Clesh") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-trivial-shell sbcl-named-readtables)) - (home-page "https://github.com/Neronus/Clesh") - (synopsis "Embed shell code in Common Lisp") - (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)))) - -(define-public cl-clesh - (sbcl-package->cl-source-package sbcl-clesh)) - -(define-public ecl-clesh - (sbcl-package->ecl-package sbcl-clesh)) - -(define-public sbcl-trivial-channels - (let ((commit "e2370118d8983ba69c0360a7695f8f2e2fd6a8a6") - (revision "1")) - (package - (name "sbcl-trivial-channels") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/rpav/trivial-channels") - (commit commit))) - (file-name (git-file-name "trivial-channels" version)) - (sha256 - (base32 "04wnxcgk40x8p0gxnz9arv1a5wasdqrdxa8c4p5v7r2mycfps6jj")))) - (build-system asdf-build-system/sbcl) - (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") - (description - "It's very basic implementation of channels and queue for Common Lisp.") - (license license:bsd-2)))) - -(define-public ecl-trivial-channels - (sbcl-package->ecl-package sbcl-trivial-channels)) - -(define-public cl-trivial-channels - (sbcl-package->cl-source-package sbcl-trivial-channels)) - -(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-trivial-download - (sbcl-package->cl-source-package sbcl-trivial-download)) - -(define-public ecl-trivial-download - (sbcl-package->ecl-package sbcl-trivial-download)) - -(define-public sbcl-transmission - (let ((commit "4bbf1d2761bfa5dfa79b7bc12c3238089b994d95")) - (package - (name "sbcl-transmission") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/libre-man/cl-transmission/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0sg3f2jqs2z3mvscjhc43hkd34vlcc4c8hq8rhh5w1gjg19z57hb")))) - (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") - (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-transmission - (sbcl-package->cl-source-package sbcl-transmission)) - -(define-public ecl-transmission - (sbcl-package->ecl-package sbcl-transmission)) - -(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/") + (url "https://github.com/fukamachi/quri") (commit version))) (file-name (git-file-name name version)) (sha256 - (base32 "0lkraw0dwh4is4x5sp5rjrw6f93m0gr9849abrbi12s25ws7jbw4")))) + (base32 "0l1jnvvkyaxbf08lnqfdbv6lrkq02iqr3y3rwvqxm4fvnzp7mnpz")))) (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") + (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 - "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))) + "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-gtwiwtg - (sbcl-package->cl-source-package sbcl-gtwiwtg)) +(define-public cl-quri + (sbcl-package->cl-source-package sbcl-quri)) -(define-public ecl-gtwiwtg - (sbcl-package->ecl-package sbcl-gtwiwtg)) - -(define-public sbcl-cl-progress-bar - (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae")) - (package - (name "sbcl-cl-progress-bar") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sirherrbatka/cl-progress-bar/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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-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 ecl-repl-utilities - (sbcl-package->ecl-package sbcl-repl-utilities)) - -(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-flamegraph - (let ((commit "1ed7a718eae88bd35e1649a1c716d46c59dc0a24") - (revision "0")) - (package - (name "sbcl-flamegraph") - (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") - (commit commit))) - (file-name (git-file-name "cl-flamegraph" version)) - (sha256 - (base32 "1aj7hhvav9j9c66ssy11ry3p6xqb912yafi91g6sin6pdx84c2lw")))) - (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") - (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}.") - (license license:bsd-3)))) - -(define-public cl-flamegraph - (sbcl-package->cl-source-package sbcl-flamegraph)) - -(define-public sbcl-trivial-benchmark - (let ((commit "1fbc8d15f09ed8aa426bc73956b8b7c9b2668802") - (revision "2")) - (package - (name "sbcl-trivial-benchmark") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/trivial-benchmark/") - (commit commit))) - (file-name (git-file-name "cl-trivial-benchmark" 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)))) - -(define-public cl-trivial-benchmark - (sbcl-package->cl-source-package sbcl-trivial-benchmark)) - -(define-public ecl-trivial-benchmark - (sbcl-package->ecl-package sbcl-trivial-benchmark)) - -(define-public sbcl-the-cost-of-nothing - (let ((commit "f364029fbbf37ae5786f2f9ddf6185dd204a7185") - (revision "0")) - (package - (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/marcoheisig/the-cost-of-nothing") - (commit commit))) - (file-name (git-file-name "cl-the-cost-of-nothing" version)) - (sha256 - (base32 "1ccrglyr1wnnfp218w1qj7yfl4yzlxkki3hqaifi5axgbi5dmmh8")))) - (build-system asdf-build-system/sbcl) - (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 - "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-the-cost-of-nothing - (sbcl-package->cl-source-package sbcl-the-cost-of-nothing)) - -(define-public ecl-the-cost-of-nothing - (sbcl-package->ecl-package sbcl-the-cost-of-nothing)) - -(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 cl-atomichron - (sbcl-package->cl-source-package sbcl-atomichron)) - -(define-public ecl-atomichron - (sbcl-package->ecl-package sbcl-atomichron)) - -(define-public sbcl-glyphs - (let ((commit "1ff5714e8c1dca327bc604dfe3e3d1f4b7755373")) - (package - (name "sbcl-glyphs") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ahungry/glyphs/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "17kai1anbkk5dj5sbrsin2fc019cmcbglb900db60v38myj0y0wf")))) - (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") - (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))) - -(define-public cl-zs3 - (sbcl-package->cl-source-package sbcl-zs3)) - -(define-public ecl-zs3 - (sbcl-package->ecl-package sbcl-zs3)) - -(define-public sbcl-simple-neural-network - (package - (name "sbcl-simple-neural-network") - (version "3.1") - (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)) - (sha256 - (base32 "1jj1c90fr5clwka0jv32hv6xp1bkdlpa6x5jh19an13rhx8ll4zr")))) - (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+))) - -(define-public cl-simple-neural-network - (sbcl-package->cl-source-package sbcl-simple-neural-network)) - -(define-public ecl-simple-neural-network - (sbcl-package->ecl-package sbcl-simple-neural-network)) - -(define-public sbcl-zstd - (let ((commit "134f058eee11512cf772a8d5b64364acf56a10b8") - (revision "1")) - (package - (name "sbcl-zstd") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/glv/cl-zstd") - (commit commit))) - (file-name (git-file-name "cl-zstd" version)) - (sha256 - (base32 "1iqpi5v6fdm6xxc9l8zhk6kcgl8hgxiwk1ki2yx2j3j4kfvqv8j9")))) - (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") - (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 cl-zstd - (sbcl-package->cl-source-package sbcl-zstd)) - -(define-public ecl-zstd - (sbcl-package->ecl-package sbcl-zstd)) - -(define-public sbcl-agnostic-lizard - (let ((commit "fe1a1d7d80c8b56163754e0e5b3653fd750ad298") - (revision "2")) - (package - (name "sbcl-agnostic-lizard") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/mraskin/agnostic-lizard") - (commit commit))) - (file-name (git-file-name "cl-agnostic-lizard" version)) - (sha256 - (base32 "0amzshh6v3mp24j0h2cinv4zvdlg4kih04md5biakwhnmcw4j4pr")))) - (build-system asdf-build-system/sbcl) - (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. - -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-agnostic-lizard - (sbcl-package->cl-source-package sbcl-agnostic-lizard)) - -(define-public ecl-agnostic-lizard - (sbcl-package->ecl-package sbcl-agnostic-lizard)) - -(define-public sbcl-dynamic-classes - (let ((commit "ebd7405603f67b16e8f2bc08ce8e2bcfcf439501") - (revision "0")) - (package - (name "sbcl-dynamic-classes") - (version (git-version "1.0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/dynamic-classes") - (commit commit))) - (file-name (git-file-name "dynamic-classes" version)) - (sha256 - (base32 "1k9lkchwyi2xhygp2v8ifq3kg1l3wcnihhzgr06jrivjxgdqpc1a")))) - (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)))) - -(define-public ecl-dynamic-classes - (sbcl-package->ecl-package sbcl-dynamic-classes)) - -(define-public cl-dynamic-classes - (sbcl-package->cl-source-package sbcl-dynamic-classes)) - -(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-cl-markdown") - (version (git-version "0.10.6" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/cl-markdown") - (commit commit))) - (file-name (git-file-name "cl-markdown" version)) - (sha256 - (base32 "1algqwmafipyf194cx9wfhg0pdx1ppx6s444p1pm8yaycbsyla1v")))) - (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") - (description - "This is an implementation of a Markdown parser in Common Lisp.") - (license license:expat)))) - -(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-markdown - (sbcl-package->cl-source-package sbcl-cl-markdown)) - -(define-public sbcl-cl-markless - (let ((commit "a0e145c03103bd3bf7e275d5ac0e19e8381eb844") - (revision "1")) - (package - (name "sbcl-cl-markless") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/cl-markless") - (commit commit))) - (file-name (git-file-name "cl-markless" version)) - (sha256 - (base32 "154ax1yk0b1035yij29c5pgfn7ifghrxy821mk68wyljg8afgvh5")))) - (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)))) - -(define-public ecl-cl-markless - (sbcl-package->ecl-package sbcl-cl-markless)) - -(define-public cl-markless - (sbcl-package->cl-source-package sbcl-cl-markless)) - -(define-public sbcl-magicffi - (let ((commit "d88f2f280c31f639e4e05be75215d8a8dce6aef2")) - (package - (name "sbcl-magicffi") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dochang/magicffi/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0p6ysa92fk34bhxpw7bycbfgw150fv11z9x8jr9xb4lh8cm2hvp6")))) - (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)))) - -(define-public ecl-magicffi - (sbcl-package->ecl-package sbcl-magicffi)) - -(define-public cl-magicffi - (sbcl-package->cl-source-package sbcl-magicffi)) - -(define-public sbcl-shlex - (let ((commit "3dee1cb7c0140fa7660ca7a3b2ac5e75d1218e5c") - (revision "2")) - (package - (name "sbcl-shlex") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/cl-shlex") - (commit commit))) - (file-name (git-file-name "cl-shlex" version)) - (sha256 - (base32 "16ag48sswgimr1fzr582vhym4s03idpd4lkydw5s58lv80ibpim8")))) - (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)))) - -(define-public ecl-shlex - (sbcl-package->ecl-package sbcl-shlex)) - -(define-public cl-shlex - (sbcl-package->cl-source-package sbcl-shlex)) - -(define-public sbcl-cmd - (let ((commit "0164d574ba236e2001ee1d9dba3f4774c7512a8c") - (revision "8")) - (package - (name "sbcl-cmd") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/cmd/") - (commit commit))) - (file-name (git-file-name "cl-cmd" version)) - (sha256 - (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 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 - "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 ecl-cmd - (sbcl-package->ecl-package sbcl-cmd)) - -(define-public cl-cmd - (sbcl-package->cl-source-package sbcl-cmd)) - -(define-public sbcl-ppath - (let ((commit "eb1a8173b4d1d691ea9a7699412123462f58c3ce")) - (package - (name "sbcl-ppath") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (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-trivial-escapes - (let ((commit "1eca78da2078495d09893be58c28b3aa7b8cc4d1")) - (package - (name "sbcl-trivial-escapes") - (version (git-version "1.2.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/williamyaoh/trivial-escapes") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "0v6h8lk17iqv1qkxgqjyzn8gi6v0hvq2vmfbb01md3zjvjqxn6lr")))) - (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") - (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)))) - -(define-public ecl-trivial-escapes - (sbcl-package->ecl-package sbcl-trivial-escapes)) - -(define-public cl-trivial-escapes - (sbcl-package->cl-source-package sbcl-trivial-escapes)) - -(define-public sbcl-trivial-extensible-sequences - (let ((commit "d40b2da23716601578b1f645727047f80baeb49a") - (revision "0")) - (package - (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/Shinmera/trivial-extensible-sequences") - (commit commit))) - (file-name (git-file-name "cl-trivial-extensible-sequences" version)) - (sha256 - (base32 "0352psdd8j0phjycr6ldckwspyal4jcf0f2fizi6fwdp7nvadng7")))) - (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.") - (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-trivial-extensible-sequences - (sbcl-package->cl-source-package sbcl-trivial-extensible-sequences)) - -(define-public sbcl-cl-indentify - (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53")) - (package - (name "sbcl-cl-indentify") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/yitzchak/cl-indentify") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p")))) - (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") - (description - "A library and command line utility to automatically indent Common Lisp -source files.") - (license license:expat)))) - -(define-public ecl-cl-indentify - (sbcl-package->ecl-package sbcl-cl-indentify)) - -(define-public cl-indentify - (sbcl-package->cl-source-package sbcl-cl-indentify)) - -(define-public sbcl-concrete-syntax-tree - (let ((commit "37291727196a3bc88a7be67c1427c52078d4b82c") - (revision "0")) - (package - (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/s-expressionists/Concrete-Syntax-Tree") - (commit commit))) - (file-name (git-file-name "cl-concrete-syntax-tree" commit)) - (sha256 - (base32 "15q9jyqsh2z921li9my8c840cj2ci7k217x5frfiyk0kymkx4rgv")))) - (build-system asdf-build-system/sbcl) - (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 - "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)))) - -(define-public ecl-concrete-syntax-tree - (sbcl-package->ecl-package sbcl-concrete-syntax-tree)) - -(define-public cl-concrete-syntax-tree - (sbcl-package->cl-source-package sbcl-concrete-syntax-tree)) - -(define-public sbcl-eclector - (let ((commit "d499b09142c7e39b4ef52e821fa767d5a8d606a0") - (revision "0")) - (package - (name "sbcl-eclector") - (version (git-version "0.9.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)) - (sha256 - (base32 "1sg8wmdpm8pcjwk394way5vs2ya3r995lddmi51q9zfn9hmzb7gn")))) - (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") - (description - "Eclector is a portable Common Lisp reader that is highly customizable, -can recover from errors and can return concrete syntax trees. - -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. - -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-eclector - (sbcl-package->ecl-package sbcl-eclector)) - -(define-public cl-eclector - (sbcl-package->cl-source-package sbcl-eclector)) - -(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 cl-trucler - (sbcl-package->cl-source-package sbcl-trucler)) - -(define-public ecl-trucler - (sbcl-package->ecl-package sbcl-trucler)) - -(define-public sbcl-incless - (let ((commit "395accf484ffdff70f20b941f322e8329c585ca7") - (revision "0")) - (package - (name "sbcl-incless") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/s-expressionists/Incless") - (commit commit))) - (file-name (git-file-name "cl-incless" commit)) - (sha256 - (base32 "14bkb5zx8xq6wv6dsqi041dwq9scvw3kdjlnkfs2ndazj0rb2a1k")))) - (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") - (description - "@code{cl-incless} implements print-object methods for many standard -classes.") - (license license:bsd-2)))) - -(define-public ecl-incless - (sbcl-package->ecl-package sbcl-incless)) - -(define-public cl-incless - (sbcl-package->cl-source-package sbcl-incless)) - -(define-public sbcl-jsown - (let ((commit "744c4407bef58dfa876d9da0b5c0205d869e7977")) - (package - (name "sbcl-jsown") - (version (git-version "1.0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/madnificent/jsown") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "0gadvmf1d9bq35s61z76psrsnzwwk12svi66jigf491hv48wigw7")))) - (build-system asdf-build-system/sbcl) - (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. - -@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 ecl-jsown - (sbcl-package->ecl-package sbcl-jsown)) - -(define-public cl-jsown - (sbcl-package->cl-source-package sbcl-jsown)) - -(define-public sbcl-clostrum - (let ((commit "c85d38bde9d093f1f132574e9b98b8d64683cd51") - (revision "0")) - (package - (name "sbcl-clostrum") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/s-expressionists/Clostrum") - (commit commit))) - (file-name (git-file-name "cl-clostrum" commit)) - (sha256 - (base32 "10alsdnpzbgic75xghwjp414sqwg4npvp69zn0r4l8ms0ki9zr1x")))) - (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.") - (license license:bsd-2)))) - -(define-public ecl-clostrum - (sbcl-package->ecl-package sbcl-clostrum)) - -(define-public cl-clostrum - (sbcl-package->cl-source-package sbcl-clostrum)) - -(define-public sbcl-system-locale - (let ((commit "4b334bc2fa45651bcaa28ae7d9331095d6bf0a17")) - (package - (name "sbcl-system-locale") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/system-locale/") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "00p5c053kmgq4ks6l9mxsqz6g3bjcybvkvj0bh3r90qgpkaawm1p")))) - (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") - (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)))) - -(define-public ecl-system-locale - (sbcl-package->ecl-package sbcl-system-locale)) - -(define-public cl-system-locale - (sbcl-package->cl-source-package sbcl-system-locale)) - -(define-public sbcl-cluster - (let ((commit "b040e97578f3027d7d8c7652c74917726574c43e") - (revision "0")) - (package - (name "sbcl-cluster") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/robert-strandh/Cluster") - (commit commit))) - (file-name (git-file-name "cl-cluster" commit)) - (sha256 - (base32 "0ixbr3wm7d3m8mgzasd95rxvs9kip6ngr5s1zk7j3604mcfssqyi")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public ecl-cluster - (sbcl-package->ecl-package sbcl-cluster)) - -(define-public cl-cluster - (sbcl-package->cl-source-package sbcl-cluster)) - -(define-public sbcl-language-codes - (let ((commit "e7aa0e37cb97a3d37d6bc7316b479d01bff8f42e")) - (package - (name "sbcl-language-codes") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/language-codes") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "0py176ibmsc01n5r0q1bs1ykqf5jwdbh8kx0j1a814l9y51241v0")))) - (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)))) - -(define-public ecl-language-codes - (sbcl-package->ecl-package sbcl-language-codes)) - -(define-public cl-language-codes - (sbcl-package->cl-source-package sbcl-language-codes)) - -(define-public sbcl-multilang-documentation - (let ((commit "59e798a07e949e8957a20927f52aca425d84e4a0")) - (package - (name "sbcl-multilang-documentation") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/multilang-documentation") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "13y5jskx8n2b7kimpfarr8v777w3b7zj5swg1b99nj3hk0843ixw")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public ecl-multilang-documentation - (sbcl-package->ecl-package sbcl-multilang-documentation)) - -(define-public cl-multilang-documentation - (sbcl-package->cl-source-package sbcl-multilang-documentation)) - -(define-public sbcl-trivial-do - (let ((commit "03a1729f1e71bad3ebcf6cf098a0cce52dfa1163")) - (package - (name "sbcl-trivial-do") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/yitzchak/trivial-do") - (commit commit))) - (file-name (git-file-name name commit)) - (sha256 - (base32 "1ffva79nkicc7wc8c2ic5nayis3b2rk5sxzj74yjkymkjgbpcrgd")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/yitzchak/trivial-do") - (synopsis "Additional dolist style macros for Common Lisp") - (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)))) - -(define-public ecl-trivial-do - (sbcl-package->ecl-package sbcl-trivial-do)) - -(define-public cl-trivial-do - (sbcl-package->cl-source-package sbcl-trivial-do)) - -(define-public sbcl-common-lisp-jupyter - (let ((commit "ba9f0e746b9200d6fd6db647d7274448119ed01b") - (revision "3")) - (package - (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/yitzchak/common-lisp-jupyter") - (commit commit))) - (file-name (git-file-name "common-lisp-jupyter" commit)) - (sha256 - (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-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 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-common-lisp-jupyter - (sbcl-package->ecl-package sbcl-common-lisp-jupyter)) - -(define-public cl-common-lisp-jupyter - (sbcl-package->cl-source-package sbcl-common-lisp-jupyter)) +(define-public ecl-quri + (sbcl-package->ecl-package sbcl-quri)) (define-public sbcl-radiance (let ((commit "8d826c7fe1935338565580931db43f46181e0e85") @@ -19332,12 +24381,12 @@ they can be used on practically any setup without having to undergo special adaptations.") (license license:zlib)))) -(define-public ecl-radiance - (sbcl-package->ecl-package sbcl-radiance)) - (define-public cl-radiance (sbcl-package->cl-source-package sbcl-radiance)) +(define-public ecl-radiance + (sbcl-package->ecl-package sbcl-radiance)) + (define-public sbcl-radiance-contribs (let ((commit "710b3e1f9971e48368d52eea0b407f2e8f510981") (revision "1")) @@ -19375,3576 +24424,525 @@ adaptations.") implementations for Radiance interfaces.") (license license:zlib)))) -(define-public ecl-radiance-contribs - (sbcl-package->ecl-package sbcl-radiance-contribs)) - (define-public cl-radiance-contribs (sbcl-package->cl-source-package sbcl-radiance-contribs)) -(define-public sbcl-daemon - (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597") - (revision "1")) +(define-public ecl-radiance-contribs + (sbcl-package->ecl-package sbcl-radiance-contribs)) + +(define-public sbcl-random-sample + (let ((commit "46b70374ed796b84ea003e83c1db97b0caf97e22") + (revision "0")) (package - (name "sbcl-daemon") - (version (git-version "0.0.4" 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/snmsts/daemon") + (url "https://github.com/ruricolist/random-sample") (commit commit))) - (file-name (git-file-name "daemon" version)) + (file-name (git-file-name "cl-random-sample" version)) (sha256 - (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4")))) + (base32 "0nhgca6wf754wbg91h40gx7xq22rawg2pn6l7h02wv1jxac4q6nh")))) (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) (inputs - (list sbcl-trivial-features)) - (home-page "https://github.com/snmsts/daemon") - (synopsis "Daemonize Common Lisp processes") + (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") (description - "DAEMON provides the functionality of daemonizing Common Lisp processes -on UNIX like platforms.") + "Random-Sample is a library for reliably taking a random sample from a +sequence.") (license license:expat)))) -(define-public ecl-daemon - (sbcl-package->ecl-package sbcl-daemon)) +(define-public cl-random-sample + (sbcl-package->cl-source-package sbcl-random-sample)) -(define-public cl-daemon - (sbcl-package->cl-source-package sbcl-daemon)) +(define-public ecl-random-sample + (sbcl-package->ecl-package sbcl-random-sample)) -(define-public sbcl-file-attributes - (let ((commit "bbde396438f37d676de9775239115410bec4da2d")) +(define-public sbcl-random-state + (let ((commit "c270d4f15e0b66ba9680ca8734a5de56959cb118") + (revision "1")) (package - (name "sbcl-file-attributes") - (version (git-version "1.0.0" "2" 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/Shinmera/file-attributes/") + (url "https://github.com/Shinmera/random-state") + (commit commit))) + (file-name (git-file-name "cl-random-state" version)) + (sha256 + (base32 "0r3bk6hqpr0qmpza93pknl8wpsd6y0yy9qg7vz751a7gzzww9vj6")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-documentation-utils)) + (home-page "https://shinmera.github.io/random-state/") + (synopsis "Portable random number generation") + (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)) + +(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 cl-re + (sbcl-package->cl-source-package sbcl-re)) + +(define-public ecl-re + (sbcl-package->ecl-package sbcl-re)) + +(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-regex") + (version (git-version "1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/michaelw/regex/") (commit commit))) (file-name (git-file-name name version)) (sha256 - (base32 "0n8q818ry2shggjfhp8gjby8v5mla9pg97c5g19pcglpnwim7a74")))) + (base32 "0wq5wlafrxv13wg28hg5b10sc48b88swsvznpy2zg7x37m4nmm6a")))) (build-system asdf-build-system/sbcl) - (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") + (home-page "https://github.com/michaelw/regex/") + (synopsis "Regular expression engine for Common Lisp") (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 Common Lisp package provides a regular expression engine.") + (license license:bsd-2)))) -(define-public ecl-file-attributes - (sbcl-package->ecl-package sbcl-file-attributes)) +(define-public cl-regex + (sbcl-package->cl-source-package sbcl-regex)) -(define-public cl-file-attributes - (sbcl-package->cl-source-package sbcl-file-attributes)) +(define-public ecl-regex + (sbcl-package->ecl-package sbcl-regex)) -(define-public sbcl-filesystem-utils - (let ((commit "a07e8b61b89d4b46408fb9294d9b8130e8c8a02e") - (revision "2")) +(define-public sbcl-repl-utilities + (let ((commit "7e300df663177ea4581f4e7e9c601377881dd986")) (package - (name "sbcl-filesystem-utils") - (version (git-version "1.0.0" 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/Shinmera/filesystem-utils/") + (url "https://github.com/m-n/repl-utilities/") (commit commit))) - (file-name (git-file-name "cl-filesystem-utils" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "1zv2i2gndnbs7hz3bgkkq1qfx604wbndpc7qqlqvg23fssn9w59f")))) + (base32 "1hh56pq5nw3l4b83dzlyss69f06r038byj2cnjwvci4hfjhdfcc3")))) (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") + (home-page "https://github.com/m-n/repl-utilities") + (synopsis "Ease common tasks at the Common Lisp REPL") (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)))) + "@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 ecl-filesystem-utils - (sbcl-package->ecl-package sbcl-filesystem-utils)) +(define-public cl-repl-utilities + (sbcl-package->cl-source-package sbcl-repl-utilities)) -(define-public cl-filesystem-utils - (sbcl-package->cl-source-package sbcl-filesystem-utils)) +(define-public ecl-repl-utilities + (sbcl-package->ecl-package sbcl-repl-utilities)) -(define-public sbcl-depot - (let ((commit "73822d9f480cbad00971b45ee80117297a67fb53") +(define-public sbcl-restas + (let ((commit "81bbbab6b36f81f846f78e71232e9d3d15f6d952") (revision "1")) (package - (name "sbcl-depot") - (version (git-version "1.0.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/Shinmera/depot/") + (url "https://github.com/archimag/restas") (commit commit))) + (file-name (git-file-name "cl-restas" version)) (sha256 - (base32 "1v42pirdwbxy8l8i9a2jmbpri8a62vh0r4vm25xwaak0y4gr71va")) - (file-name (git-file-name "depot" version)))) - (build-system asdf-build-system/sbcl) - (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/") - (license license:zlib)))) - -(define-public ecl-depot - (sbcl-package->ecl-package sbcl-depot)) - -(define-public cl-depot - (sbcl-package->cl-source-package sbcl-depot)) - -(define-public sbcl-cl-difflib - (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e") - (revision "0")) - (package - (name "sbcl-cl-difflib") - (version (git-version "0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/wiseman/cl-difflib") - (commit commit))) - (file-name - (git-file-name name version)) - (sha256 - (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48")))) - (build-system asdf-build-system/sbcl) - ;; 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 - "A Common Lisp library for computing differences between -sequences based on the Python difflib module.") - (license license:expat)))) - -(define-public ecl-cl-difflib - (sbcl-package->ecl-package sbcl-cl-difflib)) - -(define-public cl-difflib - (sbcl-package->cl-source-package sbcl-cl-difflib)) - -(define-public sbcl-cl-html-diff - (let ((commit "5a0b39d1c524278d6f60851d7786bb2585614310") - (revision "0")) - (package - (name "sbcl-cl-html-diff") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/wiseman/cl-html-diff") - (commit commit))) - (file-name - (git-file-name name version)) - (sha256 - (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb")))) - (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.") - (license license:expat)))) - -(define-public ecl-cl-html-diff - (sbcl-package->ecl-package sbcl-cl-html-diff)) - -(define-public cl-html-diff - (sbcl-package->cl-source-package sbcl-cl-html-diff)) - -(define-public sbcl-tooter - (let ((commit "2dcc2facddcacd79d0cce545a8c4b73c35826fc1") - (revision "4")) - (package - (name "sbcl-tooter") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/tooter") - (commit commit))) - (file-name (git-file-name "cl-tooter" version)) - (sha256 - (base32 "1zisrmslj4rnibm02vxh7hbas2cfsjh6iizs2nfdg3a3pn7bhf6h")))) - (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)))) - -(define-public ecl-tooter - (sbcl-package->ecl-package sbcl-tooter)) - -(define-public cl-tooter - (sbcl-package->cl-source-package sbcl-tooter)) - -(define-public sbcl-croatoan - (let ((commit "282145ff9e9005fddc4241bc6827b3ab09c5bd25") - (revision "1")) - (package - (name "sbcl-croatoan") - (version (git-version "2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/McParen/croatoan") - (commit commit))) - (file-name (git-file-name "cl-croatoan" version)) - (sha256 - (base32 "021h2f2yj4j9gynr3k7qi36x94jm5b95p3vaddbaih96wyzgbmq5")))) + (base32 "00ng6jik1lwjw3bbxhijy8s0ml24lgm73liwrr01gcsb0r6wrjjn")))) (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")))))))) - (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 ecl-croatoan - (sbcl-package->ecl-package sbcl-croatoan)) - -(define-public cl-croatoan - (sbcl-package->cl-source-package sbcl-croatoan)) - -(define-public sbcl-cl-spark - (let ((commit "4e34bcebdcf8e45265986eb43ad4ad03bb41a581") - (revision "1")) - (package - (name "sbcl-cl-spark") - (version (git-version "0.1.13" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tkych/cl-spark") - (commit commit))) - (file-name (git-file-name "cl-spark" version)) - (sha256 - (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk")))) - (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)))) - -(define-public ecl-cl-spark - (sbcl-package->ecl-package sbcl-cl-spark)) - -(define-public cl-spark - (sbcl-package->cl-source-package sbcl-cl-spark)) - -(define-public sbcl-access - (let ((commit "a4f87fc1007f5c9a0a2abfddc1c23a77e87096f8") - (revision "1")) - (package - (name "sbcl-access") - (version (git-version "1.6.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/AccelerationNet/access") - (commit commit))) - (file-name (git-file-name "cl-access" version)) - (sha256 - (base32 "0zdjqhb9rvnlq6nzmsp7372gi91k1rq9bz510m6hcki7g3r01iv5")))) - (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") - (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 ecl-access - (sbcl-package->ecl-package sbcl-access)) - -(define-public cl-access - (sbcl-package->cl-source-package sbcl-access)) - -(define-public sbcl-sxql-composer - (let ((commit "2b2230cb01ae1b68e28921d99e4814046867fb75") - (revision "1")) - (package - (name "sbcl-sxql-composer") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/sxql-composer") - (commit commit))) - (file-name (git-file-name "sxql-composer" version)) - (sha256 - (base32 "1agkrj3ymskzc3c7pxbrj123d1kygjqcls145m0ap3i07q96hh1r")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-sxql)) - (synopsis "Build and compose SXQL queries dynamically") - (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)))) - -(define-public ecl-sxql-composer - (sbcl-package->ecl-package sbcl-sxql-composer)) - -(define-public cl-sxql-composer - (sbcl-package->cl-source-package sbcl-sxql-composer)) - -(define-public sbcl-cl-i18n - (let ((commit "acb162a12dac50fc46d83da8934fce85d19e31c4") - (revision "3")) - (package - (name "sbcl-cl-i18n") - (version (git-version "0.5.5" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://codeberg.org/cage/cl-i18n") - (commit commit))) - (file-name (git-file-name "cl-i18n" version)) - (sha256 - (base32 "1y29cirmlyc406a45sdx39spvnjzbs772c977075ccicz46qaxz7")))) - (build-system asdf-build-system/sbcl) - (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)) - -(define-public cl-i18n - (sbcl-package->cl-source-package sbcl-cl-i18n)) - -(define-public sbcl-crypto-shortcuts - (let ((commit "7efd22d80e867cd8c9f8f363d4fe7b51ee2dadc0") - (revision "1")) - (package - (name "sbcl-crypto-shortcuts") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/crypto-shortcuts") - (commit commit))) - (file-name (git-file-name "crypto-shortcuts" version)) - (sha256 - (base32 "0c0m0ar04jn7qf2v8c4sivamlzki03r13rnxy8b3n27rh9r6hgin")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-base64 sbcl-flexi-streams sbcl-ironclad)) - (synopsis "Collection of common cryptography functions") - (description - "This is a collection of common cryptography functions for Common -Lisp.") - (home-page "https://shinmera.github.io/crypto-shortcuts/") - (license license:zlib)))) - -(define-public ecl-crypto-shortcuts - (sbcl-package->ecl-package sbcl-crypto-shortcuts)) - -(define-public cl-crypto-shortcuts - (sbcl-package->cl-source-package sbcl-crypto-shortcuts)) - -(define-public sbcl-cl-html5-parser - (let ((commit "74a92eb3a183a0afd089ea33350e816e6b9aeefa") - (revision "1")) - (package - (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/rotatef/cl-html5-parser") - (commit commit))) - (file-name (git-file-name "cl-html5-parser" version)) - (sha256 - (base32 "04if61wigylsmn996rbfl8ylsd0d9hzdmg7p2wiglncibjzcl5k9")))) - (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+)))) - -(define-public ecl-cl-html5-parser - (sbcl-package->ecl-package sbcl-cl-html5-parser)) - -(define-public cl-html5-parser - (sbcl-package->cl-source-package sbcl-cl-html5-parser)) - -(define-public sbcl-percent-encoding - (let ((commit "c1224e22bc8048fbd3ebbc9329715a0c1b673170") - (revision "1")) - (package - (name "sbcl-percent-encoding") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/llibra/percent-encoding") - (commit commit))) - (file-name (git-file-name "percent-encoding" version)) - (sha256 - (base32 "0q1lh3sa6mkjr5gcdkgimkpc29rgf9cjhv90f61h8ridj28grq0h")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - (list sbcl-anaphora sbcl-babel)) - (synopsis "RFC 3986 percent-encoding library") - (description - "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-machine-state - (let ((commit "3d258eea63942e7d2fd7212f1ad8bbcf505634a2") - (revision "2")) - (package - (name "sbcl-machine-state") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/machine-state") - (commit commit))) - (file-name (git-file-name "cl-machine-state" version)) - (sha256 - (base32 "1fjf2v8agx75qnna1n8fn54lvb01w1rk1vddi3p45a2xw1kwhzml")))) - (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)) - -(define-public cl-machine-state - (sbcl-package->cl-source-package sbcl-machine-state)) - -(define-public sbcl-cl-mount-info - (let ((commit "2024f5037a7f63db3e3587dc9972cd7b9318f06b") - (revision "1")) - (package - (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 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)))) - -(define-public cl-system-load - (sbcl-package->cl-source-package sbcl-system-load)) - -(define-public ecl-system-load - (sbcl-package->ecl-package sbcl-system-load)) - -(define-public sbcl-fof - (let ((commit "522879e7da110ecf2e841998b197b34062c54b29") - (revision "1")) - (package - (name "sbcl-fof") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.com/ambrevar/fof") - (commit commit))) - (file-name (git-file-name "cl-fof" version)) - (sha256 - (base32 "0ipy51q2fw03xk9rqcyzbq2b9c32npc1gl3c53rdjywpak7zwwg6")))) - (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") - (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+)))) - -(define-public ecl-fof - (sbcl-package->ecl-package sbcl-fof)) - -(define-public cl-fof - (sbcl-package->cl-source-package sbcl-fof)) - -(define-public sbcl-computable-reals - (let ((commit "fdc73d75e79d0a4ce6d01c822c950ae2eb137d39")) - (package - (name "sbcl-computable-reals") - (version (git-version "1.1.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/stylewarning/computable-reals") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0f12axi53x14l12dgf4a1lfq3p1fx7fh7sjfc0db3lk88ph9qfwl")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/stylewarning/computable-reals") - (synopsis "Arbitrary-precision, re-computing real-numbers in Common Lisp") - (description - "This library provides arbitrary precision (floating point) real -numbers in Common Lisp.") - (license license:bsd-3)))) - -(define-public ecl-computable-reals - (sbcl-package->ecl-package sbcl-computable-reals)) - -(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 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. - -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))) - -(define-public ecl-html-template - (sbcl-package->ecl-package sbcl-html-template)) - -(define-public cl-html-template - (sbcl-package->cl-source-package sbcl-html-template)) - -(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 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)))) - -(define-public ecl-bodge-math - (sbcl-package->ecl-package sbcl-bodge-math)) - -(define-public cl-bodge-math - (sbcl-package->cl-source-package sbcl-bodge-math)) - -(define-public sbcl-cl-mathstats - (let ((commit "4df38ea1b9de069cf939919253565a9ca9538eca") - (revision "1")) - (package - (name "sbcl-cl-mathstats") - (version (git-version "0.8.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hraban/cl-mathstats") - (commit commit))) - (file-name (git-file-name "cl-mathstats" version)) - (sha256 - (base32 "0gsjvmkmnxc4hp5z9mkm5vsllywqyg7kx8jgz88vnx47yj3va1s8")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-lift)) - (inputs - (list sbcl-cl-containers sbcl-metatilities-base)) - (home-page "https://github.com/hraban/cl-mathstats") - (synopsis "Common Lisp collection of mathematical routines") - (description - "This package provides Common Lisp math and statistics routines.") - (license license:expat)))) - -(define-public ecl-cl-mathstats - (sbcl-package->ecl-package sbcl-cl-mathstats)) - -(define-public cl-mathstats - (sbcl-package->cl-source-package sbcl-cl-mathstats)) - -(define-public sbcl-bodge-blobs-support - (let ((commit "c5034ca5f4fc3a44dbadeba215a09afd59a404b0") - (revision "1")) - (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)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/3b/cl-opengl") - (commit commit))) - (file-name (git-file-name "cl-opengl" version)) - (sha256 - (base32 "0mhqmll09f079pnd6mgswz9nvr6h5n27d4q7zpmm2igf1v460id7")))) - (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") - (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)))) - -(define-public ecl-cl-opengl - (sbcl-package->ecl-package sbcl-cl-opengl)) - -(define-public cl-opengl - (sbcl-package->cl-source-package sbcl-cl-opengl)) - -(define-public sbcl-shadow - (let ((commit "b2031adbfba3579b48c9d39ad997e19b79b6852f") - (revision "1")) - (package - (name "sbcl-shadow") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://git.mfiano.net/mfiano/shadow") - (commit commit))) - (file-name (git-file-name "shadow" version)) - (sha256 - (base32 "0w1i734gkdkziin74ql2nhx7jdjxx02ylssaa6qdrvnj4br1124a")))) - (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") - (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).") - (license license:expat)))) - -(define-public ecl-shadow - (sbcl-package->ecl-package sbcl-shadow)) - -(define-public cl-shadow - (sbcl-package->cl-source-package sbcl-shadow)) - -(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 ecl-umbra - (sbcl-package->ecl-package sbcl-umbra)) - -(define-public cl-umbra - (sbcl-package->cl-source-package sbcl-umbra)) - -(define-public sbcl-abstract-classes - (let ((commit "7fa74f1e057f9ba7c1ffecff14f049f979e45267") - (revision "1")) - (package - (name "sbcl-abstract-classes") - (version (git-version "1.7.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://bitbucket.org/eeeickythump/cl-abstract-classes") - (commit commit))) - (file-name (git-file-name "cl-abstract-classes" version)) - (sha256 - (base32 "06lby4i6xbbgs7kgb0f3fqybvyskyg6djhrf967lnysv7hn3zpg9")))) - (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") - (description - "This package provides Common Lisp extension to the MOP to allow -abstract, final and singleton classes.") - (license license:public-domain)))) - -(define-public ecl-abstract-classes - (sbcl-package->ecl-package sbcl-abstract-classes)) - -(define-public cl-abstract-classes - (sbcl-package->cl-source-package sbcl-abstract-classes)) - -(define-public sbcl-coalton - (let ((commit "939342495f55991812c2c2767322c5e51e755216") - (revision "4")) - (package - (name "sbcl-coalton") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/coalton-lang/coalton") - (commit commit))) - (file-name (git-file-name "cl-coalton" version)) - (sha256 - (base32 "08qzj3v4fvn9h87whyqg650rpap8lva7jr94d1akv6m2z62l5q68")))) - (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") - (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)))) - -(define-public ecl-coalton - (sbcl-package->ecl-package sbcl-coalton)) - -(define-public cl-coalton - (sbcl-package->cl-source-package sbcl-coalton)) - -(define-public sbcl-clip - (let ((commit "7afa68702fbb99c47ed115ea0faccd97a29d9b2e") - (revision "1")) - (package - (name "sbcl-clip") - (version (git-version "0.7.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/shinmera/clip") - (commit commit))) - (file-name (git-file-name "clip" version)) - (sha256 - (base32 "13kkajkva2shm19fvn4yashsw18l6imv2rmy3hmpcky7g5ay7bv3")))) - (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") - (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)))) - -(define-public ecl-clip - (sbcl-package->ecl-package sbcl-clip)) - -(define-public cl-clip - (sbcl-package->cl-source-package sbcl-clip)) - -(define-public sbcl-pathname-utils - (let ((commit "f28068a79825f37002e96d13dfd739172382bf94") - (revision "3")) - (package - (name "sbcl-pathname-utils") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/pathname-utils") - (commit commit))) - (file-name (git-file-name "cl-pathname-utils" version)) - (sha256 - (base32 "10xs0wnnkbdiirr1cb7q7hzi2zmksfsrj0p7yws0j1l215vz8qs8")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) - (inputs - (list sbcl-trivial-features)) - (home-page "https://shinmera.github.io/pathname-utils/") - (synopsis "Collection of utilities to help with pathname operations") - (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: #. - ;; - #:tests? #f)))) - -(define-public cl-pathname-utils - (sbcl-package->cl-source-package sbcl-pathname-utils)) - -(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 ecl-terrable - (sbcl-package->ecl-package sbcl-terrable)) - -(define-public cl-terrable - (sbcl-package->cl-source-package sbcl-terrable)) - -(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 - "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 ecl-simple-rgb - (sbcl-package->ecl-package sbcl-simple-rgb)) - -(define-public cl-simple-rgb - (sbcl-package->cl-source-package sbcl-simple-rgb)) - -(define-public sbcl-cl-qprint - (let ((commit "bfe398551cbfb7ca84a9ba59a26a1116ac5c06eb") - (revision "1")) - (package - (name "sbcl-cl-qprint") - (version (git-version "0.9.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eugeneia/cl-qprint/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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 ecl-cl-qprint - (sbcl-package->ecl-package sbcl-cl-qprint)) - -(define-public cl-qprint - (sbcl-package->cl-source-package sbcl-cl-qprint)) - -(define-public sbcl-cl-mime - (let ((commit "d30a28e0a40393bd3af7d138daa05319ed2e9d07") - (revision "1")) - (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)) - (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") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0qn8if0fj6vzc897pqqqs0m1y107gmzqngpqhqmwrcsp1ckj5k0v")))) - (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)))) - -(define-public ecl-cl-mime - (sbcl-package->ecl-package sbcl-cl-mime)) - -(define-public cl-mime - (sbcl-package->cl-source-package sbcl-cl-mime)) - -(define-public sbcl-cl-mimeparse - (let ((commit "93cbdf6f6fe8a2eb5f652f8adec453eb98ea0547") - (revision "0")) - (package - (name "sbcl-cl-mimeparse") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmontone/cl-mimeparse") - (commit commit))) - (file-name (git-file-name "cl-mimeparse" version)) - (sha256 - (base32 "0gdkpi3620va0a3q56svcn1q9f5w0pqfhx30lnldg8fjnrdfiwkk")))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-test-systems '("cl-mimeparse-tests"))) - (native-inputs - (list sbcl-rt)) - (inputs - (list sbcl-cl-ppcre sbcl-parse-number)) - (home-page "https://github.com/mmontone/cl-mimeparse/") - (synopsis "Common Lisp library for parsing MIME types") - (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)))) - -(define-public cl-mimeparse - (sbcl-package->cl-source-package sbcl-cl-mimeparse)) - -(define-public ecl-cl-mimeparse - (sbcl-package->ecl-package sbcl-cl-mimeparse)) - -(define-public sbcl-cl-mixed - (let ((commit "4aaff134d3902d93a2a8605c10de4bcfc62d7afa") - (revision "0")) - (package - (name "sbcl-cl-mixed") - (version (git-version "2.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/cl-mixed") - (commit commit))) - (file-name (git-file-name "cl-mixed" version)) - (sha256 - (base32 "1mrj95lxb1gbxxm89x8gy1ifw2ic1p5wwpapkxcd2jr8abw7zny0")) - (modules '((guix build utils))) - (snippet - ;; Delete bundled libraries. - `(begin - (delete-file-recursively "static"))))) - (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)))) - -(define-public ecl-cl-mixed - (sbcl-package->ecl-package sbcl-cl-mixed)) - -(define-public cl-mixed - (sbcl-package->cl-source-package sbcl-cl-mixed)) - -(define-public sbcl-lispbuilder-sdl - (let ((commit "589b3c6d552bbec4b520f61388117d6c7b3de5ab")) - (package - (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/lispbuilder/lispbuilder") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0zga59fjlhq3mhwbf80qwqwpkjkxqnn2mhxajlb8563vhn3dbafp")))) - (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") - (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))) - -(define-public ecl-dufy - (sbcl-package->ecl-package sbcl-dufy)) - -(define-public cl-dufy - (sbcl-package->cl-source-package sbcl-dufy)) - -(define-public sbcl-bknr-datastore - (let ((commit "c98d44f47cc88d19ff91ca3eefbd9719a8ace022") - (revision "1")) - (package - (name "sbcl-bknr-datastore") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/hanshuebner/bknr-datastore") - (commit commit))) - (file-name (git-file-name "bknr-datastore" version)) - (sha256 - (base32 "1vi3w65fnczqvswkm381n6liqfrzjrg40y698qvj7skj28dm5vrm")))) - (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))) + (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) - ("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)))) - -;; 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 cl-bknr-datastore - (sbcl-package->cl-source-package sbcl-bknr-datastore)) - -(define-public sbcl-authentic - (let ((commit "4e9194dda227b98f56dda1c2a2480efcc2d1f973") - (revision "2")) - (package - (name "sbcl-authentic") - (version (git-version "0.1.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/charje/cl-authentic") - (commit commit))) - (file-name (git-file-name "cl-authentic" version)) - (sha256 - (base32 "0ncsxrybnx0pjsndv3j8w4lphlpcsld8sxg3c5b46fb3a8nd4ssf")))) - (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)))) - -(define-public ecl-authentic - (sbcl-package->ecl-package sbcl-authentic)) - -(define-public cl-authentic - (sbcl-package->cl-source-package sbcl-authentic)) - -(define-public sbcl-3d-vectors - (let ((commit "257969402864ac3859d77b981abf0aa5373c4e78") - (revision "2")) - (package - (name "sbcl-3d-vectors") - (version (git-version "3.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/3d-vectors") - (commit commit))) - (file-name (git-file-name "cl-3d-vectors" version)) - (sha256 - (base32 "0vmf7nycc49ydcy0dfs25cgs655kwjc6jcjvpwxw61jq4gl2fh7x")))) - (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") - (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)))) - -(define-public ecl-3d-vectors - (sbcl-package->ecl-package sbcl-3d-vectors)) - -(define-public cl-3d-vectors - (sbcl-package->cl-source-package sbcl-3d-vectors)) - -(define-public sbcl-3d-matrices - (let ((commit "b4f5a58299f8437fad2d77f0879c374e3430f4b5") - (revision "2")) - (package - (name "sbcl-3d-matrices") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/3d-matrices") - (commit commit))) - (file-name (git-file-name "cl-3d-matrices" version)) - (sha256 - (base32 "1s8b4zlmqwyplghs73riz1khf0c5sk64w6b12jd599091d5nr6sr")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-parachute)) - (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") - (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)))) - -(define-public ecl-3d-matrices - (sbcl-package->ecl-package sbcl-3d-matrices)) - -(define-public cl-3d-matrices - (sbcl-package->cl-source-package sbcl-3d-matrices)) - -(define-public sbcl-3d-quaternions - (let ((commit "b79c15cca8d9c409216a6cee8ec9e182dcdec9e2") - (revision "0")) - (package - (name "sbcl-3d-quaternions") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/3d-quaternions") - (commit commit))) - (file-name (git-file-name "cl-3d-quaternions" version)) - (sha256 - (base32 "1mrq6yhb90mhvxdkg3fx58ci5yj5xlixbbzf1q6p76wyq40qjv76")))) - (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") - (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)))) - -;; 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-3d-quaternions - (sbcl-package->cl-source-package sbcl-3d-quaternions)) - -(define-public sbcl-interface - (let ((commit "6d8bd74214053debcbc0b174d65ea73c271c1563") - (revision "0")) - (package - (name "sbcl-interface") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/stylewarning/interface") - (commit commit))) - (file-name (git-file-name "cl-interface" version)) - (sha256 - (base32 "0h1bckhyig2znl6nrd3agjzz7knrm2kyh2vfyk7j60kzki9rpzxy")))) - (build-system asdf-build-system/sbcl) - (inputs (list sbcl-alexandria sbcl-global-vars)) - (synopsis "System for defining interfaces") - (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)))) - -(define-public ecl-interface - (sbcl-package->ecl-package sbcl-interface)) - -(define-public cl-interface - (sbcl-package->cl-source-package sbcl-interface)) - -(define-public sbcl-cl-syslog - (let ((commit "d5d46f777f0735938e6f650cf17d814b88b70305") - (revision "0")) - (package - (name "sbcl-cl-syslog") - (version (git-version "0.2.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/mmaul/cl-syslog") - (commit commit))) - (file-name (git-file-name "cl-syslog" version)) - (sha256 - (base32 "1qcz55jiqwk91b01hsahxnha884f6zf2883j2m51sqph0mvj69mh")))) - (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") - (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)))) - -(define-public ecl-metering - (sbcl-package->ecl-package sbcl-metering)) - -(define-public cl-metering - (sbcl-package->cl-source-package sbcl-metering)) - -(define-public sbcl-cl-grnm - (let ((commit "778a312e9eb3d3de7541457b516ea3d9055a15aa") - (revision "0")) - (package - (name "sbcl-cl-grnm") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/quil-lang/cl-grnm") - (commit commit))) - (file-name (git-file-name "cl-grnm" version)) - (sha256 - (base32 "1hb5n37n3x2ylrghcqsia2g9a6f5wg24l659jiz4ncpi5bsv4m3s")))) - (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)))) - -(define-public ecl-cl-grnm - (sbcl-package->ecl-package sbcl-cl-grnm)) - -(define-public cl-grnm - (sbcl-package->cl-source-package sbcl-cl-grnm)) - -(define-public sbcl-priority-queue - (let ((commit "011b8d52ef7ba7f8e6bc26608eedef222b38aaa8") - (revision "0")) - (package - (name "sbcl-priority-queue") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/dsorokin/priority-queue") - (commit commit))) - (file-name (git-file-name "cl-priority-queue" version)) - (sha256 - (base32 "0y5a1fid8xzzl58hfdj64n8mrzq0kr06a0lnmdjpgi0czc3x0jcy")))) - (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)))) - -(define-public ecl-priority-queue - (sbcl-package->ecl-package sbcl-priority-queue)) - -(define-public cl-priority-queue - (sbcl-package->cl-source-package sbcl-priority-queue)) - -(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") - (license license:bsd-2)))) - -(define-public ecl-cl-messagepack - (sbcl-package->ecl-package sbcl-cl-messagepack)) - -(define-public cl-messagepack - (sbcl-package->cl-source-package sbcl-cl-messagepack)) - -(define-public sbcl-cl-permutation - (let ((commit "20c10e9ca56452d2fafc3ec0984dcdf78b4f4b19") - (revision "0")) - (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 - (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-messagebox - (let ((commit "ea3688d9a9954bee7079c0173bc7b3f327021e9f") - (revision "1")) - (package - (name "sbcl-messagebox") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/messagebox") - (commit commit))) - (file-name (git-file-name "messagebox" version)) - (sha256 - (base32 "0jkbzlca0wvspgsfj0b0hjwlyyy8jlywsldsbkp79q48fc3aa8jd")))) - (build-system asdf-build-system/sbcl) - (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") - (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)))) - -(define-public ecl-messagebox - (sbcl-package->ecl-package sbcl-messagebox)) - -(define-public cl-messagebox - (sbcl-package->cl-source-package sbcl-messagebox)) - -(define-public sbcl-3d-transforms - (let ((commit "1d44509387d0747cd0351e95a533eca609058632") - (revision "0")) - (package - (name "sbcl-3d-transforms") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/3d-transforms") - (commit commit))) - (file-name (git-file-name "cl-3d-transforms" version)) - (sha256 - (base32 "03pmv7dh1j6kl16ch6lnvxzjrld4jbr3jx8slzkiipgzdxg74pcx")))) - (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") - (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)) - -(define-public cl-3d-transforms - (sbcl-package->cl-source-package sbcl-3d-transforms)) - -(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-type-templates - (sbcl-package->cl-source-package sbcl-type-templates)) - -(define-public ecl-type-templates - (sbcl-package->ecl-package sbcl-type-templates)) - -(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 cl-3d-spaces - (sbcl-package->cl-source-package sbcl-3d-spaces)) - -(define-public ecl-3d-spaces - (sbcl-package->ecl-package sbcl-3d-spaces)) - -(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 ecl-glsl-toolkit - (sbcl-package->ecl-package sbcl-glsl-toolkit)) - -(define-public cl-glsl-toolkit - (sbcl-package->cl-source-package sbcl-glsl-toolkit)) - -(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 ecl-simple-tasks - (sbcl-package->ecl-package sbcl-simple-tasks)) - -(define-public cl-simple-tasks - (sbcl-package->cl-source-package sbcl-simple-tasks)) - -(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)))) - -(define-public ecl-trivial-main-thread - (sbcl-package->ecl-package sbcl-trivial-main-thread)) - -(define-public cl-trivial-main-thread - (sbcl-package->cl-source-package sbcl-trivial-main-thread)) - -(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 - ;; #: - ;; Sorry, No walker for the special operater DECLARE defined. - ;; - ;; Backtrace for: # - ;; 0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK # # :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 ecl-arnesi - (sbcl-package->ecl-package sbcl-arnesi)) - -(define-public cl-arnesi - (sbcl-package->cl-source-package sbcl-arnesi)) - -(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+)))) - -(define-public ecl-gettext - (sbcl-package->ecl-package sbcl-gettext)) - -(define-public cl-gettext - (sbcl-package->cl-source-package sbcl-gettext)) - -(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)))) - -(define-public ecl-parser-combinators - (sbcl-package->ecl-package sbcl-parser-combinators)) - -(define-public cl-parser-combinators - (sbcl-package->cl-source-package sbcl-parser-combinators)) - -(define-public sbcl-cl-locale - (let ((commit "0a36cc0dcf5e0a8c8bf97869cd6199980ca25eec") - (revision "1")) - (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))) - (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)))) - -(define-public ecl-cl-locale - (sbcl-package->ecl-package sbcl-cl-locale)) - -(define-public cl-locale - (sbcl-package->cl-source-package sbcl-cl-locale)) - -(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)))) - -(define-public ecl-cl-slice - (sbcl-package->ecl-package sbcl-cl-slice)) - -(define-public cl-slice - (sbcl-package->cl-source-package sbcl-cl-slice)) - -(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)))) - -(define-public ecl-djula - (sbcl-package->ecl-package sbcl-djula)) - -(define-public cl-djula - (sbcl-package->cl-source-package sbcl-djula)) - -(define-public sbcl-for - (let ((commit "a39782991292e44ee3b5e2e25cddaa8115f6d363") - (revision "1")) - (package - (name "sbcl-for") - (version (git-version "1.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/for") - (commit commit))) - (file-name (git-file-name "cl-for" version)) - (sha256 - (base32 "07jdwqkyb3qd65mng60cs723z7p0bv2769hhalz4c0mfzn8qrn99")))) - (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") - (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)))) - -(define-public ecl-for - (sbcl-package->ecl-package sbcl-for)) - -(define-public cl-for - (sbcl-package->cl-source-package sbcl-for)) - -(define-public sbcl-flare - (let ((commit "4f9f17a4fc5b368c2a1988b9a20288695b8d8c48") - (revision "1")) - (package - (name "sbcl-flare") - (version (git-version "1.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/flare") - (commit commit))) - (file-name (git-file-name "flare" version)) - (sha256 - (base32 "00nm3sjngbflj2gd5q0xs2m136w4kix6krww23nk64pkkyq2fs86")))) - (build-system asdf-build-system/sbcl) - (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") - (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)))) - -(define-public ecl-flare - (sbcl-package->ecl-package sbcl-flare)) - -(define-public cl-flare - (sbcl-package->cl-source-package sbcl-flare)) - -(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 ecl-simple-inferiors - (sbcl-package->ecl-package sbcl-simple-inferiors)) - -(define-public cl-simple-inferiors - (sbcl-package->cl-source-package sbcl-simple-inferiors)) - -(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)))) - -(define-public ecl-metacopy - (sbcl-package->ecl-package sbcl-metacopy)) - -(define-public cl-metacopy - (sbcl-package->cl-source-package sbcl-metacopy)) - -(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)))) - -(define-public ecl-legit - (sbcl-package->ecl-package sbcl-legit)) - -(define-public cl-legit - (sbcl-package->cl-source-package sbcl-legit)) - -(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. - -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)))) - -(define-public ecl-flow - (sbcl-package->ecl-package sbcl-flow)) - -(define-public cl-flow - (sbcl-package->cl-source-package sbcl-flow)) - -(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") + ("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-restas + (sbcl-package->cl-source-package sbcl-restas)) + +(define-public ecl-restas + (sbcl-package->ecl-package sbcl-restas)) + +(define-public sbcl-retrospectiff + (let ((commit "2fbf8c687799487654d988c7036d19d75a7fc67d") + (revision "1")) + (package + (name "sbcl-retrospectiff") + (version (git-version "0.2" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/slyrus/retrospectiff") + (commit commit))) + (file-name (git-file-name "cl-retrospectiff" version)) + (sha256 + (base32 "1vfcbfzhkm2wkxnjg7y6gg93wlib9cqpbdbhyqcm5kc7170ci3vz")))) + (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") (description - "This package provides a Common Lisp bindings to @code{glfw}, an OpenGL -application development library.") + "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 ecl-cl-glfw3 - (sbcl-package->ecl-package sbcl-cl-glfw3)) +(define-public cl-retrospectif + (sbcl-package->cl-source-package sbcl-retrospectiff)) -(define-public cl-glfw3 - (sbcl-package->cl-source-package sbcl-cl-glfw3)) +(define-public ecl-retrospectiff + (sbcl-package->ecl-package sbcl-retrospectiff)) -(define-public sbcl-cl-gltf - (let ((commit "7a3af05a7f491d8973b217f096806ef12a97474b") +(define-public sbcl-rfc2388 + (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e") (revision "1")) (package - (name "sbcl-cl-gltf") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/cl-gltf") - (commit commit))) - (file-name (git-file-name "cl-gltf" version)) - (sha256 - (base32 "1d64fg2l2c0wns3wpp1xypd8687gnp3k70fv9fb48m1kpzg4kvrh")))) - (build-system asdf-build-system/sbcl) - (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 package provides a Common Lisp parser for glTF file format.") - (license license:zlib)))) - -;; 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 #. -;; -;; See -;; -;; (define-public ecl-cl-gltf -;; (sbcl-package->ecl-package sbcl-cl-gltf)) - -(define-public cl-gltf - (sbcl-package->cl-source-package sbcl-cl-gltf)) - -(define-public sbcl-chirp - (let ((commit "01c79fa41939688216d1f86d0766a687becb0654") - (revision "1")) - (package - (name "sbcl-chirp") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/chirp") - (commit commit))) - (file-name (git-file-name "chirp" version)) - (sha256 - (base32 "10xlz1vwdv3jv48kmpndpnrg6672m0r5vsjgm2pksfl8bc05j2m0")))) - (build-system asdf-build-system/sbcl) - (arguments - `(#:asd-systems '("chirp-core" "chirp-dexador" "chirp-drakma" "chirp"))) - (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") - (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") + (name "sbcl-rfc2388") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/cbaggers/cepl") + (url "https://github.com/jdz/rfc2388") (commit commit))) - (file-name (git-file-name "cepl" version)) + (file-name (git-file-name "rfc2388" version)) (sha256 - (base32 "0izbw2advqm3wailj3dpq6zqfrfirwn14pw5qmqh8i71r51xwmm2")))) + (base32 "0phh5n3clhl9ji8jaxrajidn22d3f0aq87mlbfkkxlnx2pnw694k")))) (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") + (home-page "https://github.com/jdz/rfc2388/") + (synopsis "Implementation of RFC 2388 in Common Lisp") (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.") + "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 ecl-cepl - (sbcl-package->ecl-package sbcl-cepl)) +(define-public cl-rfc2388 + (sbcl-package->cl-source-package sbcl-rfc2388)) -(define-public cl-cepl - (sbcl-package->cl-source-package sbcl-cepl)) +(define-public ecl-rfc2388 + (sbcl-package->ecl-package sbcl-rfc2388)) -(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-routes + (let ((commit "1b79e85aa653e1ec87e21ca745abe51547866fa9") + (revision "1")) (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)))) - -(define-public ecl-stmx - (sbcl-package->ecl-package sbcl-stmx)) - -(define-public cl-stmx - (sbcl-package->cl-source-package sbcl-stmx)) - -(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 - (method git-fetch) - (uri (git-reference - (url "https://github.com/phoe/binding-arrows") - (commit commit))) - (file-name (git-file-name "cl-binding-arrows" 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)))) - -(define-public ecl-binding-arrows - (sbcl-package->ecl-package sbcl-binding-arrows)) - -(define-public cl-binding-arrows - (sbcl-package->cl-source-package sbcl-binding-arrows)) - -(define-public sbcl-atomics - ;; No release in years. - (let ((commit "b7477024894e322bff9c85e6d81e5e8d1d4eae59") - (revision "2")) - (package - (name "sbcl-atomics") - (version (git-version "1.0.0" revision commit)) + (name "sbcl-routes") + (version (git-version "0.2.5" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shinmera/atomics") + (url "https://github.com/archimag/cl-routes") (commit commit))) - (file-name (git-file-name "cl-atomics" version)) + (file-name (git-file-name "cl-routes" version)) (sha256 - (base32 "1ah6fgvfva0axnhj4sp1qy6gjyw41fkhpnv998di0wbp6hls8j39")))) + (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 + `(("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)))) + +(define-public cl-routes + (sbcl-package->cl-source-package sbcl-routes)) + +(define-public ecl-routes + (sbcl-package->ecl-package sbcl-routes)) + +(define-public sbcl-rss + ;; No release. + (let ((commit "51d0145e91b86327ae5c36364f9c3048052e7a58")) + (package + (name "sbcl-rss") + (version (git-version "0.9.1.1" "2" 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)))) (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-aserve sbcl-kmrcl sbcl-xmls)) + (home-page "https://github.com/nsrahmad/cl-rss") + (synopsis "Common Lisp RSS processor") (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 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-atomics - (sbcl-package->ecl-package sbcl-atomics)) +(define-public cl-rss + (sbcl-package->cl-source-package sbcl-rss)) -(define-public cl-atomics - (sbcl-package->cl-source-package sbcl-atomics)) - -(define-public sbcl-cl-murmurhash - ;; No release. - (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364") +(define-public sbcl-rtg-math + (let ((commit "29fc5b3d0028a4a11a82355ecc8cca62662c69e0") (revision "1")) (package - (name "sbcl-cl-murmurhash") + (name "sbcl-rtg-math") (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/cbaggers/rtg-math") + (commit commit))) + (file-name (git-file-name "rtg-math" version)) + (sha256 + (base32 "0bhxxnv7ldkkb18zdxyz2rj2a3iawzq2kcp7cn5i91iby7n0082x")))) + (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") + (description + "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-rtg-math + (sbcl-package->cl-source-package sbcl-rtg-math)) + +(define-public ecl-rtg-math + (sbcl-package->ecl-package sbcl-rtg-math)) + +(define-public sbcl-rucksack + (let ((commit "89278f88513ef328d290aa8b2baa06d63b44a9b1") + (revision "0")) + (package + (name "sbcl-rucksack") + (version (git-version "0.1.20" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/arieltan/rucksack") + (commit commit))) + (file-name (git-file-name "cl-rucksack" 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)))) + +(define-public cl-rucksack + (sbcl-package->cl-source-package sbcl-rucksack)) + +(define-public sbcl-rutils + (let ((commit "db3c3f4ae897025b5f0cd81042ca147da60ca0c5") + (revision "0")) + (package + (name "sbcl-rutils") + (version (git-version "5.2.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/vseloved/rutils") + (commit commit))) + (file-name (git-file-name "rutils" version)) + (sha256 + (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 + `(("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-rutils + (sbcl-package->cl-source-package sbcl-rutils)) + +(define-public ecl-rutils + (sbcl-package->ecl-package sbcl-rutils)) + +(define-public sbcl-s-sysdeps + ;; No release since 2013. + (let ((commit "7f8de283b7fbd8b038fdf08493063a736db36ce7") + (revision "3")) + (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") (source (origin (method git-fetch) @@ -22954,327 +24952,314 @@ implementations offer.") (file-name (git-file-name name version)) (sha256 (base32 - "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws")))) - (build-system asdf-build-system/sbcl) + "0rp81iq0rgl48qdwbmfy89glga81hmry2lp8adjbr5h5ybr92b4n")))) (inputs - (list sbcl-babel)) - (native-inputs - (list sbcl-fiveam)) - (synopsis "32-bit version of Murmurhash3 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)))) + (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 ecl-cl-murmurhash - (sbcl-package->ecl-package sbcl-cl-murmurhash)) +@code{s-sysdeps} abstracts: -(define-public cl-murmurhash - (sbcl-package->cl-source-package sbcl-cl-murmurhash)) +@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-cl-hamt - ;; No release - (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208")) - (package - (name "sbcl-cl-hamt") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/danshapero/cl-hamt/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5")))) - (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") - (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-s-sysdeps + (sbcl-package->cl-source-package sbcl-s-sysdeps)) -(define-public ecl-cl-hamt - (sbcl-package->ecl-package sbcl-cl-hamt)) +(define-public ecl-s-sysdeps + (sbcl-package->ecl-package sbcl-s-sysdeps)) -(define-public cl-hamt - (sbcl-package->cl-source-package sbcl-cl-hamt)) - -(define-public sbcl-cl-gserver +(define-public sbcl-s-xml (package - (name "sbcl-cl-gserver") - (version "1.8.0") + (name "sbcl-s-xml") + (version "3") (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)) + (method url-fetch) + (uri "https://common-lisp.net/project/s-xml/s-xml.tgz") (sha256 - (base32 "1bfz7z8v417dvsp1jz76ir3ihcs8g7zis2d56xx1dpzqzjd95g7z")))) + (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-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") + (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 - "@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))) + "S-XML-RPC is an implementation of XML-RPC in Common Lisp for both +client and server.") + (license license:lgpl3+))) -(define-public ecl-cl-gserver - (sbcl-package->ecl-package sbcl-cl-gserver)) +(define-public cl-s-xml-rpc + (sbcl-package->cl-source-package sbcl-s-xml-rpc)) -(define-public cl-gserver - (sbcl-package->cl-source-package sbcl-cl-gserver)) +(define-public ecl-s-xml-rpc + (sbcl-package->ecl-package sbcl-s-xml-rpc)) -(define-public sbcl-assoc-utils - (let ((commit "74af16a3c0f10ad35e406167de02984744fc7854") - (revision "1")) +(define-public sbcl-safe-read + (let ((commit "d25f08597b34d7aaeb86b045d57f7b020a5bb5f0") + (revision "0")) (package - (name "sbcl-assoc-utils") + (name "sbcl-safe-read") (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/fukamachi/assoc-utils") + (url "https://github.com/phoe/safe-read") (commit commit))) - (file-name (git-file-name "cl-assoc-utils" version)) + (file-name (git-file-name "cl-safe-read" version)) (sha256 - (base32 "1yac1v7zmdxj0p6rvwrrhyqvy7yjfhmqbchkwqhhr89gpjvvaick")))) + (base32 "1r9k8danfnqgpbn2vb90n6wdc6jd92h1ig565yplrbh6232lhi26")))) (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") + (inputs + (list sbcl-local-time sbcl-trivial-garbage)) + (home-page "https://github.com/phoe/safe-read/") + (synopsis "Safer variant of READ") (description - "@code{assoc-utils} provides utilities for manipulating association -lists in Common Lisp.") - (license license:public-domain)))) + "This package provides a safer variant of @code{READ} secure against +internbombing, excessive input and macro characters.") + (license license:bsd-2)))) -(define-public cl-assoc-utils - (sbcl-package->cl-source-package sbcl-assoc-utils)) +(define-public cl-safe-read + (sbcl-package->cl-source-package sbcl-safe-read)) -(define-public ecl-assoc-utils - (sbcl-package->ecl-package sbcl-assoc-utils)) +(define-public ecl-safe-read + (sbcl-package->ecl-package sbcl-safe-read)) -(define-public sbcl-let-over-lambda - (let ((commit "481b2e3ab4646186451dfdd2062113203287d520") - (revision "1")) +(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-let-over-lambda") - (version (git-version "1.0.1" 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/thephoeron/let-over-lambda") + (url "https://github.com/nikodemus/sb-cga/") (commit commit))) - (file-name (git-file-name "cl-let-over-lambda" version)) + (file-name (git-file-name "cl-sb-cga" 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 - ;; #: - ;; Component LET-OVER-LAMBDA-ASD::LET-OVER-LAMBDA-TEST not found, - ;; required by # - `(#: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)))) - -(define-public cl-let-over-lambda - (sbcl-package->cl-source-package sbcl-let-over-lambda)) - -(define-public ecl-let-over-lambda - (sbcl-package->ecl-package sbcl-let-over-lambda)) - -(define-public sbcl-flute - (let ((commit "90ebcd6e82f637f49b6de7d625ccc51ec4c92900") - (revision "1")) - (package - (name "sbcl-flute") - (version (git-version "0.2-dev" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ailisp/flute") - (commit commit))) - (file-name (git-file-name "cl-flute" version)) - (sha256 - (base32 "0q8jhp040cvpppyn820mm6a550yfxyr1lar298x13c42mm807f4f")))) + (base32 "1y54qlwfrhch9aghk7nsbdx7x2qsvgsws1g2k631l9dsgdakw4w8")))) (build-system asdf-build-system/sbcl) (inputs - (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") + (list sbcl-alexandria)) + (home-page "https://github.com/nikodemus/sb-cga/") + (synopsis "Computer graphic algebra for Common Lisp") (description - "Flute is an easily composable HTML5 generation library in Common -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-flute - (sbcl-package->cl-source-package sbcl-flute)) +(define-public cl-sb-cga + (sbcl-package->cl-source-package sbcl-sb-cga)) -(define-public ecl-flute - (sbcl-package->ecl-package sbcl-flute)) +(define-public ecl-sb-cga + (sbcl-package->ecl-package sbcl-sb-cga)) -(define-public sbcl-cl-posix-mqueue - (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f") +(define-public sbcl-schemeish + (let ((commit "dff57bafae5d0cffa104c8fdc4146502f32d7f85") (revision "1")) (package - (name "sbcl-cl-posix-mqueue") - (version (git-version "0.1.2" 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/xFA25E/cl-posix-mqueue") + (url "https://github.com/chebert/schemeish") (commit commit))) - (file-name (git-file-name "cl-posix-mqueue" version)) + (file-name (git-file-name name version)) (sha256 - (base32 "04519rg8vc782z097dzlb8nx0skab2fy2zd0m60r6mz2nw8xdvh6")))) + (base32 "0q9b07spmhg1b576cnnacvkf7zr3mab2rdydfylbn92y9mms9vyj")))) (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 - `(("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") + (list sbcl-trivial-arguments)) + (synopsis "Scheme style syntax/macros/functions for 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)))) - -(define-public ecl-cl-posix-mqueue - (sbcl-package->ecl-package sbcl-cl-posix-mqueue)) - -(define-public cl-posix-mqueue - (sbcl-package->cl-source-package sbcl-cl-posix-mqueue)) - -(define-public sbcl-glop - (let ((commit "45e722ab4a0cd2944d550bf790206b3326041e38") - (revision "1")) - (package - (name "sbcl-glop") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lispgames/glop") - (commit commit))) - (file-name (git-file-name "glop" version)) - (sha256 - (base32 "1nm35kvigflfjlmsa8zwdajc61f02fh4sq08jv0wnqylhx8yg2bv")))) - (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") - (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.") + "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 ecl-glop - (sbcl-package->ecl-package sbcl-glop)) +(define-public cl-schemeish + (sbcl-package->cl-source-package sbcl-schemeish)) -(define-public cl-glop - (sbcl-package->cl-source-package sbcl-glop)) +(define-public ecl-schemeish + (sbcl-package->ecl-package sbcl-schemeish)) + +(define-public sbcl-screamer + (let ((commit "ce50614024de090b376107668da5e53232540ec7")) + (package + (name "sbcl-screamer") + (version (git-version "0.0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/nikodemus/screamer/") + (commit commit))) + (file-name (git-file-name "cl-screamer" version)) + (sha256 + (base32 "1jl42pl6kwkiq71d0naf3r1mn1qy89ndimfgiz58c4g66xbjb7kx")))) + (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") + (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)))) + +(define-public cl-screamer + (sbcl-package->cl-source-package sbcl-screamer)) + +(define-public ecl-screamer + (sbcl-package->ecl-package sbcl-screamer)) + +(define-public sbcl-sdf + ;; Shinmera's fork required for Alloy. + (let ((commit "e1ab3ac4ea52c0e0119b832f428c71f580b4d83b") + (revision "1")) + (package + (name "sbcl-sdf") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/sdf") + (commit commit))) + (file-name (git-file-name "sdf" version)) + (sha256 + (base32 "1cyq4hkgiw9mnb87ah6xw19cybfs9hfbjvg1ch2mf4cr0ism0nvn")))) + (build-system asdf-build-system/sbcl) + (inputs + (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 + "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-sdf + (sbcl-package->cl-source-package sbcl-sdf)) + +(define-public ecl-sdf + (sbcl-package->ecl-package sbcl-sdf)) (define-public sbcl-sdl2 (let ((commit "80410b514570ca06894675d4a2a5fc93287ea7b6") @@ -23316,12 +25301,12 @@ except system libraries.") C Library.") (license license:expat)))) -(define-public ecl-sdl2 - (sbcl-package->ecl-package sbcl-sdl2)) - (define-public cl-sdl2 (sbcl-package->cl-source-package sbcl-sdl2)) +(define-public ecl-sdl2 + (sbcl-package->ecl-package sbcl-sdl2)) + (define-public sbcl-sdl2-image (let ((commit "9c05c806286b66a5d9861ef829cfe68c4f3da077") (revision "1")) @@ -23358,11 +25343,45 @@ C Library.") "This is a (currently) brief but usable wrap for SDL2_image.") (license license:expat)))) +(define-public cl-sdl2-image + (sbcl-package->cl-source-package sbcl-sdl2-image)) + (define-public ecl-sdl2-image (sbcl-package->ecl-package sbcl-sdl2-image)) -(define-public cl-sdl2-image - (sbcl-package->cl-source-package sbcl-sdl2-image)) +(define-public sbcl-sdl2kit + (let ((commit "aae663224a10ece2b0c374aa5942a3f0bc1b3c2f")) + (package + (name "sbcl-sdl2kit") + (version (git-version "0.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/lispgames/sdl2kit/") + (commit commit))) + (file-name (git-file-name "cl-sdl2kit" version)) + (sha256 + (base32 "10ymmxqsvdn7ndda9k2qcixj75l7namgqdxc5y2w3v5r1313fy2d")))) + (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)))) + +(define-public cl-sdl2kit + (sbcl-package->cl-source-package sbcl-sdl2kit)) + +(define-public ecl-sdl2kit + (sbcl-package->ecl-package sbcl-sdl2kit)) (define-public sbcl-sdl2-mixer (let ((commit "fdcc7ee7935dd01fd338e22690451db2cf126156") @@ -23401,12 +25420,12 @@ C Library.") Library.") (license license:expat)))) -(define-public ecl-sdl2-mixer - (sbcl-package->ecl-package sbcl-sdl2-mixer)) - (define-public cl-sdl2-mixer (sbcl-package->cl-source-package sbcl-sdl2-mixer)) +(define-public ecl-sdl2-mixer + (sbcl-package->ecl-package sbcl-sdl2-mixer)) + (define-public sbcl-sdl2-ttf (let ((commit "6dd2df2fb3a79ec4f835e3bc882e60e8da039878") (revision "1")) @@ -23454,54 +25473,2493 @@ UNICODE, and Glyph text rendering is available only Latin text has been tested (as shown in the examples).") (license license:expat)))) -(define-public ecl-sdl2-ttf - (sbcl-package->ecl-package sbcl-sdl2-ttf)) - (define-public cl-sdl2-ttf (sbcl-package->cl-source-package sbcl-sdl2-ttf)) -(define-public sbcl-cl-gamepad - (let ((commit "d5b99fbaa2e39294d23061699e8f1e761eda7205") - (revision "3")) +(define-public ecl-sdl2-ttf + (sbcl-package->ecl-package sbcl-sdl2-ttf)) + +(define-public sbcl-sealable-metaobjects + (let ((commit "e09ec97252e0844528f61abdc0c7ee256875f8ee")) (package - (name "sbcl-cl-gamepad") - (version (git-version "3.0.0" revision commit)) + (name "sbcl-sealable-metaobjects") + (version (git-version "0.0.0" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shirakumo/cl-gamepad") + (url "https://github.com/marcoheisig/sealable-metaobjects/") (commit commit))) - (file-name (git-file-name "cl-gamepad" version)) + (file-name (git-file-name "cl-sealable-metaobjects" version)) (sha256 - (base32 "0y6kg9wq92p07i1chm1v7j7p77iqc5c985pdvmmivcip8zmd4hm4")))) + (base32 "0hz1ivlpfhnk1w2cw4q2i000j2dc7maay06ndzziyywg7li6zf2p")))) + (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") + (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)))) + +(define-public cl-sealable-metaobjects + (sbcl-package->cl-source-package sbcl-sealable-metaobjects)) + +(define-public ecl-sealable-metaobjects + (sbcl-package->ecl-package sbcl-sealable-metaobjects)) + +(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)))) + +(define-public cl-seedable-rng + (sbcl-package->cl-source-package sbcl-seedable-rng)) + +(define-public ecl-seedable-rng + (sbcl-package->ecl-package sbcl-seedable-rng)) + +(define-public sbcl-select + (let ((commit "df7920fc451b6d15345040ce4a3ee1ea2818ab1a") + (revision "0")) + (package + (name "sbcl-select") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Lisp-Stat/select") + (commit commit))) + (file-name (git-file-name "cl-select" version)) + (sha256 + (base32 "0bhpvfqp7n33pia4y62qi31bx86gjl2nxjy529rfawac57c9rxv3")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-alexandria + sbcl-anaphora + sbcl-let-plus)) + (native-inputs + (list sbcl-fiveam)) + (home-page "https://lisp-stat.github.io/select/") + (synopsis "Library for taking slices from array-like objects") + (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-serapeum + (let ((commit "c08442a9757b7fa30ac345cb040e1642f97f6b78") + (revision "12")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1sabd048agvgv7bhbw126rci9hf45fk08zhghcv6an2h6xwmc3qv")))) + (build-system asdf-build-system/sbcl) + (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") + (description + "Serapeum is a conservative library of Common Lisp utilities. It is a +supplement, not a competitor, to Alexandria.") + (license license:expat)))) + +(define-public cl-serapeum + (sbcl-package->cl-source-package sbcl-serapeum)) + +(define-public ecl-serapeum + (sbcl-package->ecl-package sbcl-serapeum)) + +(define-public sbcl-series + (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a") + (revision "1")) + (package + (name "sbcl-series") + (version (git-version "2.2.11" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "git://git.code.sf.net/p/series/series") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw")))) (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") + ;; 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 - "This is a library to provide cross-platform access to gamepads, -joysticks, and other such HID devices.") + "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)))) + +(define-public cl-series + (sbcl-package->cl-source-package sbcl-series)) + +(define-public ecl-series + (sbcl-package->ecl-package sbcl-series)) + +(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)))) + +(define-public cl-sha1 + (sbcl-package->cl-source-package sbcl-sha1)) + +(define-public ecl-sha1 + (sbcl-package->ecl-package sbcl-sha1)) + +(define-public sbcl-shadow + (let ((commit "b2031adbfba3579b48c9d39ad997e19b79b6852f") + (revision "1")) + (package + (name "sbcl-shadow") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://git.mfiano.net/mfiano/shadow") + (commit commit))) + (file-name (git-file-name "shadow" version)) + (sha256 + (base32 "0w1i734gkdkziin74ql2nhx7jdjxx02ylssaa6qdrvnj4br1124a")))) + (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") + (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).") + (license license:expat)))) + +(define-public cl-shadow + (sbcl-package->cl-source-package sbcl-shadow)) + +(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-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 cl-shasht + (sbcl-package->cl-source-package sbcl-shasht)) + +(define-public ecl-shasht + (sbcl-package->ecl-package sbcl-shasht)) + +(define-public sbcl-shlex + (let ((commit "3dee1cb7c0140fa7660ca7a3b2ac5e75d1218e5c") + (revision "2")) + (package + (name "sbcl-shlex") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/cl-shlex") + (commit commit))) + (file-name (git-file-name "cl-shlex" version)) + (sha256 + (base32 "16ag48sswgimr1fzr582vhym4s03idpd4lkydw5s58lv80ibpim8")))) + (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)))) + +(define-public ecl-shlex + (sbcl-package->ecl-package sbcl-shlex)) + +(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-simple-date-time") + (version (git-version "0.1.0" 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)) + (sha256 + (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-simple-date-time + (sbcl-package->cl-source-package sbcl-simple-date-time)) + +(define-public ecl-simple-date-time + (sbcl-package->ecl-package sbcl-simple-date-time)) + +(define-public sbcl-simple-guess + (let ((commit "34744e3200a96e6aba285d70f91cdbd6c25508a6") + (revision "0")) + (package + (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/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 ecl-cl-gamepad - (sbcl-package->ecl-package sbcl-cl-gamepad)) +(define-public cl-simple-inferiors + (sbcl-package->cl-source-package sbcl-simple-inferiors)) -(define-public cl-gamepad - (sbcl-package->cl-source-package sbcl-cl-gamepad)) +(define-public ecl-simple-inferiors + (sbcl-package->ecl-package sbcl-simple-inferiors)) + +(define-public sbcl-simple-neural-network + (package + (name "sbcl-simple-neural-network") + (version "3.1") + (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)) + (sha256 + (base32 "1jj1c90fr5clwka0jv32hv6xp1bkdlpa6x5jh19an13rhx8ll4zr")))) + (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+))) + +(define-public cl-simple-neural-network + (sbcl-package->cl-source-package sbcl-simple-neural-network)) + +(define-public ecl-simple-neural-network + (sbcl-package->ecl-package sbcl-simple-neural-network)) + +(define-public sbcl-simple-parallel-tasks + (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6") + (revision "1")) + (package + (name "sbcl-simple-parallel-tasks") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://codeberg.org/glv/simple-parallel-tasks") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7")))) + (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)))) + +(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 + "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 ecl-simple-rgb + (sbcl-package->ecl-package sbcl-simple-rgb)) + +(define-public cl-simple-rgb + (sbcl-package->cl-source-package sbcl-simple-rgb)) + +(define-public sbcl-simple-routes + (let ((commit "6f88c38945a4de73e85786d3499c39cacb400598") + (revision "1")) + (package + (name "sbcl-simple-routes") + (version (git-version "0.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.com/vancan1ty/simple-routes") + (commit commit))) + (file-name (git-file-name "cl-simple-routes" version)) + (sha256 + (base32 "0zkjl69zf1ynmqmvwccdbip3wxfyi7xplivv70qwxzd27mc0kh3k")))) + (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)) + +(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-simple-tasks + (sbcl-package->cl-source-package sbcl-simple-tasks)) + +(define-public ecl-simple-tasks + (sbcl-package->ecl-package sbcl-simple-tasks)) + +(define-public sbcl-simplified-types + (let ((commit "8fd0727a70a9de76289ac62c1567b8d278e7434e") + (revision "0")) + (package + (name "sbcl-simplified-types") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/marcoheisig/simplified-types") + (commit commit))) + (file-name (git-file-name "cl-simplified-types" version)) + (sha256 + (base32 "1hdwmn5lz717aj6qdqmfmr3cbjl8l3giwn0fb5ca9pj83cx7fg8y")))) + (build-system asdf-build-system/sbcl) + (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") + (license license:expat)))) + +(define-public cl-simplified-types + (sbcl-package->cl-source-package sbcl-simplified-types)) + +(define-public ecl-simplified-types + (sbcl-package->ecl-package sbcl-simplified-types)) + +(define-public sbcl-sketch + ;; No release in years. + (let ((commit "4cc00b08e202c7adda41391463096cf9df1705c3")) + (package + (name "sbcl-sketch") + (version (git-version "2017-11" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/vydd/sketch") + (commit commit))) + (file-name (git-file-name "cl-sketch" version)) + (sha256 + (base32 "1qrnma8yvmxps9rz3pvlzsir37namppsldijdlr4110pcwi9j9h6")))) + (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") + (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)) + +(define-public ecl-sketch + (sbcl-package->ecl-package sbcl-sketch)) + +(define-public sbcl-skippy + (let ((commit "e456210202ca702c792292c5060a264d45e47090") + (revision "0")) + (package + (name "sbcl-skippy") + (version (git-version "1.3.12" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/xach/skippy") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj")))) + (build-system asdf-build-system/sbcl) + (home-page "https://xach.com/lisp/skippy/") + (synopsis "Common Lisp library for GIF images") + (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)) + +(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-slime-swank + (sbcl-package->cl-source-package sbcl-slime-swank)) + +(define-public ecl-slime-swank + (sbcl-package->ecl-package sbcl-slime-swank)) + +(define-public sbcl-slite + (let ((commit "942a95330592d30be5ac02fb1b697fb14ccbf1af") + (revision "0")) + (package + (name "sbcl-slite") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/tdrhq/slite/") + (commit commit))) + (file-name (git-file-name "slite" version)) + (sha256 + (base32 "0b4c4vs1zlhcvr9flv8bx76v9hrwc9qmazmp60407q7cghn0k8zk")))) + (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 ") + (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-slot-extra-options + (let ((commit "29517d980325cd63744f1acf4cfe5c8ccec2b318")) + (package + (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/some-mthfka/slot-extra-options/") + (commit commit))) + (file-name (git-file-name "cl-slot-extra-options" version)) + (sha256 + (base32 "1b2swhjjs0w1034cy045q8l3ndmci7rjawka39q23vncy6d90497")))) + (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") + (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+)))) + +(define-public cl-slot-extra-options + (sbcl-package->cl-source-package sbcl-slot-extra-options)) + +(define-public ecl-slot-extra-options + (sbcl-package->ecl-package sbcl-slot-extra-options)) + +(define-public sbcl-slynk + ;; Update together with emacs-sly. + (let ((commit "9c43bf65b967e12cef1996f1af5f0671d8aecbf4") + (revision "9")) + (package + (name "sbcl-slynk") + (version (git-version "1.0.43" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/joaotavora/sly") + (commit commit))) + (sha256 + (base32 "15nyr02ykkws4q79jcmxcawddg8sgq9v5l8k7jv7gg3hnpzxjlb2")) + (file-name (git-file-name "cl-slynk" version)))) + (build-system asdf-build-system/sbcl) + (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-slynk + (sbcl-package->cl-source-package sbcl-slynk)) + +(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-smart-buffer + (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62") + (revision "1")) + (package + (name "sbcl-smart-buffer") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/fukamachi/smart-buffer") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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-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)))) + +(define-public cl-smart-buffer + (sbcl-package->cl-source-package sbcl-smart-buffer)) + +(define-public ecl-smart-buffer + (sbcl-package->ecl-package sbcl-smart-buffer)) + +(define-public sbcl-smug + (let ((commit "647a2428df297e1dd183ba7c19574bdb1320ae79") + (revision "0")) + (package + (name "sbcl-smug") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/drewc/smug") + (commit commit))) + (file-name (git-file-name "cl-smug" 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)))) + +(define-public cl-smug + (sbcl-package->cl-source-package sbcl-smug)) + +(define-public ecl-smug + (sbcl-package->ecl-package sbcl-smug)) + +(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)))) + (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") + (description + "This package provides Python style generators for Common Lisp. +It also includes a port of itertools.") + (license license:asl2.0)))) + +(define-public cl-snakes + (sbcl-package->cl-source-package sbcl-snakes)) + +(define-public ecl-snakes + (sbcl-package->ecl-package sbcl-snakes)) + +(define-public sbcl-spatial-trees + ;; There have been no releases. + (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba") + (revision "1")) + (package + (name "sbcl-spatial-trees") + (version (git-version "0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rpav/spatial-trees") + (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-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 + "Spatial-trees is a set of dynamic index data structures for +spatially-extended data.") + (license license:bsd-3)))) + +(define-public cl-spatial-trees + (sbcl-package->cl-source-package sbcl-spatial-trees)) + +(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-specialization-store + (let ((commit "8d39a866a6f24986aad3cc52349e9cb2653496f3") + (revision "1")) + (package + (name "sbcl-specialization-store") + (version (git-version "0.0.5" 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)) + (sha256 + (base32 "0r0bgb46q4gy72l78s7djkxq8ibb4bb3yh9brsry5lih7br8lhi0")))) + (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") + (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)))) + +(define-public cl-specialization-store + (sbcl-package->cl-source-package sbcl-specialization-store)) + +(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-specialized-function + (let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247") + (revision "3")) + (package + (name "sbcl-specialized-function") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/numcl/specialized-function") + (commit commit))) + (file-name (git-file-name "specialized-function" version)) + (sha256 + (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 + `(("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-fiveam))))) + +(define-public cl-specialized-function + (sbcl-package->cl-source-package sbcl-specialized-function)) + +(define-public ecl-specialized-function + (sbcl-package->ecl-package sbcl-specialized-function)) + +(define-public sbcl-speechless + (let ((commit "50e9b03bdfc8a3bc0836a650d92de47b51c39834") + (revision "1")) + (package + (name "sbcl-speechless") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shirakumo/speechless/") + (commit commit))) + (sha256 + (base32 "1k0kc2l98jyv04l48xnj38qwpddan80c7m41srjld64jkna0fhas")) + (file-name (git-file-name "speechless" version)))) + (build-system asdf-build-system/sbcl) + (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)) + +(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-spinneret") + (version (git-version "3.0" "6" commit)) + (source + (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) + (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 + "In the crowded space of Common Lisp HTML generators, Spinneret +occupies the following coordinates: + +@itemize + +@item Modern. Targets HTML5. Does not treat XML and HTML as the same +problem. Assumes you will be serving your documents as UTF-8. + +@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-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-st-json + (let ((commit "4a0025bcc5b6921454822f1b9f38f697b4eeaf43") + (revision "0")) + (package + (name "sbcl-st-json") + (version (git-version "0.0.0" revision commit)) + (source + (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) + (home-page "https://marijnhaverbeke.nl/st-json/") + (synopsis "JSON 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)))) + +(define-public cl-st-json + (sbcl-package->cl-source-package sbcl-st-json)) + +(define-public ecl-st-json + (sbcl-package->ecl-package sbcl-st-json)) + +(define-public sbcl-staple + (let ((commit "0ee8e25fe6fe8fa83b2a6c93d4febd468c3eaa4e") + (revision "1")) + (package + (name "sbcl-staple") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/staple/") + (commit commit))) + (sha256 + (base32 "0qf0if7py3n4rszg25lcavpsqikfz6k5dvcmh5q67y8x5r12i5m7")) + (file-name (git-file-name "staple" version)))) + (build-system asdf-build-system/sbcl) + (arguments + '(#: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. + +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-static-dispatch + (sbcl-package->cl-source-package sbcl-static-dispatch)) + +(define-public ecl-static-dispatch + (sbcl-package->ecl-package sbcl-static-dispatch)) + +(define-public sbcl-static-vectors + (package + (name "sbcl-static-vectors") + (version "1.8.9") + (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")))) + (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.") + (license license:expat))) + +(define-public cl-static-vectors + (sbcl-package->cl-source-package sbcl-static-vectors)) + +(define-public ecl-static-vectors + (sbcl-package->ecl-package sbcl-static-vectors)) + +(define-public sbcl-statistics + (let ((commit "94fc87a2bf81355a40ce3730b4ed77710ecfabaf") + (revision "0")) + (package + (name "sbcl-statistics") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Lisp-Stat/statistics") + (commit commit))) + (file-name (git-file-name "cl-statistics" version)) + (sha256 + (base32 "0is69w6iwh4hyzc5ndgb3i2331f677sa7kw5wy8pmx6hawbkgyir")))) + (build-system asdf-build-system/sbcl) + (native-inputs (list sbcl-clunit2)) + (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))))) + +(define-public cl-statistics + (sbcl-package->cl-source-package sbcl-statistics)) + +(define-public ecl-statistics + (sbcl-package->ecl-package sbcl-statistics)) + +(define-public sbcl-stdutils + (let ((commit "4a4e5a4036b815318282da5dee2a22825369137b") + (revision "0")) + (package + (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-stdutils + (sbcl-package->cl-source-package sbcl-stdutils)) + +(define-public ecl-stdutils + (sbcl-package->ecl-package sbcl-stdutils)) + +(define-public sbcl-stealth-mixin + (let ((commit "2f853fcead554221d4be3b10522b502ea729e944") + (revision "0")) + (package + (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-stealth-mixin + (sbcl-package->cl-source-package sbcl-stealth-mixin)) + +(define-public ecl-stealth-mixin + (sbcl-package->ecl-package sbcl-stealth-mixin)) + +(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-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)))) + +(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-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/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 cl-string-pokemonize + (sbcl-package->cl-source-package sbcl-string-pokemonize)) + +(define-public ecl-string-pokemonize + (sbcl-package->ecl-package sbcl-string-pokemonize)) + +(define-public sbcl-stripe + (let ((commit "b59631d21d63e101de6eb96b56941471504ba644") + (revision "0")) + (package + (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-stripe + (sbcl-package->cl-source-package sbcl-stripe)) + +(define-public ecl-stripe + (sbcl-package->ecl-package sbcl-stripe)) + +(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-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 ecl-swap-bytes + (sbcl-package->ecl-package sbcl-swap-bytes)) + +(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-sxql-composer + (let ((commit "2b2230cb01ae1b68e28921d99e4814046867fb75") + (revision "1")) + (package + (name "sbcl-sxql-composer") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/mmontone/sxql-composer") + (commit commit))) + (file-name (git-file-name "sxql-composer" version)) + (sha256 + (base32 "1agkrj3ymskzc3c7pxbrj123d1kygjqcls145m0ap3i07q96hh1r")))) + (build-system asdf-build-system/sbcl) + (inputs + (list sbcl-sxql)) + (synopsis "Build and compose SXQL queries dynamically") + (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)))) + +(define-public cl-sxql-composer + (sbcl-package->cl-source-package sbcl-sxql-composer)) + +(define-public ecl-sxql-composer + (sbcl-package->ecl-package sbcl-sxql-composer)) + +(define-public sbcl-sycamore + (let ((commit "fd2820fec165ad514493426dea209728f64e6d18")) + (package + (name "sbcl-sycamore") + (version "0.0.20120604") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ndantam/sycamore/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7")))) + (build-system asdf-build-system/sbcl) + (inputs + (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: + +@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-sycamore + (sbcl-package->cl-source-package sbcl-sycamore)) + +(define-public ecl-sycamore + (sbcl-package->ecl-package sbcl-sycamore)) + +(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 ecl-symbol-munger + (sbcl-package->ecl-package sbcl-symbol-munger)) + +(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)))) + +(define-public cl-system-load + (sbcl-package->cl-source-package sbcl-system-load)) + +(define-public ecl-system-load + (sbcl-package->ecl-package sbcl-system-load)) + +(define-public sbcl-system-locale + (let ((commit "4b334bc2fa45651bcaa28ae7d9331095d6bf0a17")) + (package + (name "sbcl-system-locale") + (version (git-version "1.0.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/system-locale/") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "00p5c053kmgq4ks6l9mxsqz6g3bjcybvkvj0bh3r90qgpkaawm1p")))) + (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") + (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)))) + +(define-public cl-system-locale + (sbcl-package->cl-source-package sbcl-system-locale)) + +(define-public ecl-system-locale + (sbcl-package->ecl-package sbcl-system-locale)) + +(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-tailrec + (sbcl-package->cl-source-package sbcl-tailrec)) + +(define-public ecl-tailrec + (sbcl-package->ecl-package sbcl-tailrec)) + +(define-public sbcl-tar + (let ((commit "7c6e07a10c93d9e311f087b5f6328cddd481669a") + (revision "0")) + (package + (name "sbcl-tar") + (version (git-version "0.2.3" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/cl-tar/cl-tar") + (commit commit))) + (file-name (git-file-name "cl-tar" version)) + (sha256 + (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 + '(#: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") + (description + "@code{cl-tar} is a Common Lisp library providing a high-level interface +for interacting with tar archives.") + (license license:expat)))) + +(define-public cl-tar + (sbcl-package->cl-source-package sbcl-tar)) + +(define-public ecl-tar + (sbcl-package->ecl-package sbcl-tar)) + +(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. + +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-tar-file + (sbcl-package->cl-source-package sbcl-tar-file)) + +(define-public ecl-tar-file + (sbcl-package->ecl-package sbcl-tar-file)) + +(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: + +@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-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-terminal-size + (sbcl-package->cl-source-package sbcl-terminal-size)) + +(define-public ecl-terminal-size + (sbcl-package->ecl-package sbcl-terminal-size)) + +(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)))) + +(define-public cl-terminfo + (sbcl-package->cl-source-package sbcl-terminfo)) + +(define-public ecl-terminfo + (sbcl-package->ecl-package sbcl-terminfo)) + +(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-terrable + (sbcl-package->cl-source-package sbcl-terrable)) + +(define-public ecl-terrable + (sbcl-package->ecl-package sbcl-terrable)) + +(define-public sbcl-the-cost-of-nothing + (let ((commit "f364029fbbf37ae5786f2f9ddf6185dd204a7185") + (revision "0")) + (package + (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/marcoheisig/the-cost-of-nothing") + (commit commit))) + (file-name (git-file-name "cl-the-cost-of-nothing" version)) + (sha256 + (base32 "1ccrglyr1wnnfp218w1qj7yfl4yzlxkki3hqaifi5axgbi5dmmh8")))) + (build-system asdf-build-system/sbcl) + (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 + "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-the-cost-of-nothing + (sbcl-package->cl-source-package sbcl-the-cost-of-nothing)) + +(define-public ecl-the-cost-of-nothing + (sbcl-package->ecl-package sbcl-the-cost-of-nothing)) + +(define-public sbcl-tooter + (let ((commit "2dcc2facddcacd79d0cce545a8c4b73c35826fc1") + (revision "4")) + (package + (name "sbcl-tooter") + (version (git-version "1.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/tooter") + (commit commit))) + (file-name (git-file-name "cl-tooter" version)) + (sha256 + (base32 "1zisrmslj4rnibm02vxh7hbas2cfsjh6iizs2nfdg3a3pn7bhf6h")))) + (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)))) + +(define-public cl-tooter + (sbcl-package->cl-source-package sbcl-tooter)) + +(define-public ecl-tooter + (sbcl-package->ecl-package sbcl-tooter)) + +(define-public sbcl-transmission + (let ((commit "4bbf1d2761bfa5dfa79b7bc12c3238089b994d95")) + (package + (name "sbcl-transmission") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/libre-man/cl-transmission/") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "0sg3f2jqs2z3mvscjhc43hkd34vlcc4c8hq8rhh5w1gjg19z57hb")))) + (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") + (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-transmission + (sbcl-package->cl-source-package sbcl-transmission)) + +(define-public ecl-transmission + (sbcl-package->ecl-package sbcl-transmission)) + +(define-public sbcl-trees + (let ((commit "7b06048af0248c4302088c758208276f9faf2beb")) + (package + (name "sbcl-trees") + (version (git-version "0.11" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/froydnj/trees/") + (commit commit))) + (file-name (git-file-name "cl-trees" version)) + (sha256 + (base32 "1xvydf3qc17rd7ia8sffxcpclgm3l0iyhx8k72ddk59v3pg5is4k")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/froydnj/trees/") + (synopsis "Binary trees in normal and balanced flavors") + (description + "This package implements binary trees of various kinds, presenting a +uniform interface to them all.") + (license license:bsd-3)))) + +(define-public cl-trees + (sbcl-package->cl-source-package sbcl-trees)) + +(define-public ecl-trees + (sbcl-package->ecl-package sbcl-trees)) + +(define-public sbcl-triads + (let ((commit "840b025bf3d65cc5eaead4542a02a3ca6d77c2b6") + (revision "0")) + (package + (name "sbcl-triads") + (version (git-version "0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/charJe/triads") + (commit commit))) + (file-name (git-file-name "cl-triads" version)) + (sha256 + (base32 "146mwshynhdw82m2nxrcjvf1nk0z3fn6ywcd2vqxkly5qricc53w")))) + (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"))))))) + (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-triads + (sbcl-package->cl-source-package sbcl-triads)) + +(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-trial (let ((commit "db4e98ede16640238bd51bf5d63cda57c75a51ae") @@ -23611,13 +28069,2059 @@ 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-trial + (sbcl-package->cl-source-package sbcl-trial)) + ;; 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-trial - (sbcl-package->cl-source-package sbcl-trial)) +(define-public sbcl-tripod + (let ((commit "b019a27cd7eb895870f84b0eb6c3edc5d7b05928") + (revision "1")) + (package + (name "sbcl-tripod") + (version (git-version "0.0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/aartaka/tripod") + (commit commit))) + (file-name (git-file-name "cl-tripod" version)) + (sha256 + (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-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 + "Tripod is a Common Lisp web server aiming to ease plain text, HTML, +and Gopher website hosting.") + (license license:bsd-2)))) + +(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-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)))))))) + +;;; 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-trivia.trivial") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/guicho271828/trivia") + (commit commit))) + (file-name (git-file-name "cl-trivia" version)) + (sha256 + (base32 + "0fnnjnba07qrsf82jm4q6dini7z72xabcssy5y2bqy082r07l8l7")))) + (build-system asdf-build-system/sbcl) + (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-trivia.trivial + (sbcl-package->cl-source-package sbcl-trivia.trivial)) + +(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-trivial-arguments + (let ((commit "ecd84ed9cf9ef8f1e873d7409e6bd04979372aa7") + (revision "1")) + (package + (name "sbcl-trivial-arguments") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/trivial-arguments") + (commit commit))) + (file-name (git-file-name "trivial-arguments" version)) + (sha256 + (base32 "02vaqfavhj8jqxnr68nnzvzshm8jbgcy6m9lvyv4daa6f7ihqf88")))) + (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") + (description + "This is a simple library to retrieve the argument list of a function.") + (license license:zlib)))) + +(define-public cl-trivial-arguments + (sbcl-package->cl-source-package sbcl-trivial-arguments)) + +(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 ecl-trivial-backtrace + (sbcl-package->ecl-package sbcl-trivial-backtrace)) + +(define-public sbcl-trivial-benchmark + (let ((commit "1fbc8d15f09ed8aa426bc73956b8b7c9b2668802") + (revision "2")) + (package + (name "sbcl-trivial-benchmark") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/trivial-benchmark/") + (commit commit))) + (file-name (git-file-name "cl-trivial-benchmark" 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)))) + +(define-public cl-trivial-benchmark + (sbcl-package->cl-source-package sbcl-trivial-benchmark)) + +(define-public ecl-trivial-benchmark + (sbcl-package->ecl-package sbcl-trivial-benchmark)) + +(define-public sbcl-trivial-channels + (let ((commit "e2370118d8983ba69c0360a7695f8f2e2fd6a8a6") + (revision "1")) + (package + (name "sbcl-trivial-channels") + (version (git-version "1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/rpav/trivial-channels") + (commit commit))) + (file-name (git-file-name "trivial-channels" version)) + (sha256 + (base32 "04wnxcgk40x8p0gxnz9arv1a5wasdqrdxa8c4p5v7r2mycfps6jj")))) + (build-system asdf-build-system/sbcl) + (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") + (description + "It's very basic implementation of channels and queue for Common Lisp.") + (license license:bsd-2)))) + +(define-public cl-trivial-channels + (sbcl-package->cl-source-package sbcl-trivial-channels)) + +(define-public ecl-trivial-channels + (sbcl-package->ecl-package sbcl-trivial-channels)) + +(define-public sbcl-trivial-clipboard + (let ((commit "aee67d6132a46237f61d508ae4bd9ff44032566d") + (revision "7")) + (package + (name "sbcl-trivial-clipboard") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/snmsts/trivial-clipboard") + (commit commit))) + (file-name (git-file-name "cl-trivial-clipboard" version)) + (sha256 + (base32 "029qmx523xfk54p99ndgbmdd20s5i32mzpf77xymngrn4c33v9jk")))) + (build-system asdf-build-system/sbcl) + (inputs + ;; Pick xsel instead of xclip because its closure size is slightly + ;; smaller. + (list wl-clipboard xsel)) + (native-inputs + (list sbcl-fiveam)) + (arguments + `(#: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 + "@command{trivial-clipboard} gives access to the system clipboard.") + (license license:expat)))) + +(define-public cl-trivial-clipboard + (sbcl-package->cl-source-package sbcl-trivial-clipboard)) + +(define-public ecl-trivial-clipboard + (sbcl-package->ecl-package sbcl-trivial-clipboard)) + +(define-public sbcl-trivial-cltl2 + (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61") + (revision "2")) + (package + (name "sbcl-trivial-cltl2") + (build-system asdf-build-system/sbcl) + (version (git-version "0.1.1" revision commit)) + (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "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-trivial-cltl2 + (sbcl-package->cl-source-package sbcl-trivial-cltl2)) + +(define-public ecl-trivial-cltl2 + (sbcl-package->ecl-package sbcl-trivial-cltl2)) + +(define-public sbcl-trivial-custom-debugger + (let ((commit "a560594a673bbcd88136af82086107ee5ff9ca81")) + (package + (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/phoe/trivial-custom-debugger") + (commit commit))) + (file-name (git-file-name "trivial-custom-debugger" version)) + (sha256 + (base32 "1iri5wsp9sc1f5q934cj87zd79r5dc8fda0gl7x1pz95v0wx28yk")))) + (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") + (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)))) + +(define-public cl-trivial-custom-debugger + (sbcl-package->cl-source-package sbcl-trivial-custom-debugger)) + +(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-trivial-do + (let ((commit "03a1729f1e71bad3ebcf6cf098a0cce52dfa1163")) + (package + (name "sbcl-trivial-do") + (version (git-version "0.1" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/yitzchak/trivial-do") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "1ffva79nkicc7wc8c2ic5nayis3b2rk5sxzj74yjkymkjgbpcrgd")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/yitzchak/trivial-do") + (synopsis "Additional dolist style macros for Common Lisp") + (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)))) + +(define-public cl-trivial-do + (sbcl-package->cl-source-package sbcl-trivial-do)) + +(define-public ecl-trivial-do + (sbcl-package->ecl-package sbcl-trivial-do)) + +(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-trivial-download + (sbcl-package->cl-source-package sbcl-trivial-download)) + +(define-public ecl-trivial-download + (sbcl-package->ecl-package sbcl-trivial-download)) + +(define-public sbcl-trivial-escapes + (let ((commit "1eca78da2078495d09893be58c28b3aa7b8cc4d1")) + (package + (name "sbcl-trivial-escapes") + (version (git-version "1.2.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/williamyaoh/trivial-escapes") + (commit commit))) + (file-name (git-file-name name commit)) + (sha256 + (base32 "0v6h8lk17iqv1qkxgqjyzn8gi6v0hvq2vmfbb01md3zjvjqxn6lr")))) + (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") + (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)))) + +(define-public cl-trivial-escapes + (sbcl-package->cl-source-package sbcl-trivial-escapes)) + +(define-public ecl-trivial-escapes + (sbcl-package->ecl-package sbcl-trivial-escapes)) + +(define-public sbcl-trivial-extensible-sequences + (let ((commit "d40b2da23716601578b1f645727047f80baeb49a") + (revision "0")) + (package + (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/Shinmera/trivial-extensible-sequences") + (commit commit))) + (file-name (git-file-name "cl-trivial-extensible-sequences" version)) + (sha256 + (base32 "0352psdd8j0phjycr6ldckwspyal4jcf0f2fizi6fwdp7nvadng7")))) + (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.") + (license license:zlib)))) + +(define-public cl-trivial-extensible-sequences + (sbcl-package->cl-source-package sbcl-trivial-extensible-sequences)) + +;; 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-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-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 home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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. + +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 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-trivial-garbage") + (version (git-version "0.21" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/trivial-garbage/trivial-garbage") + (commit commit))) + (file-name (git-file-name "cl-trivial-garbage" version)) + (sha256 + (base32 "0rfwxvwg0kpcaa0hsi035yrkfdfks4bq8d9azmrww2f0rmv9g6sd")))) + (build-system asdf-build-system/sbcl) + (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-trivial-garbage + (sbcl-package->cl-source-package sbcl-trivial-garbage)) + +(define-public ecl-trivial-garbage + (sbcl-package->ecl-package sbcl-trivial-garbage)) + +(define-public sbcl-trivial-gray-streams + (let ((revision "1") + (commit "2b3823edbc78a450db4891fd2b566ca0316a7876")) + (package + (name "sbcl-trivial-gray-streams") + (version (git-version "2.0" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url "https://github.com/trivial-gray-streams/trivial-gray-streams") + (commit commit))) + (sha256 + (base32 "1hipqwwd5ylskybd173rvlsk7ds4w4nq1cmh9952ivm6dgh7pwzn")) + (file-name (git-file-name "cl-trivial-gray-streams" version)))) + (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)))) + +(define-public cl-trivial-gray-streams + (sbcl-package->cl-source-package sbcl-trivial-gray-streams)) + +(define-public ecl-trivial-gray-streams + (sbcl-package->ecl-package sbcl-trivial-gray-streams)) + +(define-public sbcl-trivial-indent + (let ((commit "f25275094b80df8aa158af46db980bbc3ce2f88b") + (revision "1")) + (package + (name "sbcl-trivial-indent") + (version (git-version "1.0.0" revision 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)) + (sha256 + (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-trivial-indent + (sbcl-package->cl-source-package sbcl-trivial-indent)) + +(define-public ecl-trivial-indent + (sbcl-package->ecl-package sbcl-trivial-indent)) + +(define-public sbcl-trivial-macroexpand-all + (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9") + (revision "0")) + (package + (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 home-page) + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 + "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd")))) + (build-system asdf-build-system/sbcl) + (native-inputs + (list sbcl-fiveam)) + (synopsis "Portable macroexpand-all for Common Lisp") + (description + "This library provides a macroexpand-all function that calls the +implementation specific equivalent.") + (license license:unlicense)))) + +(define-public cl-trivial-macroexpand-all + (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all)) + +(define-public ecl-trivial-macroexpand-all + (sbcl-package->ecl-package sbcl-trivial-macroexpand-all)) + +(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)))) + +(define-public cl-trivial-main-thread + (sbcl-package->cl-source-package sbcl-trivial-main-thread)) + +(define-public ecl-trivial-main-thread + (sbcl-package->ecl-package sbcl-trivial-main-thread)) + +(define-public sbcl-trivial-mimes + (let ((commit "a741fc2f567a4f86b853fd4677d75e62c03e51d9") + (revision "2")) + (package + (name "sbcl-trivial-mimes") + (version (git-version "1.1.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/trivial-mimes") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (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-trivial-mimes + (sbcl-package->cl-source-package sbcl-trivial-mimes)) + +(define-public ecl-trivial-mimes + (sbcl-package->ecl-package sbcl-trivial-mimes)) + +(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-trivial-octet-streams + (let ((commit "bc5d398b18549fd42e9c2a365df28ad865f1b85d") + (revision "0")) + (package + (name "sbcl-trivial-octet-streams") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/sharplispers/trivial-octet-streams") + (commit commit))) + (file-name (git-file-name "cl-trivial-octet-streams" version)) + (sha256 + (base32 "0ysnsarlzynb7jf4b63b6kkxjancxc66jwmn0sb3vxyh87siiv6n")))) + (build-system asdf-build-system/sbcl) + (home-page "https://github.com/sharplispers/trivial-octet-streams") + (synopsis "In-memory octet streams for 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)) + +(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-trivial-open-browser") + (version (git-version "0.1" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/eudoxia0/trivial-open-browser") + (commit commit))) + (file-name (git-file-name "cl-trivial-open-browser" version)) + (sha256 + (base32 "0ixay1piq420i6adx642qhw45l6ik7rvgk52lyz27dvx5f8yqsdb")))) + (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") + (description + "This package provides a library to open a web browser to a URL.") + (license license:expat)))) + +(define-public cl-trivial-open-browser + (sbcl-package->cl-source-package sbcl-trivial-open-browser)) + +(define-public ecl-trivial-open-browser + (sbcl-package->ecl-package sbcl-trivial-open-browser)) + +(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-trivial-package-local-nicknames + (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames)) + +(define-public ecl-trivial-package-local-nicknames + (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames)) + +(define-public sbcl-trivial-raw-io + (let ((commit "b1a3c876305baa0dead419841de7b3e433a75867") + (revision "1")) + (package + (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/kingcons/trivial-raw-io") + (commit commit))) + (file-name (git-file-name "trivial-raw-io" version)) + (sha256 + (base32 "19290zw2b64k78wr62gv30pp7cmqg07q85vfwjknaffjdd73xwi1")))) + (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") + (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)) + +(define-public ecl-trivial-raw-io + (sbcl-package->ecl-package sbcl-trivial-raw-io)) + +(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)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/stacksmith/trivial-rfc-1123") + (commit commit))) + (file-name (git-file-name "cl-trivial-rfc-1123" version)) + (sha256 + (base32 "1w4ywpj10fnp7cya62dzlxlg8nyk4lppn2pnmfixsndwr4ib1h6x")))) + (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") + (description + "This package parses and prints dates in RFC-1123 format.") + (license license:bsd-3)))) + +(define-public cl-trivial-rfc-1123 + (sbcl-package->cl-source-package sbcl-trivial-rfc-1123)) + +(define-public ecl-trivial-rfc-1123 + (sbcl-package->ecl-package sbcl-trivial-rfc-1123)) + +(define-public sbcl-trivial-shell + (let ((commit "e02ec191b34b52deca5d1c4ee99d4fa13b8772e0")) + (package + (name "sbcl-trivial-shell") + (version (git-version "0.2.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/trivial-shell") + (commit commit))) + (file-name (git-file-name name version)) + (sha256 + (base32 "08mpkl5ij5sjfsyn8pq2kvsvpvyvr7ha1r8g1224fa667b8k2q85")))) + (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") + (description + "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-trivial-shell + (sbcl-package->cl-source-package sbcl-trivial-shell)) + +(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-trivial-timeout + (let ((commit "e70d9b4f7caeab83ea6ac50d724470fe49561e66") + (revision "2")) + (package + (name "sbcl-trivial-timeout") + (version (git-version "0.1.5" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/hraban/trivial-timeout") + (commit commit))) + (file-name (git-file-name "trivial-timeout" version)) + (sha256 + (base32 "0s8z9aj6b3kv21yiyk13cjylzf5zlnw9v86vcff477m1gk9yddjs")))) + (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") + (description + "This library provides an OS and implementation independent access to +timeouts.") + (license license:expat)))) + +(define-public cl-trivial-timeout + (sbcl-package->cl-source-package sbcl-trivial-timeout)) + +(define-public ecl-trivial-timeout + (sbcl-package->ecl-package sbcl-trivial-timeout)) + +(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-trivial-utf-8 + (let ((commit "6ca9943588cbc61ad22a3c1ff81beb371e122394") + (revision "2")) + (package + (name "sbcl-trivial-utf-8") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri + (git-reference + (url (string-append "https://gitlab.common-lisp.net/" + "trivial-utf-8/trivial-utf-8.git")) + (commit commit))) + (file-name (git-file-name "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 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-trivial-utilities") + (version (git-version "0.4.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.com/ediethelm/trivial-utilities") + (commit commit))) + (file-name (git-file-name "trivial-utilities" version)) + (sha256 + (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 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-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 cl-trivial-with-current-source-form + (sbcl-package->cl-source-package sbcl-trivial-with-current-source-form)) + +(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 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 cl-trivialib-type-unify + (sbcl-package->cl-source-package sbcl-trivialib-type-unify)) + +(define-public ecl-trivialib-type-unify + (sbcl-package->ecl-package sbcl-trivialib-type-unify)) + +(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 cl-trucler + (sbcl-package->cl-source-package sbcl-trucler)) + +(define-public ecl-trucler + (sbcl-package->ecl-package sbcl-trucler)) + +(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 cl-type-i + (sbcl-package->cl-source-package sbcl-type-i)) + +(define-public ecl-type-i + (package + (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-type-r + (sbcl-package->cl-source-package sbcl-type-r)) + +(define-public ecl-type-r + (sbcl-package->ecl-package sbcl-type-r)) + +(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-type-templates + (sbcl-package->cl-source-package sbcl-type-templates)) + +(define-public ecl-type-templates + (sbcl-package->ecl-package sbcl-type-templates)) + +(define-public sbcl-typo + (let ((commit "0e883490f81edf2a1be4e5b101d1caec78d7853b") + (revision "0")) + (package + (name "sbcl-typo") + (version (git-version "0.0.0" revision commit)) + (source + (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) + (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)) + +(define-public ecl-typo + (sbcl-package->ecl-package sbcl-typo)) + +(define-public sbcl-uax-14 + (let ((commit "0432162525119c401d3d705bb9bcc9580a03914f") + (revision "1")) + (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 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-uax-15") + (version "0.1.1") + (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)) + (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-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-ubiquitous + (sbcl-package->cl-source-package sbcl-ubiquitous)) + +(define-public ecl-ubiquitous + (sbcl-package->ecl-package sbcl-ubiquitous)) + +(define-public sbcl-ucons + (let ((commit "d976810ef2b12a2caaf55bd0f258272e9b79f3be") + (revision "0")) + (package + (name "sbcl-ucons") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/marcoheisig/ucons") + (commit commit))) + (file-name (git-file-name "cl-ucons" version)) + (sha256 + (base32 "17aj47pdjiywnf33hl46p27za2q0pq5ar3fpqxaqskggxrfxmijl")))) + (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)))) + +(define-public cl-ucons + (sbcl-package->cl-source-package sbcl-ucons)) + +(define-public ecl-ucons + (sbcl-package->ecl-package sbcl-ucons)) + +(define-public sbcl-uffi + (package + (name "sbcl-uffi") + (version "2.1.2") + (source + (origin + (method git-fetch) + (uri (git-reference + (url "http://git.kpe.io/uffi.git") + (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)))) + (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") + (description + "UFFI provides a universal foreign function interface (FFI) + for Common Lisp.") + (home-page "https://quickdocs.org/uffi/") + (license license:llgpl))) + +(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 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 ecl-umbra + (sbcl-package->ecl-package sbcl-umbra)) + +(define-public cl-umbra + (sbcl-package->cl-source-package sbcl-umbra)) + +(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-unix-opts + (sbcl-package->cl-source-package sbcl-unix-opts)) + +(define-public ecl-unix-opts + (sbcl-package->ecl-package sbcl-unix-opts)) + +(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 cl-usocket + (sbcl-package->cl-source-package sbcl-usocket)) + +(define-public ecl-usocket + (sbcl-package->ecl-package sbcl-usocket)) + +(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-utils-kt + (sbcl-package->cl-source-package sbcl-utils-kt)) + +(define-public ecl-utils-kt + (sbcl-package->ecl-package sbcl-utils-kt)) + +(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-vas-string-metrics + (sbcl-package->cl-source-package sbcl-vas-string-metrics)) + +(define-public ecl-vas-string-metrics + (sbcl-package->ecl-package sbcl-vas-string-metrics)) + +(define-public sbcl-verbose + (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174") + (revision "1")) + (package + (name "sbcl-verbose") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Shinmera/verbose/") + (commit commit))) + (file-name (git-file-name "verbose" version)) + (sha256 + (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6")))) + (build-system asdf-build-system/sbcl) + (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") + (description + "This is a Common Lisp library providing logging faciltiy similar to +@code{CL-LOG} and @code{LOG4CL}.") + (license license:zlib)))) + +(define-public cl-verbose + (sbcl-package->cl-source-package sbcl-verbose)) + +(define-public ecl-verbose + (sbcl-package->ecl-package sbcl-verbose)) + +(define-public sbcl-vernacular + ;; No release. + (let ((commit "79be179e9ada423b3ec41d2a1ea6f6e0266ed21f")) + (package + (name "sbcl-vernacular") + (version (git-version "0.8.0" "1" commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/ruricolist/vernacular/") + (commit commit))) + (file-name (git-file-name name 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)))) + (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") + (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.") + (license license:expat)))) + +(define-public cl-vernacular + (sbcl-package->cl-source-package sbcl-vernacular)) + +(define-public sbcl-vgplot + (let ((commit "76329928a3709387c0779175af56ec49d16bcd35") + (revision "0")) + (package + (name "sbcl-vgplot") + (version (git-version "0.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/volkers/vgplot") + (commit commit))) + (file-name (git-file-name "vgplot" version)) + (sha256 + (base32 "1vc5fd787xa8831wjbmwrpg17f9isi5k8dmb85fsysz47plbvi1y")))) + (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") + (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+)))) + +(define-public cl-vgplot + (sbcl-package->cl-source-package sbcl-vgplot)) + +(define-public ecl-vgplot + (sbcl-package->ecl-package sbcl-vgplot)) (define-public sbcl-virality (let ((commit "cdc19cca9b028f0c30d14ed8b3e51359dd46069a") @@ -23699,3833 +30203,36 @@ render them each frame.") (define-public cl-virality (sbcl-package->cl-source-package sbcl-virality)) -(define-public sbcl-cl-liballegro - (let ((commit "49f632ce97fc4f835bf5d450588793234b980a64") +(define-public sbcl-vom + (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24") (revision "1")) (package - (name "sbcl-cl-liballegro") - (version (git-version "0.2.15" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/resttime/cl-liballegro") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0brbr7i342s0gadlnzd3a61w2b9ihhx60l19ararnc2asvyhmz7x")))) - (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") - (description - "This package provides CFFI bindings and interface to Allegro 5 game -developing library for Common Lisp.") - (license license:zlib)))) - -(define-public ecl-cl-liballegro - (sbcl-package->ecl-package sbcl-cl-liballegro)) - -(define-public cl-liballegro - (sbcl-package->cl-source-package sbcl-cl-liballegro)) - -(define-public sbcl-font-discovery - (let ((commit "5101ca79151055f3ec9839aae73b8af42b884528") - (revision "1")) - (package - (name "sbcl-font-discovery") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/font-discovery") - (commit commit))) - (file-name (git-file-name "font-discovery" version)) - (sha256 - (base32 "1p9wkwc23rnif8vcjaj5ih1fmr5g57sidqjlz08qw6k0z4f6bia1")))) - (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)))) - -(define-public ecl-font-discovery - (sbcl-package->ecl-package sbcl-font-discovery)) - -(define-public cl-font-discovery - (sbcl-package->cl-source-package sbcl-font-discovery)) - -(define-public sbcl-alloy - (let ((commit "628974de537affb5b44ad548347f67c16efffcfc") - (revision "3")) - (package - (name "sbcl-alloy") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/alloy") - (commit commit))) - (file-name (git-file-name "cl-alloy" version)) - (sha256 - (base32 "0fx294qwxshgijss000pbjbnbwxqvxyw6p3mva36qljhbbkw2fxy")))) - (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") - (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)))) - -(define-public ecl-alloy - (sbcl-package->ecl-package sbcl-alloy)) - -(define-public cl-alloy - (sbcl-package->cl-source-package sbcl-alloy)) - -(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/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)))) - -(define-public ecl-org-sampler - (sbcl-package->ecl-package sbcl-org-sampler)) - -(define-public cl-org-sampler - (sbcl-package->cl-source-package sbcl-org-sampler)) - -(define-public sbcl-acl-compat - ;; There does not seem to be proper releases. - (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5")) - (package - (name "sbcl-acl-compat") - (version (git-version "0.1.1" "1" 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)) - (sha256 - (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 - `(("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 - "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 cl-acl-compat - (sbcl-package->cl-source-package sbcl-acl-compat)) - -(define-public sbcl-aserve - ;; There does not seem to be proper releases. - (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5") - (revision "2")) - (package - (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 cl-aserve - (sbcl-package->cl-source-package sbcl-aserve)) - -(define-public sbcl-yxorp - (let ((commit "c306898a467995e123a22316c9b79fcac442415b") - (revision "4")) - (package - (name "sbcl-yxorp") - (version (git-version "0.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/charJe/cl-yxorp") - (commit commit))) - (file-name (git-file-name "cl-yxorp" version)) - (sha256 - (base32 "0ll1s9w29yhhgqssgiw58fcapw4n040gkvpz4sxwv3q2v60rbidj")))) - (build-system asdf-build-system/sbcl) - (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") - (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)) - -(define-public cl-yxorp - (sbcl-package->cl-source-package sbcl-yxorp)) - -(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-rss - ;; No release. - (let ((commit "51d0145e91b86327ae5c36364f9c3048052e7a58")) - (package - (name "sbcl-rss") - (version (git-version "0.9.1.1" "2" 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)))) - (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.") - (license license:bsd-3)))) - -(define-public cl-rss - (sbcl-package->cl-source-package sbcl-rss)) - -(define-public sbcl-binascii - (let ((commit "0fb0a9e5773148fd04d50efef08c1cc10f6fc487") - (revision "1")) - (package - (name "sbcl-binascii") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/binascii") - (commit commit))) - (file-name (git-file-name "cl-binascii" 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\")")))))) - (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") - (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)))) - -(define-public cl-binascii - (sbcl-package->cl-source-package sbcl-binascii)) - -(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-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-trivial-with-current-source-form - (sbcl-package->cl-source-package sbcl-trivial-with-current-source-form)) - -(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 ecl-tailrec - (sbcl-package->ecl-package sbcl-tailrec)) - -(define-public cl-tailrec - (sbcl-package->cl-source-package sbcl-tailrec)) - -(define-public sbcl-issr-core - (let ((commit "64e3b07a63a7ca3ad70ba42474f98ac4513580aa") - (revision "1")) - (package - (name "sbcl-issr-core") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/interactive-ssr/core") - (commit commit))) - (file-name (git-file-name "issr-core" version)) - (sha256 - (base32 "1bajb09crzadkirdpd6jrpcc55irjd4sxzavygr25l85pafyhniw")))) - (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") - (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)) - -(define-public cl-issr-core - (sbcl-package->cl-source-package sbcl-issr-core)) - -(define-public sbcl-portal - (let ((commit "416589fa04cb239971422a1272acba236c8333be") - (revision "2")) - (package - (name "sbcl-portal") - (version (git-version "1.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/charJe/portal") - (commit commit))) - (file-name (git-file-name "portal" version)) - (sha256 - (base32 "1012jc068qdd8df6mmbn8vmmqlniqm5j2jbyrraw3yz8c13c8280")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-arrows - sbcl-cl-base64 - sbcl-cl-str - sbcl-flexi-streams - sbcl-global-vars - sbcl-ironclad - sbcl-parse-float - sbcl-usocket)) - (home-page "https://github.com/charJe/portal") - (synopsis "Portable Websocket Server for Common Lisp") - (description - "This is a websocket server for Common Lisp using usockets to be -portable between implementations and operating systems. It has a programming -interface that allows for multiple websocket apps per server using Common Lisp -keywords for different websocket events. It has useful restarts and -customizable errors.") - (license license:llgpl)))) - -(define-public ecl-portal - (sbcl-package->ecl-package sbcl-portal)) - -(define-public cl-portal - (sbcl-package->cl-source-package sbcl-portal)) - -(define-public sbcl-hunchenissr - (let ((commit "7df702f2e110999a2f31c7ebad81bfc39ac06670") - (revision "1")) - (package - (name "sbcl-hunchenissr") - (version (git-version "1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/interactive-ssr/hunchenissr") - (commit commit))) - (file-name (git-file-name "hunchenissr" version)) - (sha256 - (base32 "0826qrvk64pjspdklns29dv3zhzfhd6k42fq030xajv8a7hkcxda")))) - (build-system asdf-build-system/sbcl) - (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 - "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 ecl-hunchenissr - (sbcl-package->ecl-package sbcl-hunchenissr)) - -(define-public cl-hunchenissr - (sbcl-package->cl-source-package sbcl-hunchenissr)) - -(define-public sbcl-hunchenissr-routes - (let ((commit "2e831975dc2a6c030f1b518747cf429be8484b31") - (revision "1")) - (package - (name "sbcl-hunchenissr-routes") - (version (git-version "0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/interactive-ssr/hunchenissr-routes") - (commit commit))) - (file-name (git-file-name "hunchenissr-routes" version)) - (sha256 - (base32 "1xyqacihxwk4vnffqlg93czmalscglp6sh3bwy3qwb7hdxv6yxz6")))) - (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") - (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)))) - -(define-public ecl-hunchenissr-routes - (sbcl-package->ecl-package sbcl-hunchenissr-routes)) - -(define-public cl-hunchenissr-routes - (sbcl-package->cl-source-package sbcl-hunchenissr-routes)) - -(define-public sbcl-genhash - (let ((commit "220ae1af8361dbd2005177f2ee11072b6a33934f") - (revision "1")) - (package - (name "sbcl-genhash") - (version (git-version "1.7" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pnathan/genhash") - (commit commit))) - (file-name (git-file-name "cl-genhash" version)) - (sha256 - (base32 "1jnk1fix1zydhy0kn3cvlp6dy0241x7v8ahq001nlr6v152z1cwk")))) - (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)))) - -(define-public cl-genhash - (sbcl-package->cl-source-package sbcl-genhash)) - -(define-public ecl-genhash - (sbcl-package->ecl-package sbcl-genhash)) - -(define-public sbcl-spinneret - ;; No release since 2019, no tags. - (let ((commit "d4398b5a344b5c59e497c9ee78fdbae7cc434f74")) - (package - (name "sbcl-spinneret") - (version (git-version "3.0" "6" commit)) - (source - (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) - (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 - "In the crowded space of Common Lisp HTML generators, Spinneret -occupies the following coordinates: - -@itemize - -@item Modern. Targets HTML5. Does not treat XML and HTML as the same -problem. Assumes you will be serving your documents as UTF-8. - -@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 ecl-spinneret - (sbcl-package->ecl-package sbcl-spinneret)) - -(define-public cl-spinneret - (sbcl-package->cl-source-package sbcl-spinneret)) - -(define-public sbcl-path-parse - (let ((commit "86183f3752374435f8933394b4c5d8e75a37a113") - (revision "1")) - (package - (name "sbcl-path-parse") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eudoxia0/path-parse") - (commit commit))) - (file-name (git-file-name "cl-path-parse" version)) - (sha256 - (base32 "10mxm6q62cfpv3hw2w8k968ba8a1xglqdkwlkqs4l4nby3b11aaq")))) - (build-system asdf-build-system/sbcl) - (inputs - (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 package provides a function to parse the @code{PATH} environment -variable portably in Common Lisp.") - (license license:expat)))) - -(define-public cl-path-parse - (sbcl-package->cl-source-package sbcl-path-parse)) - -(define-public ecl-path-parse - (sbcl-package->ecl-package sbcl-path-parse)) - -(define-public sbcl-cl-libxml2 - (let ((commit "8d03110c532c1a3fe15503fdfefe82f60669e4bd")) - (package - (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 - (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") - (license license:llgpl)))) - -(define-public ecl-cl-libxml2 - (sbcl-package->ecl-package sbcl-cl-libxml2)) - -(define-public cl-libxml2 - (sbcl-package->cl-source-package sbcl-cl-libxml2)) - -(define-public sbcl-pileup - (let ((commit "f269473a570a8e55881082545ee63cfe5c7d3e72") - (revision "1")) - (package - (name "sbcl-pileup") - (version (git-version "1.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/nikodemus/pileup") - (commit commit))) - (file-name (git-file-name "cl-pileup" version)) - (sha256 - (base32 "01gvshpxil0ggjgfmgcymbgmpsfaxy6aggm0bywkn40rck3038vb")))) - (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") - (description - "@code{Pileup} is a portable, performant, and thread-safe binary heap -for Common Lisp.") - (license license:expat)))) - -(define-public cl-pileup - (sbcl-package->cl-source-package sbcl-pileup)) - -(define-public ecl-pileup - (sbcl-package->ecl-package sbcl-pileup)) - -(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/Shinmera/feeder") - (commit commit))) - (file-name (git-file-name "feeder" version)) - (sha256 - (base32 "1dpbzhycg50snl3j01c8dh8gdvhfhz0hnfl54xy55a3wbr3m6rp7")))) - (build-system asdf-build-system/sbcl) - (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") - (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)) - -(define-public cl-feeder - (sbcl-package->cl-source-package sbcl-feeder)) - -(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/archimag/cl-routes") - (commit commit))) - (file-name (git-file-name "cl-routes" version)) - (sha256 - (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 - `(("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)))) - -(define-public cl-routes - (sbcl-package->cl-source-package sbcl-routes)) - -(define-public ecl-routes - (sbcl-package->ecl-package sbcl-routes)) - -(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)))) - -(define-public cl-terminfo - (sbcl-package->cl-source-package sbcl-terminfo)) - -(define-public ecl-terminfo - (sbcl-package->ecl-package sbcl-terminfo)) - -(define-public sbcl-conium - (let ((commit "089adfd8759ec7973bb6f67b98d7a246e67aeb05") - (revision "1")) - (package - (name "sbcl-conium") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/conium") - (commit commit))) - (file-name (git-file-name "conium" version)) - (sha256 - (base32 "0y31za8xr8734p2pf8mrw1jd1fksh2d4y1p12wwjyn8hxxsvsx1w")))) - (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)))) - -(define-public cl-conium - (sbcl-package->cl-source-package sbcl-conium)) - -(define-public ecl-conium - (sbcl-package->ecl-package sbcl-conium)) - -(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-terminal-size - (sbcl-package->cl-source-package sbcl-terminal-size)) - -(define-public ecl-terminal-size - (sbcl-package->ecl-package sbcl-terminal-size)) - -(define-public sbcl-cl-readline - (let ((commit "8438c9ebd92ccc95ebab9cc9cbe6c72d44fccc58") - (revision "1")) - (package - (name "sbcl-cl-readline") - (version (git-version "0.1.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/vindarel/cl-readline") - (commit commit))) - (file-name (git-file-name "cl-readline" version)) - (sha256 - (base32 "14iskvqfw71ssaav483vmqw62lrpznysjs800gjjppxs785p1fa0")))) - (build-system asdf-build-system/sbcl) - (inputs - `(("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 cl-readline - (sbcl-package->cl-source-package sbcl-cl-readline)) - -(define-public ecl-cl-readline - (sbcl-package->ecl-package sbcl-cl-readline)) - -(define-public sbcl-generic-comparability - (let ((commit "53fc2846319a6eb46b36581e203e1f1542a8acff") - (revision "1")) - (package - (name "sbcl-generic-comparability") - (version (git-version "1.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pnathan/generic-comparability") - (commit commit))) - (file-name (git-file-name "generic-comparability" version)) - (sha256 - (base32 "01ma0cwirxarwwmdwflnh8kmysmr2smh5kyvzhb2074ljxg8yq2p")))) - (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)))) - -(define-public cl-generic-comparability - (sbcl-package->cl-source-package sbcl-generic-comparability)) - -(define-public ecl-generic-comparability - (sbcl-package->ecl-package sbcl-generic-comparability)) - -(define-public sbcl-cl-libyaml - (let ((commit "a7fe9f68bddfd00b7ca467b65b3b41b276336843") - (revision "1")) - (package - (name "sbcl-cl-libyaml") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eudoxia0/cl-libyaml") - (commit commit))) - (file-name (git-file-name "cl-libyaml" version)) - (sha256 - (base32 - "06pvmackyhq03rjmihpx6w63m6cy8wx78ll5xpwwvd85bgrqq817")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (inputs - `(("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 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-libyaml - (sbcl-package->cl-source-package sbcl-cl-libyaml)) - -(define-public ecl-cl-libyaml - (sbcl-package->ecl-package sbcl-cl-libyaml)) - -(define-public sbcl-cl-yaml - (let ((commit "c3202be9a753c51f3bc79538a5a498a8865192aa") - (revision "1")) - (package - (name "sbcl-cl-yaml") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eudoxia0/cl-yaml") - (commit commit))) - (file-name (git-file-name "cl-yaml" version)) - (sha256 - (base32 "1izjg0v6rf7dh069bbnnr67l30lsqj86wdk7y9ggbgiwh6v9j185")))) - (build-system asdf-build-system/sbcl) - (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 - "This is a YAML parser and emitter for Common Lisp built on top of -libyaml.") - (license license:expat)))) - -(define-public cl-yaml - (sbcl-package->cl-source-package sbcl-cl-yaml)) - -(define-public ecl-cl-yaml - (sbcl-package->ecl-package sbcl-cl-yaml)) - -(define-public sbcl-clop - (let ((commit "c0c3fe7efa5ac95ba1644febfb2c2acab757fcda") - (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)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sheepduke/clop") - (commit commit))) - (file-name (git-file-name "cl-clop" version)) - (sha256 - (base32 "1q7rlizr8gcbfz4a9660gdbw7d2zbld18akjpibg54j7jh5kb8gc")))) - (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") - (description - "Clop is a Common Lisp library for parsing strings in the TOML -configuration file format.") - (license license:expat)))) - -(define-public cl-clop - (sbcl-package->cl-source-package sbcl-clop)) - -(define-public ecl-clop - (sbcl-package->ecl-package sbcl-clop)) - -(define-public sbcl-pp-toml - (let ((commit "54f7d08c939d18b24363342c98c19b6812d7afb9") - (revision "0")) - (package - (name "sbcl-pp-toml") - (version (git-version "1.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pnathan/pp-toml") - (commit commit))) - (file-name (git-file-name "cl-pp-toml" version)) - (sha256 - (base32 "136d7jzz7l2ck9wwld0ac46jmpm94lvja6m50sy73s232slka2hg")))) - (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") - (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)))) - -(define-public cl-pp-toml - (sbcl-package->cl-source-package sbcl-pp-toml)) - -(define-public ecl-pp-toml - (sbcl-package->ecl-package sbcl-pp-toml)) - -(define-public sbcl-linedit - (let ((commit "0561c97dfca2f5854fcc66558a567a9875ddcb8f") - (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)))) - -(define-public cl-linedit - (sbcl-package->cl-source-package sbcl-linedit)) - -(define-public ecl-linedit - (sbcl-package->ecl-package sbcl-linedit)) - -(define-public sbcl-diff - (let ((commit "9c84befa598d4e07c3d223242b5b3f83cd94f301") - (revision "1")) - (package - (name "sbcl-diff") - (version (git-version "0.4" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/froydnj/diff") - (commit commit))) - (file-name (git-file-name "cl-diff" version)) - (sha256 - (base32 "1giafck8qfvb688kx5bn9g32rfc12jjywg8vdav36aqbd6lxf5z5")))) - (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") - (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-diff - (sbcl-package->cl-source-package sbcl-diff)) - -(define-public ecl-diff - (sbcl-package->ecl-package sbcl-diff)) - -(define-public sbcl-montezuma - (let ((commit "ee2129eece7065760de4ebbaeffaadcb27644738") - (revision "1")) - (package - (name "sbcl-montezuma") - (version (git-version "0.1.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/montezuma") - (commit commit))) - (file-name (git-file-name "cl-montezuma" version)) - (sha256 - (base32 "0svmvsbsirydk3c1spzfvj8qmkzcs9i69anpfvk1843i62wb7x2c")))) - (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") - (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 - -(define-public cl-montezuma - (sbcl-package->cl-source-package sbcl-montezuma)) - -(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-cl-charms - (let ((commit "64aba59d89f85bc5c9402e445873965338a66a02") - (revision "1")) - (package - (name "sbcl-cl-charms") - (version (git-version "0.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/HiTECNOLOGYs/cl-charms") - (commit commit))) - (file-name (git-file-name "cl-charms" version)) - (sha256 - (base32 "1jczaypa9dhxr34yyhsxb6lrdnircjx8am4iqkc3shfpjn32q323")))) - (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)))) - -(define-public cl-charms - (sbcl-package->cl-source-package sbcl-cl-charms)) - -(define-public ecl-cl-charms - (sbcl-package->ecl-package sbcl-cl-charms)) - -(define-public sbcl-trivial-open-browser - (let ((commit "7ab4743dea9d592639f15c565bfa0756e828c427") - (revision "1")) - (package - (name "sbcl-trivial-open-browser") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eudoxia0/trivial-open-browser") - (commit commit))) - (file-name (git-file-name "cl-trivial-open-browser" version)) - (sha256 - (base32 "0ixay1piq420i6adx642qhw45l6ik7rvgk52lyz27dvx5f8yqsdb")))) - (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") - (description - "This package provides a library to open a web browser to a URL.") - (license license:expat)))) - -(define-public cl-trivial-open-browser - (sbcl-package->cl-source-package sbcl-trivial-open-browser)) - -(define-public ecl-trivial-open-browser - (sbcl-package->ecl-package sbcl-trivial-open-browser)) - -(define-public sbcl-clinenoise - (let ((commit "46e21f99d06a55d93eaa382cf652d55d457032ef") - (revision "1")) - (package - (name "sbcl-clinenoise") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jasom/clinenoise") - (commit commit))) - (file-name (git-file-name "clinenoise" version)) - (sha256 - (base32 "0ydlirfk4dbpqqjwwph99v5swcrhd8v9g8q24fvs35wn2vm08lh1")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria sbcl-cffi sbcl-split-sequence)) - (home-page "https://github.com/jasom/clinenoise") - (synopsis "Port of linenoise to Common Lisp") - (description - "This package provides a trivial line-input library for VT-like -terminals.") - (license license:bsd-2)))) - -(define-public cl-clinenoise - (sbcl-package->cl-source-package sbcl-clinenoise)) - -(define-public ecl-clinenoise - (sbcl-package->ecl-package sbcl-clinenoise)) - -(define-public sbcl-trivial-raw-io - (let ((commit "b1a3c876305baa0dead419841de7b3e433a75867") - (revision "1")) - (package - (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/kingcons/trivial-raw-io") - (commit commit))) - (file-name (git-file-name "trivial-raw-io" version)) - (sha256 - (base32 "19290zw2b64k78wr62gv30pp7cmqg07q85vfwjknaffjdd73xwi1")))) - (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") - (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)) - -(define-public ecl-trivial-raw-io - (sbcl-package->ecl-package sbcl-trivial-raw-io)) - -(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: - -@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))) - -(define-public cl-chemboy - (sbcl-package->cl-source-package sbcl-chemboy)) - -(define-public ecl-chemboy - (sbcl-package->ecl-package sbcl-chemboy)) - -(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-cl-pass - (let ((commit "e58e97c0c0588dc742c061208afb9bc31e4dbd34") - (revision "1")) - (package - (name "sbcl-cl-pass") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eudoxia0/cl-pass") - (commit commit))) - (file-name (git-file-name "cl-pass" version)) - (sha256 - (base32 "05qx4jrkxqbqi72cxgswbpnifbdvp9mh7apc7566v522899bh0hb")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-pass - (sbcl-package->cl-source-package sbcl-cl-pass)) - -(define-public ecl-cl-pass - (sbcl-package->ecl-package sbcl-cl-pass)) - -(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/eudoxia0/which") - (commit commit))) - (file-name (git-file-name "cl-which" version)) - (sha256 - (base32 "127pm9h4rm4w9aadw5yvamnfzhk2rr69kchx10rf9k7sk7izqqfk")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-which - (sbcl-package->cl-source-package sbcl-which)) - -(define-public ecl-which - (sbcl-package->ecl-package sbcl-which)) - -(define-public sbcl-wu-decimal - (let ((commit "5b348bdb32a0f83e80e17aa68cd51787ae8c8a45") - (revision "0")) - (package - (name "sbcl-wu-decimal") - (version (git-version "2.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Wukix/wu-decimal") - (commit commit))) - (file-name (git-file-name "cl-wu-decimal" version)) - (sha256 - (base32 "1p7na4hic7297amwm4idfwkyx664ny8cdssncyra37pmv4wzp8dm")))) - (build-system asdf-build-system/sbcl) - (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-wu-decimal - (sbcl-package->cl-source-package sbcl-wu-decimal)) - -(define-public ecl-wu-decimal - (sbcl-package->ecl-package sbcl-wu-decimal)) - -(define-public sbcl-infix-math - (let ((commit "f5155ae9709e518061ace79887d78f8e79c61cac") - (revision "0")) - (package - (name "sbcl-infix-math") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/infix-math") - (commit commit))) - (file-name (git-file-name "cl-infix-math" version)) - (sha256 - (base32 "1h6p254xl793wfq3qla5y95k6zimy477f8brblx6ran3rg3bydbg")))) - (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") - (description - "Infix-Math is a library that provides a special-purpose syntax for -transcribing mathematical formulas into Lisp.") - (license license:expat)))) - -(define-public cl-infix-math - (sbcl-package->cl-source-package sbcl-infix-math)) - -(define-public ecl-infix-math - (sbcl-package->ecl-package sbcl-infix-math)) - -(define-public sbcl-cl-num-utils - (let ((commit "97a88cd34540acf52e872a82ebfef3da0a34fa12") - (revision "1")) - (package - (name "sbcl-cl-num-utils") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/cl-num-utils") - (commit commit))) - (file-name (git-file-name "cl-num-utils" version)) - (sha256 - (base32 "15ihsxxs76xnldmqfsbxybckqjwrxwcpphgghiwzr2mnbqjpdqkh")))) - (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") - (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)))) - -(define-public cl-num-utils - (sbcl-package->cl-source-package sbcl-cl-num-utils)) - -(define-public ecl-cl-num-utils - (sbcl-package->ecl-package sbcl-cl-num-utils)) - -(define-public sbcl-lla - (let ((commit "ded805d1e9b1493e17b601116ba9bd8a3de3024f") - (revision "1")) - (package - (name "sbcl-lla") - (version (git-version "0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/lla") - (commit commit))) - (file-name (git-file-name "cl-lla" version)) - (sha256 - (base32 "0n9vc7dnyjbbsv1n7rd8sylwda5fsdf8f890g4nachanyx0xps9k")))) - (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") - (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)))) - -(define-public cl-lla - (sbcl-package->cl-source-package sbcl-lla)) - -(define-public ecl-lla - (sbcl-package->ecl-package sbcl-lla)) - -(define-public sbcl-cl-rmath - (let ((commit "f6add1edda31547691d08e36ccf6c17305161aca") - (revision "1")) - (package - (name "sbcl-cl-rmath") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/cl-rmath") - (commit commit))) - (file-name (git-file-name "cl-rmath" version)) - (sha256 - (base32 "1ld8vbpy10paymx2hn0mcgd21i7cjhdrayln1jx0kayqxm12mmk4")))) - (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") - (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-rmath - (sbcl-package->cl-source-package sbcl-cl-rmath)) - -(define-public ecl-cl-rmath - (sbcl-package->ecl-package sbcl-cl-rmath)) - -(define-public sbcl-cl-random - (let ((commit "5bb65911037f95a4260bd29a594a09df3849f4ea") - (revision "1")) - (package - (name "sbcl-cl-random") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tpapp/cl-random") - (commit commit))) - (file-name (git-file-name "cl-random" version)) - (sha256 - (base32 "0jn80xphyvyp2v72acr6b8a2f6dw06myr5vrjfl14brsvks7wr89")))) - (build-system asdf-build-system/sbcl) - (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") - (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-random - (sbcl-package->cl-source-package sbcl-cl-random)) - -(define-public ecl-cl-random - (sbcl-package->ecl-package sbcl-cl-random)) - -(define-public sbcl-random-sample - (let ((commit "46b70374ed796b84ea003e83c1db97b0caf97e22") - (revision "0")) - (package - (name "sbcl-random-sample") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/random-sample") - (commit commit))) - (file-name (git-file-name "cl-random-sample" version)) - (sha256 - (base32 "0nhgca6wf754wbg91h40gx7xq22rawg2pn6l7h02wv1jxac4q6nh")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam)) - (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") - (description - "Random-Sample is a library for reliably taking a random sample from a -sequence.") - (license license:expat)))) - -(define-public cl-random-sample - (sbcl-package->cl-source-package sbcl-random-sample)) - -(define-public ecl-random-sample - (sbcl-package->ecl-package sbcl-random-sample)) - -(define-public sbcl-hypergeometrica - (let ((commit "db723ceb343d89a1c8d7f9174cf3a76fa91522b5") - (revision "0")) - (package - (name "sbcl-hypergeometrica") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/stylewarning/hypergeometrica") - (commit commit))) - (file-name (git-file-name "cl-hypergeometrica" version)) - (sha256 - (base32 "1dfd6w9djgfh7f4z79d8qsyggrwkjlqhs9rxpzpzv092nlwg3l35")))) - (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") - (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 - -On top of multiplication, one can build checkpointed algorithms for computing -various classical constants, like @math{\\pi}.") - (license license:bsd-3)))) - -(define-public cl-hypergeometrica - (sbcl-package->cl-source-package sbcl-hypergeometrica)) - -(define-public sbcl-mgl-gpr - (let ((commit "cb6ce51e2f87bf1d589f3703c13eea6e25780afe") - (revision "1")) - (package - (name "sbcl-mgl-gpr") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/melisgl/mgl-gpr") - (commit commit))) - (file-name (git-file-name "cl-mgl-gpr" version)) - (sha256 - (base32 "0w51dqixh277k6sl8bqvvp1400y6kd1l5h3d9q2f40l9bpxy8gjx")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cl-random sbcl-mgl-pax)) - (home-page "https://melisgl.github.io/mgl-gpr/") - (synopsis "Common Lisp library of evolutionary algorithms") - (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.") - (license license:expat)))) - -(define-public cl-mgl-gpr - (sbcl-package->cl-source-package sbcl-mgl-gpr)) - -(define-public ecl-mgl-gpr - (sbcl-package->ecl-package sbcl-mgl-gpr)) - -(define-public sbcl-cl-tld - ;; No release. - (let ((commit "f5014da8d831fa9481d4181d4450f10a52850c75")) - (package - (name "sbcl-cl-tld") - (version (git-version "0.1" "2" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lu4nx/cl-tld") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0sxnn35gzdby1ixil6zbjg72vli9fcspwzsqimqk455310syx9iv")))) - (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") - (description - "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 cl-tld - (sbcl-package->cl-source-package sbcl-cl-tld)) - -(define-public ecl-cl-tld - (sbcl-package->ecl-package sbcl-cl-tld)) - -(define-public sbcl-cl-strftime - ;; No release. - (let ((commit "21cb57f2595faa26d687893963f24ec41822b63c")) - (package - (name "sbcl-cl-strftime") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/cl-strftime/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "00c8hq7vzgb89ab3q7mrp60x743kiqmsk1g51ynhxlqhph2bnslf")))) - (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") - (description - "CL-STRFTIME is a Common Lisp compiler for the strftime “language.”") - (license license:expat)))) - -(define-public cl-strftime - (sbcl-package->cl-source-package sbcl-cl-strftime)) - -(define-public ecl-cl-strftime - (sbcl-package->ecl-package sbcl-cl-strftime)) - -(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-cl-base58 - (let ((commit "f446835b4104896e0eed6a61d2ceb4ad22f589d8") - (revision "1")) - (package - (name "sbcl-cl-base58") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eudoxia0/cl-base58/") - (commit commit))) - (file-name (git-file-name "cl-base58" version)) - (sha256 - (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-prove)) - (home-page "https://github.com/eudoxia0/cl-base58") - (synopsis "Implementation of base58 for Common Lisp") - (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)))) - -(define-public cl-base58 - (sbcl-package->cl-source-package sbcl-cl-base58)) - -(define-public ecl-cl-base58 - (sbcl-package->ecl-package sbcl-cl-base58)) - -(define-public sbcl-bit-smasher - ;; No release. - (let ((commit "c2dcb3b5ec0e485484be681fe17c4e81e58790d9")) - (package - (name "sbcl-bit-smasher") - (version (git-version "1.0.2" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/thephoeron/bit-smasher/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "0wjmwn06fjpw0rlpaksf3ab727p8fnzj58z7jajl3m0wqd4ii74w")))) - (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") - (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 cl-bit-smasher - (sbcl-package->cl-source-package sbcl-bit-smasher)) - -(define-public ecl-bit-smasher - (sbcl-package->ecl-package sbcl-bit-smasher)) - -(define-public sbcl-overlord - ;; No release. - (let ((commit "a8f37b321a8aae1652fc50b78e74e57c771cc763")) - (package - (name "sbcl-overlord") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/overlord/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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 '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 - "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. - -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. - -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 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-xpath - ;; No release. - (let ((commit "d364da693a534e23bd5eb3a85420e9c25e6c75b3")) - (package - (name "sbcl-xpath") - (version (git-version "0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sharplispers/xpath/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "1fb03fgnzrvh22lw1jdg04pmyja5fib5n42rzwp5mhr829yvxkvp")))) - (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") - (description - "This library is an implementation of the XML Path Language (XPath) -Version 1.0.") - (license license:bsd-2)))) - -;; 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 sbcl-fxml - ;; No release. - (let ((commit "a0e73bb48ef03adea94a55986cc27f522074c8e1")) - (package - (name "sbcl-fxml") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/fxml/") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (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 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 You are parsing potentially ill-formed XML. -@item You are parsing potentially malicious XML. -@item You need to use Klacks with namespaces. -@end itemize - -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-fxml - (sbcl-package->cl-source-package sbcl-fxml)) - -(define-public sbcl-vernacular - ;; No release. - (let ((commit "79be179e9ada423b3ec41d2a1ea6f6e0266ed21f")) - (package - (name "sbcl-vernacular") - (version (git-version "0.8.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ruricolist/vernacular/") - (commit commit))) - (file-name (git-file-name name 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)))) - (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") - (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.") - (license license:expat)))) - -(define-public cl-vernacular - (sbcl-package->cl-source-package sbcl-vernacular)) - -(define-public sbcl-cl-collider - (let ((commit "a46908896982868955b29bfb3a5337a0af489b0b") - (revision "0")) - (package - (name "sbcl-cl-collider") - (version (git-version "2018.7.15" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/byulparan/cl-collider") - (commit commit))) - (file-name (git-file-name "cl-collider" 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)))) - -(define-public cl-collider - (sbcl-package->cl-source-package sbcl-cl-collider)) - -(define-public ecl-cl-collider - (sbcl-package->ecl-package sbcl-cl-collider)) - -(define-public sbcl-osc - (let ((commit "f647738ccc22925ed740a8ca9132fda76a05baeb") - (revision "0")) - (package - (name "sbcl-osc") - (version (git-version "0.9" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/zzkt/osc") - (commit commit))) - (file-name (git-file-name "cl-osc" 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+)))) - -(define-public cl-osc - (sbcl-package->cl-source-package sbcl-osc)) - -(define-public ecl-osc - (sbcl-package->ecl-package sbcl-osc)) - -(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-core-gp - (let ((commit "90ec1c4599a19c5a911be1f703f78d5108aee160") - (revision "1")) - (package - (name "sbcl-core-gp") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jorgetavares/core-gp") - (commit commit))) - (file-name (git-file-name "cl-core-gp" version)) - (sha256 - (base32 "0nzlb2gwqisa1amlpl4zc5xxph2g3qwhfyaxchci67d31rzws6l3")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/jorgetavares/core-gp") - (synopsis "Common Lisp library for genetic programming") - (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)))) - -(define-public cl-core-gp - (sbcl-package->cl-source-package sbcl-core-gp)) - -(define-public ecl-core-gp - (sbcl-package->ecl-package sbcl-core-gp)) - -(define-public sbcl-data-sift - (let ((commit "fd617d8200cdcc1b87ecf45ab59bb38e8b16ef7e") - (revision "1")) - (package - (name "sbcl-data-sift") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/archimag/data-sift") - (commit commit))) - (file-name (git-file-name "cl-data-sift" version)) - (sha256 - (base32 "1v7gf0x4ibjzp0c56n9m77hxdgwcm9356zlk5n4l3fx4i0hj6146")))) - (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") - (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)))) - -(define-public cl-data-sift - (sbcl-package->cl-source-package sbcl-data-sift)) - -(define-public ecl-data-sift - (sbcl-package->ecl-package sbcl-data-sift)) - -(define-public sbcl-restas - (let ((commit "81bbbab6b36f81f846f78e71232e9d3d15f6d952") - (revision "1")) - (package - (name "sbcl-restas") + (name "sbcl-vom") (version (git-version "0.1.4" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/archimag/restas") - (commit commit))) - (file-name (git-file-name "cl-restas" version)) - (sha256 - (base32 "00ng6jik1lwjw3bbxhijy8s0ml24lgm73liwrr01gcsb0r6wrjjn")))) - (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)))) - -(define-public cl-restas - (sbcl-package->cl-source-package sbcl-restas)) - -(define-public ecl-restas - (sbcl-package->ecl-package sbcl-restas)) - -(define-public sbcl-zsort - (let ((commit "f6724a6fff7662a942195cedb0d7f00da59c74ed") - (revision "1")) - (package - (name "sbcl-zsort") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/jorgetavares/zsort") - (commit commit))) - (file-name (git-file-name "cl-zsort" version)) - (sha256 - (base32 "1vyklyh99712zsll4qi0m4mm8yb1nz04403vl8i57bjv5p5max49")))) - (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") - (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 cl-zsort - (sbcl-package->cl-source-package sbcl-zsort)) - -(define-public ecl-zsort - (sbcl-package->ecl-package sbcl-zsort)) - -(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/") + (url "https://github.com/orthecreedence/vom") (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 cl-https-everywhere - (sbcl-package->cl-source-package sbcl-cl-https-everywhere)) - -(define-public sbcl-magic-ed - (let ((commit "30bb27832d4e3e362578e7320934638f9889a8c4") - (revision "1")) - (package - (name "sbcl-magic-ed") - (version (git-version "0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/sanel/magic-ed") - (commit commit))) - (file-name (git-file-name "cl-magic-ed" version)) - (sha256 - (base32 "1j6il4lif0dy6hqiz6n91yl8dvii9pk1i9vz0faq5mnr42mr7i5f")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/sanel/magic-ed") - (synopsis "Editing facility for Common Lisp REPL") - (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)))) - -(define-public cl-magic-ed - (sbcl-package->cl-source-package sbcl-magic-ed)) - -(define-public ecl-magic-ed - (sbcl-package->ecl-package sbcl-magic-ed)) - -(define-public sbcl-maxpc - (let ((commit "e5e58d053039517d30fd59ab2d128256b87790d5") - (revision "1")) - (package - (name "sbcl-maxpc") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eugeneia/maxpc") - (commit commit))) - (file-name (git-file-name name 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)))) - (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") - (description - "This package provides Python style generators for Common Lisp. -It also includes a port of itertools.") - (license license:asl2.0)))) - -(define-public cl-snakes - (sbcl-package->cl-source-package sbcl-snakes)) - -(define-public ecl-snakes - (sbcl-package->ecl-package sbcl-snakes)) - -(define-public sbcl-random-state - (let ((commit "c270d4f15e0b66ba9680ca8734a5de56959cb118") - (revision "1")) - (package - (name "sbcl-random-state") - (version (git-version "0.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/random-state") - (commit commit))) - (file-name (git-file-name "cl-random-state" version)) - (sha256 - (base32 "0r3bk6hqpr0qmpza93pknl8wpsd6y0yy9qg7vz751a7gzzww9vj6")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-documentation-utils)) - (home-page "https://shinmera.github.io/random-state/") - (synopsis "Portable random number generation") - (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)) - -(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))) - -(define-public cl-decimals - (sbcl-package->cl-source-package sbcl-decimals)) - -(define-public ecl-decimals - (sbcl-package->ecl-package sbcl-decimals)) - -(define-public sbcl-simple-date-time - (let ((commit "d6992afddedf67a8172a0120a1deac32afcaa2e8") - (revision "1")) - (package - (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/quek/simple-date-time") - (commit commit))) - (file-name (git-file-name "cl-simple-date-time" version)) - (sha256 - (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-simple-date-time - (sbcl-package->cl-source-package sbcl-simple-date-time)) - -(define-public ecl-simple-date-time - (sbcl-package->ecl-package sbcl-simple-date-time)) - -(define-public sbcl-april - (let ((commit "bdd74f168ec82f28fe4ab692f2c0af39441a5701") - (revision "3")) - (package - (name "sbcl-april") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/phantomics/april") - (commit commit))) - (file-name (git-file-name "cl-april" 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")))))) - (build-system asdf-build-system/sbcl) - (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") - (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)))) - -(define-public cl-april - (sbcl-package->cl-source-package sbcl-april)) - -(define-public ecl-april - (sbcl-package->ecl-package sbcl-april)) - -(define-public sbcl-cl-sxml - (let ((commit "e5542b1d9bd6cee03ae27547d00660ccfbb60109") - (revision "1")) - (package - (name "sbcl-cl-sxml") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/eadmund/cl-sxml") - (commit commit))) - (file-name (git-file-name "cl-sxml" 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+)))) - -(define-public cl-sxml - (sbcl-package->cl-source-package sbcl-cl-sxml)) - -(define-public ecl-cl-sxml - (sbcl-package->ecl-package sbcl-cl-sxml)) - -(define-public sbcl-lorem-ipsum - (let ((commit "04a1839a03b53c954e799b9cf570ac915b032ce8") - (revision "0")) - (package - (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-asd-generator - (let ((commit "27f94971a7c68c4dcb51e3f6be4142743d0c44e8") - (revision "0")) - (package - (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-cl-gopher - (let ((commit "0899e7fa2134206f9d9778c7d53c49b7a59ff070") - (revision "3")) - (package - (name "sbcl-cl-gopher") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/knusbaum/cl-gopher") - (commit commit))) - (file-name (git-file-name "cl-gopher" 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)))) - (build-system asdf-build-system/sbcl) - (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") - (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.") - (license license:bsd-2)))) - -(define-public cl-gopher - (sbcl-package->cl-source-package sbcl-cl-gopher)) - -(define-public ecl-cl-gopher - (sbcl-package->ecl-package sbcl-cl-gopher)) - -(define-public sbcl-phos - (let ((commit "6620b82b091cdfed655e1093ef045dbe518d5474")) - (package - (name "sbcl-phos") - (version (git-version "0.0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/omar-polo/phos") - (commit commit))) - (file-name (git-file-name "phos" version)) (sha256 (base32 - "1zwci86rkbaiix0w2gd5q6nr8v2vv945pkvwp0j240iyzd4hfxr3")))) + "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy")))) (build-system asdf-build-system/sbcl) - (inputs - (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 cl-phos - (sbcl-package->cl-source-package sbcl-phos)) - -(define-public ecl-phos - (sbcl-package->ecl-package sbcl-phos)) - -(define-public sbcl-germinal - (let ((commit "5bfb371ea57dae8985c0e1c6f184f0338487d684") - (revision "0")) - (package - (name "sbcl-germinal") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://git.carcosa.net/jmcbray/germinal") - (commit commit))) - (file-name (git-file-name "cl-germinal" version)) - (sha256 - (base32 "12jypa8m10825lp5yxfcm1fyk3r4ziwcri7ndxa0m5dz0y7hggck")))) - (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)))) - -(define-public cl-germinal - (sbcl-package->cl-source-package sbcl-germinal)) - -(define-public ecl-germinal - (sbcl-package->ecl-package sbcl-germinal)) - -(define-public sbcl-css-lite - (let ((commit "6ee4e6212ed56943d665df163d2a834b122e6273") - (revision "0")) - (package - (name "sbcl-css-lite") - (version "0.01") - (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)))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/paddymul/css-lite") - (synopsis "CSS grammar for Lisp") + (synopsis "Tiny logging utility for Common Lisp") (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)))) - -(define-public cl-css-lite - (sbcl-package->cl-source-package sbcl-css-lite)) - -(define-public ecl-css-lite - (sbcl-package->ecl-package sbcl-css-lite)) - -(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: - -@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") - (license license:expat))) - -(define-public cl-nhooks - (sbcl-package->cl-source-package sbcl-nhooks)) - -(define-public ecl-nhooks - (sbcl-package->ecl-package sbcl-nhooks)) - -(define-public sbcl-wordnet - (let ((commit "8cd0db8f5e84e7a930fa74e590ecddf75cd8e5d6") - (revision "0")) - (package - (name "sbcl-wordnet") - (version (git-version "0.0.1" 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)))) - (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") - (description - "This software provides an interface by which Common Lisp programs can -access lexicographic data from WordNet.") + "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-wordnet - (sbcl-package->cl-source-package sbcl-wordnet)) +(define-public cl-vom + (sbcl-package->cl-source-package sbcl-vom)) -(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. - -@item On read error, existing files are backed up. - -@item On write error, no file is written to disk, the existing file is preserved. -@end itemize\n") - (license license:bsd-3))) - -(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 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")) - (package - (name "sbcl-nasdf") - (version "0.1.8") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/atlas-engineer/ntemplate") - (commit commit))) - (file-name (git-file-name "cl-ntemplate" version)) - (sha256 - (base32 "15j7kqxvn0blr0i2xgk0il0ia91p28clfqxdh00vlp423v9a2wbx")))) - (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. - -@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-nasdf - (sbcl-package->ecl-package sbcl-nasdf)) - -(define-public cl-nasdf - (sbcl-package->cl-source-package sbcl-nasdf)) - -(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. - -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 ecl-nclasses - (sbcl-package->ecl-package sbcl-nclasses)) - -(define-public cl-nclasses - (sbcl-package->cl-source-package sbcl-nclasses)) - -(define-public sbcl-prompter - (let ((commit "7890ed5d02e70aba01ceb964c6ee4f40776e7dc0") - (revision "0")) - (package - (name "sbcl-prompter") - (version (git-version "0.1.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/atlas-engineer/prompter") - (commit commit))) - (file-name (git-file-name "cl-prompter" version)) - (sha256 - (base32 - "0r15a6cagyp5x8aqx92ln2anni737h73bdshkvpzrac04ajss4md")))) - (build-system asdf-build-system/sbcl) - (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)))) - -(define-public cl-prompter - (sbcl-package->cl-source-package sbcl-prompter)) - -(define-public ecl-prompter - (sbcl-package->ecl-package sbcl-prompter)) - -(define-public sbcl-cl-template - (let ((commit "46193a9a389bb950530e579eae7e6e5a18184832") - (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)))) - -(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-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 #. - '(#: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-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-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)))) - -(define-public cl-sha1 - (sbcl-package->cl-source-package sbcl-sha1)) - -(define-public ecl-sha1 - (sbcl-package->ecl-package sbcl-sha1)) +(define-public ecl-vom + (sbcl-package->ecl-package sbcl-vom)) (define-public sbcl-websocket-driver (let ((commit "df94496ecb525d086eeada4f5875975515b7212e") @@ -27567,465 +30274,255 @@ implementation for Common Lisp.") (define-public ecl-websocket-driver (sbcl-package->ecl-package sbcl-websocket-driver)) -(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-simple-routes - (let ((commit "6f88c38945a4de73e85786d3499c39cacb400598") +(define-public sbcl-which + (let ((commit "b2333e4fcacab6e5d85eecd28b5ef4944bda1448") (revision "1")) (package - (name "sbcl-simple-routes") - (version (git-version "0.3" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.com/vancan1ty/simple-routes") - (commit commit))) - (file-name (git-file-name "cl-simple-routes" version)) - (sha256 - (base32 "0zkjl69zf1ynmqmvwccdbip3wxfyi7xplivv70qwxzd27mc0kh3k")))) - (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)) - -(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-cl-ipfs-api2 - (let ((commit "3ee52c80023bcc662f7d01276ea0a5814bd0011b") - (revision "0")) - (package - (name "sbcl-cl-ipfs-api2") - (version (git-version "0.51" revision commit)) - (source - (origin - (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 "1h0csxk4db1hid793mk5kz3nbjyl7z4ic1zk2wy46k1vz5lnnsph")))) - (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") - (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)))) - -(define-public cl-ipfs-api2 - (sbcl-package->cl-source-package sbcl-cl-ipfs-api2)) - -(define-public ecl-cl-ipfs-api2 - (sbcl-package->ecl-package sbcl-cl-ipfs-api2)) - -(define-public sbcl-purgatory - (let ((commit "3afd8f6bb4093ffb2f39ffdedf11278b3617fff9") - (revision "1")) - (package - (name "sbcl-purgatory") - (version (git-version "0.1.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://notabug.org/cage/purgatory") - (commit commit))) - (file-name (git-file-name "cl-purgatory" version)) - (sha256 - (base32 "0iy2jdgrwqrq9cph7bwf79d8l4zdsgcd9sfcn0lclzai2v0yizp9")))) - (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)))) - -(define-public ecl-purgatory - (sbcl-package->ecl-package sbcl-purgatory)) - -(define-public cl-purgatory - (sbcl-package->cl-source-package sbcl-purgatory)) - -(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-just-getopt-parser - (sbcl-package->ecl-package sbcl-just-getopt-parser)) - -(define-public cl-just-getopt-parser - (sbcl-package->cl-source-package sbcl-just-getopt-parser)) - -(define-public sbcl-formgrep - (let ((commit "91238cdbdd0ad815ff5d574d032b4a502febd190") - (revision "0")) - (package - (name "sbcl-formgrep") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/death/formgrep") - (commit commit))) - (file-name (git-file-name "cl-formgrep" version)) - (sha256 - (base32 "1rqzkmz6nddg5ywvs3v0k8cvxdwas38mfwgbr3rs4fdsbps90k9r")))) - (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") - (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-formgrep - (sbcl-package->cl-source-package sbcl-formgrep)) - -(define-public ecl-formgrep - (sbcl-package->ecl-package sbcl-formgrep)) - -(define-public sbcl-lmdb - (let ((commit "f439b707939a52769dc9747838ff4a616fab14a3") - (revision "0")) - (package - (name "sbcl-lmdb") + (name "sbcl-which") (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/antimer/lmdb") + (url "https://github.com/eudoxia0/which") (commit commit))) - (file-name (git-file-name "cl-lmdb" version)) + (file-name (git-file-name "cl-which" version)) (sha256 - (base32 "0akvimmvd4kcx6gh1j1dzvcclhc0jc4hc9vkh3ldgzb8wyf4vl8q")))) + (base32 "127pm9h4rm4w9aadw5yvamnfzhk2rr69kchx10rf9k7sk7izqqfk")))) (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)) + (list sbcl-cl-fad sbcl-path-parse)) (native-inputs - (list sbcl-try)) - (home-page "https://github.com/antimer/lmdb") - (synopsis "LMDB bindings for Common Lisp") + (list sbcl-fiveam)) + (home-page "https://github.com/eudoxia0/which") + (synopsis "The which command 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.") + "This package provides an implementation of the @code{which} UNIX +command in Common Lisp.") (license license:expat)))) -(define-public cl-lmdb - (sbcl-package->cl-source-package sbcl-lmdb)) +(define-public cl-which + (sbcl-package->cl-source-package sbcl-which)) -(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 ecl-which + (sbcl-package->ecl-package sbcl-which)) -(define-public cl-listopia - (sbcl-package->cl-source-package sbcl-listopia)) +(define-public sbcl-wild-package-inferred-system + (let ((commit "800b5f89b61cc4a0a9cf14706fd3f7e7fcd3e539") + (revision "0")) + (package + (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/privet-kitty/wild-package-inferred-system") + (commit commit))) + (file-name (git-file-name "cl-wild-package-inferred-system" version)) + (sha256 + (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 ecl-listopia - (sbcl-package->ecl-package sbcl-listopia)) +(define-public cl-wild-package-inferred-system + (sbcl-package->cl-source-package sbcl-wild-package-inferred-system)) -(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 ecl-wild-package-inferred-system + (sbcl-package->ecl-package sbcl-wild-package-inferred-system)) -(define-public cl-clog - (sbcl-package->cl-source-package sbcl-clog)) +(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 ecl-clog - (sbcl-package->ecl-package sbcl-clog)) +(define-public cl-with-user-abort + (sbcl-package->cl-source-package sbcl-with-user-abort)) -(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 +(define-public ecl-with-user-abort + (sbcl-package->ecl-package sbcl-with-user-abort)) -@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 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)))) -@item List all bindings matching a given prefix. (Also known as which-key in -Emacs.) +(define-public cl-woo + (sbcl-package->cl-source-package sbcl-woo)) -@item List the bindings associated to a command. +(define-public ecl-woo + (sbcl-package->ecl-package sbcl-woo)) -@item Support multiple inheritance. +(define-public sbcl-wordnet + (let ((commit "8cd0db8f5e84e7a930fa74e590ecddf75cd8e5d6") + (revision "0")) + (package + (name "sbcl-wordnet") + (version (git-version "0.0.1" 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)))) + (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") + (description + "This software provides an interface by which Common Lisp programs can +access lexicographic data from WordNet.") + (license license:expat)))) -@item Support keycode. +(define-public cl-wordnet + (sbcl-package->cl-source-package sbcl-wordnet)) -@item Validate keyspec at compile time. +(define-public ecl-wordnet + (sbcl-package->ecl-package sbcl-wordnet)) -@item define-key can set multiple bindings in a single call. +(define-public sbcl-wu-decimal + (let ((commit "5b348bdb32a0f83e80e17aa68cd51787ae8c8a45") + (revision "0")) + (package + (name "sbcl-wu-decimal") + (version (git-version "2.0.0" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/Wukix/wu-decimal") + (commit commit))) + (file-name (git-file-name "cl-wu-decimal" version)) + (sha256 + (base32 "1p7na4hic7297amwm4idfwkyx664ny8cdssncyra37pmv4wzp8dm")))) + (build-system asdf-build-system/sbcl) + (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)))) -@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 cl-wu-decimal + (sbcl-package->cl-source-package sbcl-wu-decimal)) -@item Translate keyspecs as a fallback. For instance if shift-a is not bound, -check A. +(define-public ecl-wu-decimal + (sbcl-package->ecl-package sbcl-wu-decimal)) -@item Behaviour can be customized with global parameters such as -*print-shortcut*. +(define-public sbcl-xhtmlambda + (let ((commit "c86376bccebf77ca428e8033df2ba7d8450ea1e8") + (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)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://gitlab.common-lisp.net/xhtmlambda/XHTMLambda") + (commit commit))) + (file-name (git-file-name "cl-xhtmlambda" version)) + (sha256 + (base32 "0narbzz06ry1wn048avm1fwihvnjvvc4wfcv5hmdazkilpvnqz2y")))) + (build-system asdf-build-system/sbcl) + (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)))) -@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 cl-xhtmlambda + (sbcl-package->cl-source-package sbcl-xhtmlambda)) (define-public sbcl-xkbcommon (let ((commit "aa9513d93f42d7816f88dd1bd8bd21375e7d7512") @@ -28069,2187 +30566,399 @@ instead of #'FOO. (define-public ecl-xkbcommon (sbcl-package->ecl-package sbcl-xkbcommon)) -(define-public sbcl-njson +(define-public sbcl-xml-emitter (package - (name "sbcl-njson") - (version "1.2.2") + (name "sbcl-xml-emitter") + (version "1.1.0") (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/atlas-engineer/njson") + (url "https://github.com/VitoVan/xml-emitter") (commit version))) - (file-name (git-file-name "cl-njson" version)) + (file-name (git-file-name "cl-xml-emitter" version)) (sha256 (base32 - "05v5bk3l47mds4ihxs8jlqm19gqq7hb4q0161bgg99w9847l63lk")))) + "1w9yx8gc4imimvjqkhq8yzpg3kjrp2y37rjix5c1lnz4s7bxvhk9")))) (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") + (native-inputs (list sbcl-1am)) + (inputs (list sbcl-cl-utilities)) + (synopsis "Common lisp library for emitting XML output") (description - "NJSON aims to make it convenient for one to decode, encode, -and process JSON data, in the minimum keystrokes/minutes possible. + "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))) -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-xml-emitter + (sbcl-package->cl-source-package sbcl-xml-emitter)) -@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 ecl-xml-emitter + (sbcl-package->ecl-package sbcl-xml-emitter)) -@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-nactivitypub +(define-public sbcl-xmls (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")))) + (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) - (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. + (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))) -Features: -@itemize +(define-public cl-xmls + (sbcl-package->cl-source-package sbcl-xmls)) -@item Parsing and un-parsing ActivityStreams JSON-LD objects to/from CLOS -objects with convenient accessors on those. +(define-public ecl-xmls + (sbcl-package->ecl-package sbcl-xmls)) -@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-nactivitypub - (sbcl-package->cl-source-package sbcl-nactivitypub)) - -(define-public ecl-nactivitypub - (sbcl-package->ecl-package sbcl-nactivitypub)) - -(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-utils-kt - (let ((commit "4adfe2889036ab5ffdd3cc2182ca2cc692bf11ff")) +(define-public sbcl-xpath + ;; No release. + (let ((commit "d364da693a534e23bd5eb3a85420e9c25e6c75b3")) (package - (name "sbcl-utils-kt") - (version (git-version "2007-12-02" "1" commit)) + (name "sbcl-xpath") + (version (git-version "0.1" "1" commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/kennytilton/utils-kt") + (url "https://github.com/sharplispers/xpath/") (commit commit))) - (file-name (git-file-name "cl-utils-kt" version)) + (file-name (git-file-name name 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-utils-kt - (sbcl-package->cl-source-package sbcl-utils-kt)) - -(define-public ecl-utils-kt - (sbcl-package->ecl-package sbcl-utils-kt)) - -(define-public sbcl-cells - (let ((commit "e8542b17fddd6340c1e237ce482a52327c8ead8e")) - (package - (name "sbcl-cells") - (version (git-version "3.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/kennytilton/cells") - (commit commit))) - (file-name (git-file-name "cl-cells" version)) - (sha256 - (base32 "0rkzvwq38lwb1045w54kw020pb9i63hxiawwhqkf8k1inhak3fdk")))) + (base32 "1fb03fgnzrvh22lw1jdg04pmyja5fib5n42rzwp5mhr829yvxkvp")))) (build-system asdf-build-system/sbcl) (inputs - (list sbcl-utils-kt)) - (arguments - ;; Tests fail with #. - '(#:tests? #f)) - (home-page "https://github.com/kennytilton/cells") - (synopsis "Common Lisp implementation of the dataflow programming paradigm") + (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 - "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 cl-cells - (sbcl-package->cl-source-package sbcl-cells)) - -(define-public ecl-cells - (sbcl-package->ecl-package sbcl-cells)) - -(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/stylewarning/cl-algebraic-data-type") - (commit commit))) - (file-name (git-file-name "cl-algebraic-data-type" version)) - (sha256 - (base32 "1lnqxcv8pd5z8n0g5p2l0dbljx9pqiv18hxl0vhsh7ldhkrjv2jx")))) - (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)))) - -(define-public cl-algebraic-data-type - (sbcl-package->cl-source-package sbcl-cl-algebraic-data-type)) - -(define-public ecl-algebraic-data-type - (sbcl-package->ecl-package sbcl-cl-algebraic-data-type)) - -(define-public sbcl-screamer - (let ((commit "ce50614024de090b376107668da5e53232540ec7")) - (package - (name "sbcl-screamer") - (version (git-version "0.0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/nikodemus/screamer/") - (commit commit))) - (file-name (git-file-name "cl-screamer" version)) - (sha256 - (base32 "1jl42pl6kwkiq71d0naf3r1mn1qy89ndimfgiz58c4g66xbjb7kx")))) - (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") - (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)))) - -(define-public cl-screamer - (sbcl-package->cl-source-package sbcl-screamer)) - -(define-public ecl-screamer - (sbcl-package->ecl-package sbcl-screamer)) - -(define-public sbcl-clache - (let ((commit "112976729565e1035532389ca25090ae99badd07")) - (package - (name "sbcl-clache") - (version (git-version "0.2.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/html/clache/") - (commit commit))) - (file-name (git-file-name "cl-clache" version)) - (sha256 - (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-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 - "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-clache - (sbcl-package->cl-source-package sbcl-clache)) - -(define-public ecl-clache - (sbcl-package->ecl-package sbcl-clache)) - -(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-filtered-functions - (let ((commit "130f69e7b9e1051bf569ef63364b09a3873f0ced")) - (package - (name "sbcl-filtered-functions") - (version (git-version "0.2.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/pcostanza/filtered-functions") - (commit commit))) - (file-name (git-file-name "cl-filtered-functions" version)) - (sha256 - (base32 "0m13k8pl0gfll8ss83c0z3gax7zrrw2i4s26451jfbka1xr4fgy9")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-closer-mop)) - (home-page "https://github.com/pcostanza/filtered-functions") - (synopsis "Extension of CLOS generic function invocation") - (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)))) - -(define-public cl-filtered-functions - (sbcl-package->cl-source-package sbcl-filtered-functions)) - -(define-public ecl-filtered-functions - (sbcl-package->ecl-package sbcl-filtered-functions)) - -(define-public sbcl-defstar - (let ((commit "132829dac9f84fa7202a0c5793aa6accb8d2662a")) - (package - (name "sbcl-defstar") - (version (git-version "1.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "http://bitbucket.org/eeeickythump/defstar/") - (commit commit))) - (file-name (git-file-name "cl-defstar" version)) - (sha256 - (base32 "0n6m3aqvdfnsrhlhqjcy72d1i55lbkjg13ij5c7vw003p1n78wxi")))) - (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)))) - -(define-public cl-defstar - (sbcl-package->cl-source-package sbcl-defstar)) - -(define-public ecl-defstar - (sbcl-package->ecl-package sbcl-defstar)) - -(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.") + "This library is an implementation of the XML Path Language (XPath) +Version 1.0.") (license license:bsd-2)))) -(define-public cl-dynamic-mixins - (sbcl-package->cl-source-package sbcl-dynamic-mixins)) +;; 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 ecl-dynamic-mixins - (sbcl-package->ecl-package sbcl-dynamic-mixins)) - -(define-public sbcl-stealth-mixin - (let ((commit "2f853fcead554221d4be3b10522b502ea729e944") - (revision "0")) +(define-public sbcl-xsubseq + (let ((commit "5ce430b3da5cda3a73b9cf5cee4df2843034422b") + (revision "1")) (package - (name "sbcl-stealth-mixin") + (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-yxorp + (let ((commit "c306898a467995e123a22316c9b79fcac442415b") + (revision "4")) + (package + (name "sbcl-yxorp") + (version (git-version "0.4" revision commit)) + (source + (origin + (method git-fetch) + (uri (git-reference + (url "https://github.com/charJe/cl-yxorp") + (commit commit))) + (file-name (git-file-name "cl-yxorp" version)) + (sha256 + (base32 "0ll1s9w29yhhgqssgiw58fcapw4n040gkvpz4sxwv3q2v60rbidj")))) + (build-system asdf-build-system/sbcl) + (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") + (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-yxorp + (sbcl-package->cl-source-package sbcl-yxorp)) + +(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 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-zip") (version (git-version "0.0.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/robert-strandh/Stealth-mixin") + (url "https://github.com/bluelisp/zip") (commit commit))) - (file-name (git-file-name "cl-stealth-mixin" version)) (sha256 - (base32 "0ar9cdmbmdnqz1ywpw34n47hlh0vqmb6pl76f5vbfgip3c81xwyi")))) + (base32 "0s08a6fq182fzsbfyvihqbdllq6gxcwkvphxnrd9wwz65dhg5y66")) + (file-name (git-file-name "cl-zip" version)))) (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)))) + (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-stealth-mixin - (sbcl-package->cl-source-package sbcl-stealth-mixin)) +(define-public cl-zip + (sbcl-package->cl-source-package sbcl-zip)) -(define-public ecl-stealth-mixin - (sbcl-package->ecl-package sbcl-stealth-mixin)) +(define-public ecl-zip + (sbcl-package->ecl-package sbcl-zip)) -(define-public sbcl-sealable-metaobjects - (let ((commit "e09ec97252e0844528f61abdc0c7ee256875f8ee")) - (package - (name "sbcl-sealable-metaobjects") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/marcoheisig/sealable-metaobjects/") - (commit commit))) - (file-name (git-file-name "cl-sealable-metaobjects" version)) - (sha256 - (base32 "0hz1ivlpfhnk1w2cw4q2i000j2dc7maay06ndzziyywg7li6zf2p")))) - (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") - (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)))) - -(define-public cl-sealable-metaobjects - (sbcl-package->cl-source-package sbcl-sealable-metaobjects)) - -(define-public ecl-sealable-metaobjects - (sbcl-package->ecl-package sbcl-sealable-metaobjects)) - -(define-public sbcl-fast-generic-functions - (let ((commit "9c307cd28af6453e45038ac3510de3123ff23743")) - (package - (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/marcoheisig/fast-generic-functions/") - (commit commit))) - (file-name (git-file-name "cl-fast-generic-functions" version)) - (sha256 - (base32 "16hf9bi2p5s77p3m3aqsihcd9iicqjhhxxpsarjv93c41qs54yad")))) - (build-system asdf-build-system/sbcl) - (inputs - (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 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-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 ecl-compiler-macro-notes - (sbcl-package->ecl-package sbcl-compiler-macro-notes)) - -(define-public sbcl-ctype - (let ((commit "4fc4c5ae44c435ed82556969f698005bee50101c")) - (package - (name "sbcl-ctype") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/s-expressionists/ctype") - (commit commit))) - (file-name (git-file-name "cl-ctype" 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))) - -(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-slot-extra-options - (let ((commit "29517d980325cd63744f1acf4cfe5c8ccec2b318")) - (package - (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/some-mthfka/slot-extra-options/") - (commit commit))) - (file-name (git-file-name "cl-slot-extra-options" version)) - (sha256 - (base32 "1b2swhjjs0w1034cy045q8l3ndmci7rjawka39q23vncy6d90497")))) - (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") - (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+)))) - -(define-public cl-slot-extra-options - (sbcl-package->cl-source-package sbcl-slot-extra-options)) - -(define-public ecl-slot-extra-options - (sbcl-package->ecl-package sbcl-slot-extra-options)) - -(define-public sbcl-slite - (let ((commit "942a95330592d30be5ac02fb1b697fb14ccbf1af") - (revision "0")) - (package - (name "sbcl-slite") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/tdrhq/slite/") - (commit commit))) - (file-name (git-file-name "slite" version)) - (sha256 - (base32 "0b4c4vs1zlhcvr9flv8bx76v9hrwc9qmazmp60407q7cghn0k8zk")))) - (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 ") - (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)) - -(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-sb-cga - (let ((commit "9a554ea1c01cac998ff7eaa5f767bc5bcdc4c094")) - (package - (name "sbcl-sb-cga") - (version (git-version "1.0.1" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/nikodemus/sb-cga/") - (commit commit))) - (file-name (git-file-name "cl-sb-cga" version)) - (sha256 - (base32 "1y54qlwfrhch9aghk7nsbdx7x2qsvgsws1g2k631l9dsgdakw4w8")))) - (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") - (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)))) - -(define-public cl-sb-cga - (sbcl-package->cl-source-package sbcl-sb-cga)) - -(define-public ecl-sb-cga - (sbcl-package->ecl-package sbcl-sb-cga)) - -(define-public sbcl-mathkit - (let ((commit "fd884f94b36ef5e9bc19459ad0b3cda6303d2a2a")) - (package - (name "sbcl-mathkit") - (version (git-version "0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lispgames/mathkit/") - (commit commit))) - (file-name (git-file-name "cl-mathkit" version)) - (sha256 - (base32 "174y6ndmf52h8sml87qjfl48llmynvdizzk2h0mr85zbaysx73i3")))) - (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") - (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)))) - -(define-public cl-mathkit - (sbcl-package->cl-source-package sbcl-mathkit)) - -(define-public ecl-mathkit - (sbcl-package->ecl-package sbcl-mathkit)) - -(define-public sbcl-rucksack - (let ((commit "89278f88513ef328d290aa8b2baa06d63b44a9b1") - (revision "0")) - (package - (name "sbcl-rucksack") - (version (git-version "0.1.20" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/arieltan/rucksack") - (commit commit))) - (file-name (git-file-name "cl-rucksack" 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)))) - -(define-public cl-rucksack - (sbcl-package->cl-source-package sbcl-rucksack)) - -(define-public sbcl-sdl2kit - (let ((commit "aae663224a10ece2b0c374aa5942a3f0bc1b3c2f")) - (package - (name "sbcl-sdl2kit") - (version (git-version "0.0.0" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/lispgames/sdl2kit/") - (commit commit))) - (file-name (git-file-name "cl-sdl2kit" version)) - (sha256 - (base32 "10ymmxqsvdn7ndda9k2qcixj75l7namgqdxc5y2w3v5r1313fy2d")))) - (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)))) - -(define-public cl-sdl2kit - (sbcl-package->cl-source-package sbcl-sdl2kit)) - -(define-public ecl-sdl2kit - (sbcl-package->ecl-package sbcl-sdl2kit)) - -(define-public sbcl-glkit - (let ((commit "0d8e7c5fed4231f2177afcf0f3ff66f196ed6a46")) - (package - (name "sbcl-glkit") - (version (git-version "0.0" "1" 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)) - (sha256 - (base32 "1x3y5jcr1f0v9sgn3y5b7b8fhgd6vv37nz73016gdwh511idi8jn")))) - (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)))) - -(define-public cl-glkit - (sbcl-package->cl-source-package sbcl-glkit)) - -(define-public ecl-glkit - (sbcl-package->ecl-package sbcl-glkit)) - -(define-public sbcl-cl-fond - (let ((commit "dac975cbc73f231b400d5b8d8539b16330239a4a") +(define-public sbcl-zippy + (let ((commit "ed9bca591ded2ff27a9ac95d9a60827773a0e707") (revision "1")) (package - (name "sbcl-cl-fond") + (name "sbcl-zippy") (version (git-version "1.1.0" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/Shirakumo/cl-fond") + (url "https://github.com/Shinmera/zippy/") (commit commit))) - (file-name (git-file-name "cl-fond" version)) (sha256 - (base32 "03ygcw1azb44bhdsqcq99xi4ci0by76ap5jf5l2d1vfxq04v8grq")))) + (base32 "16cvyyf2nzd9r3fcy4w6d5wh8n3x833wldmrxmnzd3k2xrkhzfl9")) + (file-name (git-file-name "zippy" version)))) (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.") - (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 ecl-doplus - (sbcl-package->ecl-package sbcl-doplus)) - -(define-public sbcl-trees - (let ((commit "7b06048af0248c4302088c758208276f9faf2beb")) - (package - (name "sbcl-trees") - (version (git-version "0.11" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/froydnj/trees/") - (commit commit))) - (file-name (git-file-name "cl-trees" version)) - (sha256 - (base32 "1xvydf3qc17rd7ia8sffxcpclgm3l0iyhx8k72ddk59v3pg5is4k")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/froydnj/trees/") - (synopsis "Binary trees in normal and balanced flavors") - (description - "This package implements binary trees of various kinds, presenting a -uniform interface to them all.") - (license license:bsd-3)))) - -(define-public cl-trees - (sbcl-package->cl-source-package sbcl-trees)) - -(define-public ecl-trees - (sbcl-package->ecl-package sbcl-trees)) - -(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. - -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 cl-cl-geometry - (sbcl-package->cl-source-package sbcl-cl-geometry)) - -(define-public ecl-cl-geometry - (sbcl-package->ecl-package sbcl-cl-geometry)) - -(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-quicklisp-stats - (let ((commit "953b45c2212ae513d48a611d3dd09c846a6102cd") - (revision "0")) - (package - (name "sbcl-quicklisp-stats") - (version (git-version "0.0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/phoe/quicklisp-stats") - (commit commit))) - (file-name (git-file-name "cl-quicklisp-stats" version)) - (sha256 - (base32 "0v8dgmlgd283n1g486q4sj2mghgdvgywg2nqp43nnrfc04mkvgc0")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-alexandria - sbcl-drakma - sbcl-split-sequence)) - (arguments - `(#:tests? #f)) ; There are no tests. - (synopsis "Fetches and operates on Quicklisp download statistics") - (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/") - (license license:expat)))) - -(define-public cl-quicklisp-stats - (sbcl-package->cl-source-package sbcl-quicklisp-stats)) - -(define-public ecl-quicklisp-stats - (sbcl-package->ecl-package sbcl-quicklisp-stats)) - -(define-public sbcl-sketch - ;; No release in years. - (let ((commit "4cc00b08e202c7adda41391463096cf9df1705c3")) - (package - (name "sbcl-sketch") - (version (git-version "2017-11" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/vydd/sketch") - (commit commit))) - (file-name (git-file-name "cl-sketch" version)) - (sha256 - (base32 "1qrnma8yvmxps9rz3pvlzsir37namppsldijdlr4110pcwi9j9h6")))) - (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") - (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)) - -(define-public ecl-sketch - (sbcl-package->ecl-package sbcl-sketch)) - -(define-public sbcl-cl-cron - (let ((commit "092aef5d5666fb43c04258e4043f609670a20456") - (revision "0")) - (package - (name "sbcl-cl-cron") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/ciel-lang/cl-cron") - (commit commit))) - (file-name (git-file-name "cl-cron" version)) - (sha256 - (base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d")))) - (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") - (description - "@code{cl-cron} is a simple tool that provides cron like facilities -directly inside of Common Lisp.") - (license license:gpl3+)))) - -(define-public cl-cron - (sbcl-package->cl-source-package sbcl-cl-cron)) - -(define-public ecl-cl-cron - (sbcl-package->ecl-package sbcl-cl-cron)) - -(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 cl-string-pokemonize - (sbcl-package->cl-source-package sbcl-string-pokemonize)) - -(define-public ecl-string-pokemonize - (sbcl-package->ecl-package sbcl-string-pokemonize)) - -(define-public sbcl-binary-types - (let ((commit "9ec42042a50403961c08179a892ae3de725b1d7a")) - (package - (name "sbcl-binary-types") - (version (git-version "1.2" "1" commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/frodef/binary-types/") - (commit commit))) - (file-name (git-file-name "binary-types" version)) - (sha256 - (base32 "0kp4xwblfxh7gmgqc38k9xzrqlcr0q1jm5167ma1pajdxd3182j8")))) - (build-system asdf-build-system/sbcl) - (home-page "https://github.com/frodef/binary-types/") - (synopsis "Read and write binary records for 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)))) - -(define-public cl-binary-types - (sbcl-package->cl-source-package sbcl-binary-types)) - -(define-public ecl-binary-types - (sbcl-package->ecl-package sbcl-binary-types)) - -(define-public sbcl-trivial-custom-debugger - (let ((commit "a560594a673bbcd88136af82086107ee5ff9ca81")) - (package - (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/phoe/trivial-custom-debugger") - (commit commit))) - (file-name (git-file-name "trivial-custom-debugger" version)) - (sha256 - (base32 "1iri5wsp9sc1f5q934cj87zd79r5dc8fda0gl7x1pz95v0wx28yk")))) - (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") - (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)))) - -(define-public cl-trivial-custom-debugger - (sbcl-package->cl-source-package sbcl-trivial-custom-debugger)) - -(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-safe-read - (let ((commit "d25f08597b34d7aaeb86b045d57f7b020a5bb5f0") - (revision "0")) - (package - (name "sbcl-safe-read") - (version (git-version "0.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/phoe/safe-read") - (commit commit))) - (file-name (git-file-name "cl-safe-read" version)) - (sha256 - (base32 "1r9k8danfnqgpbn2vb90n6wdc6jd92h1ig565yplrbh6232lhi26")))) - (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") - (description - "This package provides a safer variant of @code{READ} secure against -internbombing, excessive input and macro characters.") - (license license:bsd-2)))) - -(define-public cl-safe-read - (sbcl-package->cl-source-package sbcl-safe-read)) - -(define-public ecl-safe-read - (sbcl-package->ecl-package sbcl-safe-read)) - -(define-public sbcl-portable-condition-system - (let ((commit "1307ec146d227a9d8ea42312c1ba2a5206a9eb3c") - (revision "0")) - (package - (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/phoe/portable-condition-system") - (commit commit))) - (file-name (git-file-name name version)) - (sha256 - (base32 "099lb9f4bavj95wik99wla5rf6fk1gdw9pvn0cqlaf0wf20csd3h")))) - (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") - (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 cl-portable-condition-system - (sbcl-package->cl-source-package sbcl-portable-condition-system)) - -(define-public ecl-portable-condition-system - (sbcl-package->ecl-package sbcl-portable-condition-system)) - -(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: + (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 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. +@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") - (license license:bsd-3))) + (home-page "https://shinmera.github.io/zippy/") + (license license:zlib)))) -(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 cl-zippy + (sbcl-package->cl-source-package sbcl-zippy)) -(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 ecl-zippy + (sbcl-package->ecl-package sbcl-zippy)) -(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 +(define-public sbcl-zpb-exif (package - (name "sbcl-ndebug") - (version "0.2.0") + (name "sbcl-zpb-exif") + (version "1.2.5") (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)) + (url "https://github.com/xach/zpb-exif") + (commit (string-append "release-" version)))) + (file-name (git-file-name "cl-zpb-exif" version)) (sha256 - (base32 "1sndg4qclkdr53xkxrfjskx8gcqx0bn4r0vslzfx1kgznl4hbf1d")))) + (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-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))) + (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-ndebug - (sbcl-package->cl-source-package sbcl-ndebug)) +(define-public cl-zpng + (sbcl-package->cl-source-package sbcl-zpng)) -(define-public ecl-ndebug - (sbcl-package->ecl-package sbcl-ndebug)) - -(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 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-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-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 cl-enhanced-defclass - (sbcl-package->cl-source-package sbcl-enhanced-defclass)) - -(define-public ecl-enhanced-defclass - (sbcl-package->ecl-package sbcl-enhanced-defclass)) - -(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 cl-object-class - (sbcl-package->cl-source-package sbcl-object-class)) - -(define-public ecl-object-class - (sbcl-package->ecl-package sbcl-object-class)) - -(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-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-inheriting-readers - (sbcl-package->cl-source-package sbcl-inheriting-readers)) - -(define-public ecl-inheriting-readers - (sbcl-package->ecl-package sbcl-inheriting-readers)) - -(define-public sbcl-simple-guess - (let ((commit "34744e3200a96e6aba285d70f91cdbd6c25508a6") - (revision "0")) - (package - (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-wild-package-inferred-system - (let ((commit "800b5f89b61cc4a0a9cf14706fd3f7e7fcd3e539") - (revision "0")) - (package - (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/privet-kitty/wild-package-inferred-system") - (commit commit))) - (file-name (git-file-name "cl-wild-package-inferred-system" version)) - (sha256 - (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-wild-package-inferred-system - (sbcl-package->cl-source-package sbcl-wild-package-inferred-system)) - -(define-public ecl-wild-package-inferred-system - (sbcl-package->ecl-package sbcl-wild-package-inferred-system)) - -(define-public sbcl-fakenil - (package - (name "sbcl-fakenil") - (version "1.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Hexstream/fakenil") - (commit (string-append "v" version)))) - (file-name (git-file-name "cl-fakenil" version)) - (sha256 - (base32 "0ipqax3sgcs1dsgxz8d2pmfg324k6l35pn0nz89w5jl02fia61l3")))) - (build-system asdf-build-system/sbcl) - (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-fakenil - (sbcl-package->cl-source-package sbcl-fakenil)) - -(define-public ecl-fakenil - (sbcl-package->ecl-package sbcl-fakenil)) - -(define-public sbcl-evaled-when - (let ((commit "c59f8ab20b846cac81d4be80d056a3d65676e8eb") - (revision "0")) - (package - (name "sbcl-evaled-when") - (version (git-version "1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Hexstream/evaled-when") - (commit commit))) - (file-name (git-file-name "cl-evaled-when" version)) - (sha256 - (base32 "07g1a50aairvsj57issb18si5a9r3skpbk05nlixmlj0mva3gkl3")))) - (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)))) - -(define-public cl-evaled-when - (sbcl-package->cl-source-package sbcl-evaled-when)) - -(define-public ecl-evaled-when - (sbcl-package->ecl-package sbcl-evaled-when)) - -(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-boolean - (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)) - -(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 cl-cesdi - (sbcl-package->cl-source-package sbcl-cesdi)) - -(define-public ecl-cesdi - (sbcl-package->ecl-package sbcl-cesdi)) - -(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-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-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-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 cl-definitions-systems - (sbcl-package->cl-source-package sbcl-definitions-systems)) - -(define-public ecl-definitions-systems - (sbcl-package->ecl-package sbcl-definitions-systems)) - -(define-public sbcl-numerical-utilities - (let ((commit "44f45ba952b35675640630e40cf90df6f8279746") - (revision "0")) - (package - (name "sbcl-numerical-utilities") - (version (git-version "1.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/numerical-utilities") - (commit commit))) - (file-name (git-file-name "cl-numerical-utilities" version)) - (sha256 - (base32 "1dwz8zxhqzi31qp863zj1cn1lgljny14snycb9nk871qs121kmsd")))) - (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") - (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)))) - -(define-public cl-numerical-utilities - (sbcl-package->cl-source-package sbcl-numerical-utilities)) - -(define-public ecl-numerical-utilities - (sbcl-package->ecl-package sbcl-numerical-utilities)) +(define-public ecl-zpng + (sbcl-package->ecl-package sbcl-zpng)) (define-public sbcl-zr-utils (let ((commit "e7eaffcb71811f6e1ab85fb15a079bcac4038eeb") @@ -30296,824 +31005,113 @@ Zombie Raptor game engine project.") (define-public ecl-zr-utils (sbcl-package->ecl-package sbcl-zr-utils)) -(define-public sbcl-draw-cons-tree - (let ((commit "04334f5885a85cd7127db8dda3f6d6686a0438b1") - (revision "0")) +(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-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/phoe/draw-cons-tree") - (commit commit))) - (file-name (git-file-name "cl-draw-cons-tree" version)) - (sha256 - (base32 "1523bdkq8a5qn0qp9q7r16w47y6jb0hkfj7hbjfj6mg3xv001s3x")))) - (build-system asdf-build-system/sbcl) - (native-inputs - (list sbcl-fiveam sbcl-split-sequence)) - (inputs - (list sbcl-alexandria)) - (synopsis "Draw an ascii picture of a cons tree") - (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)))) - -(define-public cl-draw-cons-tree - (sbcl-package->cl-source-package sbcl-draw-cons-tree)) - -(define-public ecl-draw-cons-tree - (sbcl-package->ecl-package sbcl-draw-cons-tree)) - -(define-public sbcl-triads - (let ((commit "840b025bf3d65cc5eaead4542a02a3ca6d77c2b6") - (revision "0")) - (package - (name "sbcl-triads") - (version (git-version "0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/charJe/triads") - (commit commit))) - (file-name (git-file-name "cl-triads" version)) - (sha256 - (base32 "146mwshynhdw82m2nxrcjvf1nk0z3fn6ywcd2vqxkly5qricc53w")))) - (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"))))))) - (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-triads - (sbcl-package->cl-source-package sbcl-triads)) - -(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-music-spelling - (let ((commit "a2d492af440ad30a21042140cf8ffce4b73fbd42") - (revision "0")) - (package - (name "sbcl-music-spelling") + (name "sbcl-zsort") (version (git-version "0.1" revision commit)) (source (origin (method git-fetch) (uri (git-reference - (url "https://github.com/ntrocado/music-spelling") + (url "https://github.com/jorgetavares/zsort") (commit commit))) - (file-name (git-file-name "cl-music-spelling" version)) + (file-name (git-file-name "cl-zsort" version)) (sha256 - (base32 "0fgahb0jjr4sp2739d55gylmx8alsghnx3spyaqfqci4cxfrys52")))) + (base32 "1vyklyh99712zsll4qi0m4mm8yb1nz04403vl8i57bjv5p5max49")))) (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)))) - -(define-public cl-music-spelling - (sbcl-package->cl-source-package sbcl-music-spelling)) - -(define-public ecl-music-spelling - (sbcl-package->ecl-package sbcl-music-spelling)) - -(define-public sbcl-closure-template - ;; There are no releases since 2015. - (let ((commit "f1983aa525045691e128027d2a2d74831c873d6e") - (revision "0")) - (package - (name "sbcl-closure-template") - (version (git-version "0.2.1" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/archimag/cl-closure-template") - (commit commit))) - (file-name (git-file-name "cl-closure-template" version)) - (sha256 - (base32 "16h0fs6bjjd4n9pbkwcprpgyj26vsw2akk3q08m7xmsmqi05dppv")))) - (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-alexandria)) + (home-page "https://github.com/jorgetavares/zsort") + (synopsis "Collection of portable sorting algorithms 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))) - -(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-smug - (let ((commit "647a2428df297e1dd183ba7c19574bdb1320ae79") - (revision "0")) - (package - (name "sbcl-smug") - (version (git-version "0.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/drewc/smug") - (commit commit))) - (file-name (git-file-name "cl-smug" 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)))) - -(define-public cl-smug - (sbcl-package->cl-source-package sbcl-smug)) - -(define-public ecl-smug - (sbcl-package->ecl-package sbcl-smug)) - -(define-public sbcl-cl-variates - (let ((commit "4e7548754d8a8731a42487fae31174db4bf36d47") - (revision "0")) - (package - (name "sbcl-cl-variates") - (version "0.9.0") - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://gitlab.common-lisp.net/cl-variates/cl-variates") - (commit commit))) - (file-name (git-file-name "cl-variates" version)) - (sha256 - (base32 "03wnvfi3yfflpvi0mr732r834msij4vrwdbgf6csh0b8kqxl47zn")))) - (build-system asdf-build-system/sbcl) - ;; USE-PACKAGE # causes name-conflicts in - ;; # 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.") + "@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 cl-variates - (sbcl-package->cl-source-package sbcl-cl-variates)) +(define-public cl-zsort + (sbcl-package->cl-source-package sbcl-zsort)) -(define-public ecl-cl-variates - (sbcl-package->ecl-package sbcl-cl-variates)) +(define-public ecl-zsort + (sbcl-package->ecl-package sbcl-zsort)) -(define-public sbcl-cl-vorbis - (let ((commit "c5835cd7091aea9e2e389ad359d244542d637758") - (revision "0")) +(define-public sbcl-zstd + (let ((commit "134f058eee11512cf772a8d5b64364acf56a10b8") + (revision "1")) (package - (name "sbcl-cl-vorbis") - (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/cl-vorbis") + (url "https://codeberg.org/glv/cl-zstd") (commit commit))) - (file-name (git-file-name "cl-vorbis" version)) + (file-name (git-file-name "cl-zstd" 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 "1iqpi5v6fdm6xxc9l8zhk6kcgl8hgxiwk1ki2yx2j3j4kfvqv8j9")))) (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")))))))) + (native-inputs + (list sbcl-fiveam)) (inputs - (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 ecl-cl-vorbis - (sbcl-package->ecl-package sbcl-cl-vorbis)) - -(define-public cl-vorbis - (sbcl-package->cl-source-package sbcl-cl-vorbis)) - -(define-public sbcl-cephes - (let ((commit "d87146fa38c8425ffb5fe425eee5eb3e818bacd4") - (revision "0")) - (package - (name "sbcl-cephes") - (version (git-version "1.2" 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")))) - (build-system asdf-build-system/sbcl) - (inputs - (list sbcl-cffi)) + (list sbcl-cffi + sbcl-cl-octet-streams + (list zstd "lib"))) (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") + (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 package provides a common lisp CFFI wrapper for the SciPy version -of Cephes special functions.") - (license license:ms-pl)))) + "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 cl-cephes - (sbcl-package->cl-source-package sbcl-cephes)) +(define-public cl-zstd + (sbcl-package->cl-source-package sbcl-zstd)) -(define-public ecl-cephes - (sbcl-package->ecl-package sbcl-cephes)) - -(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-distributions - (let ((commit "ea72622073ee7e005dfdc621ce1e5a83b22bb39e") - (revision "0")) - (package - (name "sbcl-distributions") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/distributions") - (commit commit))) - (file-name (git-file-name "cl-distributions" version)) - (sha256 - (base32 "1fkzigd0s0s0mvszgmv04yc8jp9gm4812445hfh6kpz6cjy5zpsk")))) - (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)) - -(define-public sbcl-statistics - (let ((commit "94fc87a2bf81355a40ce3730b4ed77710ecfabaf") - (revision "0")) - (package - (name "sbcl-statistics") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/statistics") - (commit commit))) - (file-name (git-file-name "cl-statistics" version)) - (sha256 - (base32 "0is69w6iwh4hyzc5ndgb3i2331f677sa7kw5wy8pmx6hawbkgyir")))) - (build-system asdf-build-system/sbcl) - (native-inputs (list sbcl-clunit2)) - (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))))) - -(define-public cl-statistics - (sbcl-package->cl-source-package sbcl-statistics)) - -(define-public ecl-statistics - (sbcl-package->ecl-package sbcl-statistics)) - -(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 cl-data-frame - (sbcl-package->cl-source-package sbcl-data-frame)) - -;; 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-dfio - (let ((commit "5caf473acb9bc464839e87395724cbd941167915") - (revision "0")) - (package - (name "sbcl-dfio") - (version (git-version "1.0.2" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/dfio") - (commit commit))) - (file-name (git-file-name "cl-dfio" version)) - (sha256 - (base32 "1p53r7773939jnap518xp4b4wfvc1kbrz9jp6yd40xq0jpf9pbqg")))) - (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)))) - -(define-public cl-dfio - (sbcl-package->cl-source-package sbcl-dfio)) - -;; This depends on ecl-data-frame, which doesn't work yet. -;; (define-public ecl-dfio -;; (sbcl-package->ecl-package sbcl-dfio)) - -(define-public sbcl-lisp-stat - (let ((commit "357a0d2b5f68a5ff925776235c2b7455e12b78ba") - (revision "0")) - (package - (name "sbcl-lisp-stat") - (version (git-version "1.2.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Lisp-Stat/lisp-stat") - (commit commit))) - (file-name (git-file-name "cl-lisp-stat" version)) - (sha256 - (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-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 cl-lisp-stat - (sbcl-package->cl-source-package sbcl-lisp-stat)) - -;; 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-cl-modio - (let ((commit "2fd288af27b574f448357fa6de4b42acf44e2f11") - (revision "1")) - (package - (name "sbcl-cl-modio") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/cl-modio/") - (commit commit))) - (sha256 - (base32 "0hz87v81pi8kr2c7az30czpdf7v757lkzlsmdcc59p94pipca7m9")) - (file-name (git-file-name "cl-modio" 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)))) - -(define-public cl-modio - (sbcl-package->cl-source-package sbcl-cl-modio)) - -(define-public ecl-cl-modio - (sbcl-package->ecl-package sbcl-cl-modio)) - -(define-public sbcl-cl-steamworks - (let ((commit "9d6a4de653a8cc256ae35e0298912b518aa92ba3") - (revision "1")) - (package - (name "sbcl-cl-steamworks") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/cl-steamworks/") - (commit commit))) - (sha256 - (base32 "1fzj3rlqw1kwdlmh0ga0y71p2n1adflcamzx4yp9kga552c1db5j")) - (file-name (git-file-name "cl-steamworks" version)))) - (build-system asdf-build-system/sbcl) - (inputs - (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-steamworks - (sbcl-package->cl-source-package sbcl-cl-steamworks)) - -(define-public ecl-cl-steamworks - (sbcl-package->ecl-package sbcl-cl-steamworks)) - -(define-public sbcl-forge - (let ((commit "012324e251d91436f4a610e2fe2eb50674c3c3ce") - (revision "1")) - (package - (name "sbcl-forge") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shinmera/forge/") - (commit commit))) - (sha256 - (base32 "006vi2ihrn28pzrwa8b7axmv98bdaxzx7lacnh9pbacbjg3b7hb0")) - (file-name (git-file-name "forge" version)))) - (build-system asdf-build-system/sbcl) - (arguments - '(#:asd-systems '("forge-support" - "forge-communication" - "forge"))) - (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)))) - -(define-public forge - (sbcl-package->cl-source-package sbcl-forge)) - -(define-public sbcl-maiden - (let ((commit "164e8df1b513fcbf097315b51242d337c183a5ef") - (revision "1")) - (package - (name "sbcl-maiden") - (version (git-version "3.1.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/maiden/") - (commit commit))) - (sha256 - (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-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 maiden - (sbcl-package->cl-source-package sbcl-maiden)) - -(define-public sbcl-speechless - (let ((commit "50e9b03bdfc8a3bc0836a650d92de47b51c39834") - (revision "1")) - (package - (name "sbcl-speechless") - (version (git-version "1.0.0" revision commit)) - (source - (origin - (method git-fetch) - (uri (git-reference - (url "https://github.com/Shirakumo/speechless/") - (commit commit))) - (sha256 - (base32 "1k0kc2l98jyv04l48xnj38qwpddan80c7m41srjld64jkna0fhas")) - (file-name (git-file-name "speechless" version)))) - (build-system asdf-build-system/sbcl) - (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)) - -(define-public ecl-speechless - (sbcl-package->ecl-package sbcl-speechless)) - -;;; -;;; 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))