aboutsummaryrefslogtreecommitdiff
;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2015 David Thompson <davet@gnu.org>
;;; Copyright © 2016 Efraim Flashner <efraim@flashner.co.il>
;;; Copyright © 2018 Tobias Geerinckx-Rice <me@tobias.gr>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages pumpio)
  #:use-module (guix licenses)
  #:use-module (guix packages)
  #:use-module (guix download)
  #:use-module (guix git-download)
  #:use-module (guix build-system gnu)
  #:use-module (gnu packages aspell)
  #:use-module (gnu packages qt)
  #:use-module (gnu packages web))

(define-public pumpa
  (package
    (name "pumpa")
    (version "0.9.3")
    (source (origin
              (method git-fetch) ; no source tarballs
              (uri (git-reference
                    (url "https://source.pumpa.branchable.com/")
                    (commit (string-append "v" version))))
              (sha256
               (base32
                "14072vis539zjgryjr5a77j2cprxii5znyg3p01qbb11lijk9nj7"))
              (file-name (string-append name "-" version "-checkout"))))
    (build-system gnu-build-system)
    (arguments
     '(#:phases
       (modify-phases %standard-phases
         (replace 'configure
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (substitute* "src/util.cpp"
               (("buffio\\.h") "tidybuffio.h"))
             ;; Fix dependency tests.
             (substitute* "pumpa.pro"
               (("/usr/include/tidy\\.h")
                (search-input-file inputs "/include/tidy.h"))
               (("/usr/include/aspell.h")
                (search-input-file inputs "/include/aspell.h")))
             ;; Run qmake with proper installation prefix.
             (let ((prefix (string-append "PREFIX="
                                          (assoc-ref outputs "out"))))
               (invoke "qmake" prefix))
             #t)))))
    (inputs
     (list aspell qtbase-5 tidy-html))
    (synopsis "Qt-based pump.io client")
    (description "Pumpa is a simple pump.io client written in C++ and Qt.")
    (home-page "https://pumpa.branchable.com/")
    (license gpl3+)))
966d1bae8d9c2d0e8cd4a9dfbc8b7cf7af18d9'>Diffstat (limited to 'gnu')
-rw-r--r--gnu/packages/lisp-xyz.scm44206
1 files changed, 22102 insertions, 22104 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,911 +137,604 @@
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-19))
-(define-public sbcl-alexandria-plus
- (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5")
- (revision "0"))
+(define-public sbcl-3b-bmfont
+ (let ((commit "332c2262705f161627fc18add0310451a42799af")
+ (revision "3"))
(package
- (name "sbcl-alexandria-plus")
- ;; Version is stated in the ASD file.
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-3b-bmfont")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Symbolics/alexandria-plus")
+ (url "https://github.com/3b/3b-bmfont/")
(commit commit)))
- (file-name (git-file-name "cl-alexandria-plus" version))
+ (file-name (git-file-name "cl-3b-bmfont" version))
(sha256
- (base32 "1w9r19610h599303gqlx2x5n8mmdynss2gyl7xilg5h6v8z3hkfl"))))
+ (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-systems '("alexandria+")))
- (native-inputs
- (list sbcl-parachute))
+ `(#:asd-systems '("3b-bmfont"
+ "3b-bmfont/common"
+ "3b-bmfont/json"
+ "3b-bmfont/text"
+ "3b-bmfont/xml")))
(inputs
- (list sbcl-alexandria))
- (home-page "https://symbolics.github.io/alexandria-plus/")
- (synopsis "Conservative set of extensions to Alexandria utilities")
- (description
- "@code{cl-alexandria-plus} is a conservative set of extensions to
-@code{cl-alexandria} utilities.")
- (license license:ms-pl))))
-
-(define-public cl-alexandria-plus
- (sbcl-package->cl-source-package sbcl-alexandria-plus))
-
-(define-public ecl-alexandria-plus
- (sbcl-package->ecl-package sbcl-alexandria-plus))
-
-(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")
+ (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
- "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))
+ "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 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 ecl-3b-bmfont
+ (sbcl-package->ecl-package sbcl-3b-bmfont))
-(define-public cl-reader
- (sbcl-package->cl-source-package sbcl-reader))
+(define-public cl-3b-bmfont
+ (sbcl-package->cl-source-package sbcl-3b-bmfont))
-(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 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-st-json
- (let ((commit "4a0025bcc5b6921454822f1b9f38f697b4eeaf43")
- (revision "0"))
+(define-public sbcl-3bmd
+ (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5")
+ (revision "4"))
(package
- (name "sbcl-st-json")
+ (name "sbcl-3bmd")
(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-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")
+ (url "https://github.com/3b/3bmd")
(commit commit)))
- (file-name (git-file-name "cl-stdutils" version))
(sha256
- (base32 "16vxxphqdq8264x0aanm36x9r6d3ci1gjf4vf46mwl59gcff4wcj"))))
+ (base32 "12xqih1gnwsn1baqm7bq3kxss73phn06gvd0v1h1vwsjd1xgpq3g"))
+ (file-name (git-file-name "cl-3bmd" version))))
(build-system asdf-build-system/sbcl)
- (arguments '(#:tests? #f)) ; There are no tests.
+ (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 sbcl-cl-fad
- sbcl-cl-ppcre))
- (home-page "https://github.com/eslick/cl-stdutils/")
- (synopsis "Grab bag of Common Lisp utility functions")
+ (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 package provides a grab bag of miscellaneous Common Lisp
-utilities.")
- (license license:bsd-3))))
+ "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-stdutils
- (sbcl-package->cl-source-package sbcl-stdutils))
+(define-public cl-3bmd
+ (sbcl-package->cl-source-package sbcl-3bmd))
-(define-public ecl-stdutils
- (sbcl-package->ecl-package sbcl-stdutils))
+(define-public ecl-3bmd
+ (sbcl-package->ecl-package sbcl-3bmd))
-(define-public sbcl-langutils
- (let ((commit "38beec7a82eeb35b0bfb0824a41d13ed94fc648b")
- (revision "0"))
+(define-public sbcl-3bz
+ (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad")
+ (revision "1"))
(package
- (name "sbcl-langutils")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-3bz")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/eslick/cl-langutils")
+ (url "https://github.com/3b/3bz")
(commit commit)))
- (file-name (git-file-name "cl-langutils" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "15y9x5wkg3fqndc04w2sc650fnwimxp4gjgpv9xvvdm9x4v433x6"))))
+ (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4"))))
(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")
+ (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
- "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))))
+ "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-hash-set
- (sbcl-package->cl-source-package sbcl-hash-set))
+(define-public cl-3bz
+ (sbcl-package->cl-source-package sbcl-3bz))
-(define-public ecl-hash-set
- (sbcl-package->ecl-package sbcl-hash-set))
+(define-public ecl-3bz
+ (sbcl-package->ecl-package sbcl-3bz))
-(define-public sbcl-duologue
- (let ((commit "ea1ada244a81da65f85b548823c9a6d7c9c145e1")
+(define-public sbcl-3d-math
+ (let ((commit "3831b1706d225def95a7301ef48b393b563f0114")
(revision "0"))
(package
- (name "sbcl-duologue")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-3d-math")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/duologue")
+ (url "https://github.com/Shinmera/3d-math")
(commit commit)))
- (file-name (git-file-name "cl-duologue" version))
+ (file-name (git-file-name "cl-3d-math" version))
(sha256
- (base32 "1yg7f27im9h0m6jihcay1p7alfhzm9hafwm5dw5hsyacy8f2cwk2"))))
+ (base32 "052vzx5j7bag9dxvl0j0wrm244js1djldyn31rwxgkq7965rmi5r"))))
(build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-stefil))
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-alexandria
- sbcl-anaphora
- sbcl-chronicity
- sbcl-cl-ansi-text
- sbcl-cl-fad
- sbcl-clavier
- sbcl-drakma))
- (home-page "https://github.com/mmontone/duologue/")
- (synopsis "High level user interaction library")
+ (list sbcl-documentation-utils
+ sbcl-type-templates))
+ (home-page "https://shinmera.github.io/3d-math/")
+ (synopsis "Linear algebra for 2D and 3D computations")
(description
- "Duologue is high-level interaction library for Common Lisp. It features
-coloured printing via @code{cl-ansi-text} and readline completion.")
- (license (list license:expat
- ;; https://github.com/mmontone/duologue/issues/9
- license:gpl3+)))))
-
-(define-public cl-duologue
- (sbcl-package->cl-source-package sbcl-duologue))
-
-(define-public ecl-duologue
- (sbcl-package->ecl-package sbcl-duologue))
-
-(define-public sbcl-alea
- (package
- (name "sbcl-alea")
- (version "1.0")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/eXodiquas/alea")
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-alea" version))
- (sha256
- (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs (list sbcl-fiveam))
- (synopsis "Dice rolling library")
- (description
- "This package provides a Common Lisp library for dice rolling and working
-with dice-roll statistics.")
- (home-page "https://github.com/eXodiquas/alea")
- (license license:expat)))
+ "The @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-alea
- (sbcl-package->cl-source-package sbcl-alea))
+(define-public cl-3d-math
+ (sbcl-package->cl-source-package sbcl-3d-math))
-(define-public ecl-alea
- (sbcl-package->ecl-package sbcl-alea))
+(define-public ecl-3d-math
+ (sbcl-package->ecl-package sbcl-3d-math))
-(define-public sbcl-cf
- (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e")
+(define-public sbcl-3d-matrices
+ (let ((commit "b4f5a58299f8437fad2d77f0879c374e3430f4b5")
(revision "2"))
(package
- (name "sbcl-cf")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://codeberg.org/glv/cl-cf")
- (commit commit)))
- (file-name (git-file-name "cl-cf" version))
- (sha256
- (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig"))))
- (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+))))
-
-(define-public cl-cf
- (sbcl-package->cl-source-package sbcl-cf))
-
-(define-public ecl-cf
- (sbcl-package->ecl-package sbcl-cf))
-
-(define-public sbcl-bubble-operator-upwards
- (let ((commit "846275a318b960de81b62caecb1e31930f70aef6")
- (revision "0"))
- (package
- (name "sbcl-bubble-operator-upwards")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-3d-matrices")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Hexstream/bubble-operator-upwards")
+ (url "https://github.com/Shinmera/3d-matrices")
(commit commit)))
- (file-name (git-file-name "cl-bubble-operator-upwards" version))
+ (file-name (git-file-name "cl-3d-matrices" version))
(sha256
- (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi"))))
+ (base32 "1s8b4zlmqwyplghs73riz1khf0c5sk64w6b12jd599091d5nr6sr"))))
(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-bubble-operator-upwards
- (sbcl-package->cl-source-package sbcl-bubble-operator-upwards))
-
-(define-public ecl-bubble-operator-upwards
- (sbcl-package->ecl-package sbcl-bubble-operator-upwards))
-
-(define-public sbcl-map-bind
- (let ((commit "532d55d93540c632e22b2cd264b5daa5f9d3d900")
- (revision "0"))
- (package
- (name "sbcl-map-bind")
- (version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/map-bind")
- (commit commit)))
- (file-name (git-file-name "cl-map-bind" version))
- (sha256
- (base32 "0hfy65xyqc4zqfncn11pp3hjjkdz7m91cynnv91s3lgcl3kffva0"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
- (home-page "https://www.hexstreamsoft.com/libraries/map-bind/")
- (synopsis "Macro favouring positional references over naming")
- (description
- "@code{MAP-BIND} is a macro that allows visual grouping of variables with
-their corresponding values in calls to mapping operators when using an
-inline @code{LAMBDA}.")
- (license license:unlicense))))
-
-(define-public cl-map-bind
- (sbcl-package->cl-source-package sbcl-map-bind))
-
-(define-public ecl-cl-map-bind
- (sbcl-package->ecl-package sbcl-map-bind))
-
-(define-public sbcl-positional-lambda
- (let ((commit "a43a7bb4ef6faa277e6a7440ec9839711c4b9d28")
- (revision "0"))
- (package
- (name "sbcl-positional-lambda")
- (version (git-version "2.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Hexstream/positional-lambda")
- (commit commit)))
- (file-name (git-file-name "cl-positional-lambda" version))
- (sha256
- (base32 "1l27mw5ciqz7rnjq1lwslgk220i8iqcr39rs8b7hxkp1yqmah5zq"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
(inputs
- (list sbcl-map-bind))
- (home-page "https://www.hexstreamsoft.com/libraries/positional-lambda/")
- (synopsis "Macro favouring positional references over naming")
+ (list sbcl-3d-vectors sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/3d-matrices/")
+ (synopsis "Utility library implementing 2x2, 3x3, 4x4 and NxM matrices")
(description
- "This package provides a concise, intuitive and flexible macro for
-trivial lambdas that eschews explicit naming of parameter variables in favor
-of positional references, with support for a used or ignored &rest parameter
-and automatic declaration of ignored parameters when logical @code{gaps}
-are left in the positional references. Further convenience features
-are provided.")
- (license license:unlicense))))
-
-(define-public cl-positional-lambda
- (sbcl-package->cl-source-package sbcl-positional-lambda))
-
-(define-public ecl-cl-positional-lambda
- (sbcl-package->ecl-package sbcl-positional-lambda))
-
-(define-public sbcl-bodge-utilities
- (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f")
- (revision "1"))
- (package
- (name "sbcl-bodge-utilities")
- (version (git-version "1.0.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/borodust/bodge-utilities")
- (commit commit)))
- (file-name (git-file-name "bodge-utilities" version))
- (sha256
- (base32 "1z1blj05q71vzh323qwyn9p3xs7v0mq2yhwfyzza5libp37wqm3c"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-cffi
- sbcl-claw
- sbcl-dissect
- sbcl-local-time
- sbcl-log4cl
- sbcl-split-sequence
- sbcl-static-vectors
- sbcl-trivial-gray-streams))
- (home-page "https://github.com/borodust/bodge-utilities")
- (synopsis "Common Lisp utilities library for CL-BODGE")
- (description
- "This Common Lisp library provides utilities for the @emph{Bodge} library
-collection.")
- (license license:expat))))
+ "@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-bodge-utilities
- (sbcl-package->ecl-package sbcl-bodge-utilities))
+(define-public cl-3d-matrices
+ (sbcl-package->cl-source-package sbcl-3d-matrices))
-(define-public cl-bodge-utilities
- (sbcl-package->cl-source-package sbcl-bodge-utilities))
+(define-public ecl-3d-matrices
+ (sbcl-package->ecl-package sbcl-3d-matrices))
-(define-public sbcl-meta
- (let ((commit "74faea662139fbbfb9c99341aaed989f5b0e9da3")
+(define-public sbcl-3d-quaternions
+ (let ((commit "b79c15cca8d9c409216a6cee8ec9e182dcdec9e2")
(revision "0"))
(package
- (name "sbcl-meta")
+ (name "sbcl-3d-quaternions")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/frideau/meta")
+ (url "https://github.com/Shinmera/3d-quaternions")
(commit commit)))
- (file-name (git-file-name "cl-meta" version))
+ (file-name (git-file-name "cl-3d-quaternions" version))
(sha256
- (base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy"))))
+ (base32 "1mrq6yhb90mhvxdkg3fx58ci5yj5xlixbbzf1q6p76wyq40qjv76"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-named-readtables))
- (home-page "https://gitlab.common-lisp.net/frideau/meta")
- (synopsis "Recursive-descent parser DSL for Common Lisp")
+ (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 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))))
+ "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-inotify
- (sbcl-package->cl-source-package sbcl-cl-inotify))
+(define-public cl-3d-quaternions
+ (sbcl-package->cl-source-package sbcl-3d-quaternions))
-(define-public ecl-cl-inotify
- (sbcl-package->ecl-package sbcl-cl-inotify))
+;; 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-file-notify
- (let ((commit "f12dc2f2aae5fee13355cd93a8cae0c4c412b76d")
+(define-public sbcl-3d-spaces
+ (let ((commit "a93f4915affcf65617366297ad8bd2ec77bae702")
(revision "0"))
(package
- (name "sbcl-file-notify")
+ (name "sbcl-3d-spaces")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/file-notify")
+ (url "https://github.com/Shirakumo/3d-spaces")
(commit commit)))
- (file-name (git-file-name "cl-file-notify" version))
+ (file-name (git-file-name "cl-3d-spaces" version))
(sha256
- (base32 "0788d98rqm1krl8nbfh8qshvyf6g336i9bqrdhkx06cfvbh0wcny"))))
+ (base32 "1m5cg5zy1731dcgkm1p4m53z1zsp387xligxh32pdrnrhc2lzhmf"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-cffi
+ (list sbcl-3d-math
sbcl-documentation-utils
- sbcl-trivial-features))
- (home-page "https://github.com/Shinmera/file-notify")
- (synopsis "Get notifications for file accesses and changes")
+ sbcl-for
+ sbcl-trivial-extensible-sequences))
+ (home-page "https://shirakumo.github.io/3d-spaces/")
+ (synopsis "Implementations of various spatial query structures")
(description
- "File-Notify is a Common Lisp library for getting notifications for file
-accesses and changes.")
+ "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-file-notify
- (sbcl-package->cl-source-package sbcl-file-notify))
+(define-public cl-3d-spaces
+ (sbcl-package->cl-source-package sbcl-3d-spaces))
-(define-public ecl-file-notify
- (sbcl-package->ecl-package sbcl-file-notify))
+(define-public ecl-3d-spaces
+ (sbcl-package->ecl-package sbcl-3d-spaces))
-(define-public sbcl-file-select
- (let ((commit "ef25f6d7c78ed9e0b62119979af8c4b5b0f8c774")
- (revision "1"))
+(define-public sbcl-3d-transforms
+ (let ((commit "1d44509387d0747cd0351e95a533eca609058632")
+ (revision "0"))
(package
- (name "sbcl-file-select")
+ (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/file-select")
+ (url "https://github.com/Shinmera/3d-transforms")
(commit commit)))
- (file-name (git-file-name "file-select" version))
+ (file-name (git-file-name "cl-3d-transforms" version))
(sha256
- (base32 "1qh32ymljw5c98zzbvjfq6jzwlzs4qxi8gh4gw8pixir6y1inxaa"))))
+ (base32 "03pmv7dh1j6kl16ch6lnvxzjrld4jbr3jx8slzkiipgzdxg74pcx"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(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")
+ (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 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.")
+ "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-file-select
- (sbcl-package->cl-source-package sbcl-file-select))
+(define-public cl-3d-transforms
+ (sbcl-package->cl-source-package sbcl-3d-transforms))
-(define-public ecl-file-select
- (sbcl-package->ecl-package sbcl-file-select))
+;; 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-bodge-queue
- (let ((commit "948c9a501dcd412689952d09eb7453ec2722336a")
- (revision "0"))
+(define-public sbcl-3d-vectors
+ (let ((commit "257969402864ac3859d77b981abf0aa5373c4e78")
+ (revision "2"))
(package
- (name "sbcl-bodge-queue")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-3d-vectors")
+ (version (git-version "3.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/borodust/bodge-queue")
+ (url "https://github.com/Shinmera/3d-vectors")
(commit commit)))
- (file-name (git-file-name "bodge-queue" version))
+ (file-name (git-file-name "cl-3d-vectors" version))
(sha256
- (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr"))))
+ (base32 "0vmf7nycc49ydcy0dfs25cgs655kwjc6jcjvpwxw61jq4gl2fh7x"))))
(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))))
+ (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-bodge-queue
- (sbcl-package->cl-source-package sbcl-bodge-queue))
+(define-public cl-3d-vectors
+ (sbcl-package->cl-source-package sbcl-3d-vectors))
-(define-public ecl-bodge-queue
- (sbcl-package->ecl-package sbcl-bodge-queue))
+(define-public ecl-3d-vectors
+ (sbcl-package->ecl-package sbcl-3d-vectors))
-(define-public sbcl-list-named-class
- (let ((commit "2955791a7469131bcab42d800883f27993ee1d62")
+(define-public sbcl-40ants-doc
+ (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b")
(revision "0"))
(package
- (name "sbcl-list-named-class")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-40ants-doc")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phoe/list-named-class")
+ (url "https://github.com/40ants/doc")
(commit commit)))
- (file-name (git-file-name "cl-list-named-class" version))
(sha256
- (base32 "1bdi9q9wvfj66jji3n9hpjrj9271ial2awsb0xw80bmy6wqbg8kq"))))
+ (base32 "1v6gnhrk02vsixmprzk4wvvj7vh11vp5waxyih0qz2ih8d38r5pg"))
+ (file-name (git-file-name "cl-40ants-doc" version))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-1am))
+ (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-alexandria sbcl-closer-mop))
- (home-page "https://github.com/phoe/list-named-class/")
- (synopsis "Name classes after lists of symbols")
+ (list sbcl-named-readtables
+ sbcl-pythonic-string-reader
+ ;; For 40ants-doc-full:
+ ;;sbcl-3bmd
+ ;;sbcl-alexandria
+ ;;sbcl-babel
+ ;;sbcl-cl-cookie
+ ;;sbcl-cl-fad
+ ;;sbcl-cl-ppcre
+ ;;sbcl-common-doc ; Missing from Guix
+ ;;sbcl-common-html ; Missing from Guix
+ ;;sbcl-commondoc-markdown ; Missing from Guix
+ ;;sbcl-dexador
+ ;;sbcl-docs-builder ; Missing from Guix
+ ;;sbcl-fare-utils
+ ;;sbcl-jonathan
+ ;;sbcl-lass
+ ;;sbcl-local-time
+ ;;sbcl-log4cl
+ ;;sbcl-slime-swank
+ ;;sbcl-slynk
+ ;;sbcl-spinneret
+ ;;sbcl-stem ; Missing from Guix; also, license is unconfirmed
+ ;;sbcl-str
+ ;;sbcl-tmpdir ; Missing from Guix
+ ;;sbcl-trivial-extract ; Missing from Guix
+ ;;sbcl-xml-emitter
+ ))
+ (home-page "https://40ants.com/doc/")
+ (synopsis "Exploratory programming environment and documentation generator")
(description
- "This package makes it possible to name classes by lists of symbols
-instead of symbols.")
+ "@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-list-named-class
- (sbcl-package->cl-source-package sbcl-list-named-class))
+(define-public cl-40ants-doc
+ (sbcl-package->cl-source-package sbcl-40ants-doc))
-(define-public ecl-list-named-class
- (sbcl-package->ecl-package sbcl-list-named-class))
+(define-public ecl-40ants-doc
+ (sbcl-package->ecl-package sbcl-40ants-doc))
-(define-public sbcl-golden-utils
- (let ((commit "e43914ad2bdb0c8e1b1f10ef591aafc3c55b89e7")
- (revision "4"))
+(define-public sbcl-abstract-classes
+ (let ((commit "7fa74f1e057f9ba7c1ffecff14f049f979e45267")
+ (revision "1"))
(package
- (name "sbcl-golden-utils")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/lisp-mirror/golden-utils")
+ (name "sbcl-abstract-classes")
+ (version (git-version "1.7.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://bitbucket.org/eeeickythump/cl-abstract-classes")
(commit commit)))
- (file-name (git-file-name "cl-golden-utils" version))
+ (file-name (git-file-name "cl-abstract-classes" version))
(sha256
- (base32 "09vq29wjr3x7h3fshwxg8h1psy4p73yl61cjljarpqjhsgz7lmbp"))))
+ (base32 "06lby4i6xbbgs7kgb0f3fqybvyskyg6djhrf967lnysv7hn3zpg9"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (synopsis "Common Lisp utility library")
+ `(("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 is a Common Lisp library providing various utilities.")
- (license license:expat))))
+ "This package provides Common Lisp extension to the MOP to allow
+abstract, final and singleton classes.")
+ (license license:public-domain))))
-(define-public ecl-golden-utils
- (sbcl-package->ecl-package sbcl-golden-utils))
+(define-public ecl-abstract-classes
+ (sbcl-package->ecl-package sbcl-abstract-classes))
-(define-public cl-golden-utils
- (sbcl-package->cl-source-package sbcl-golden-utils))
+(define-public cl-abstract-classes
+ (sbcl-package->cl-source-package sbcl-abstract-classes))
-(define-public sbcl-asdf-finalizers
- (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
+(define-public sbcl-access
+ (let ((commit "a4f87fc1007f5c9a0a2abfddc1c23a77e87096f8")
(revision "1"))
(package
- (name "sbcl-asdf-finalizers")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-access")
+ (version (git-version "1.6.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers")
+ (url "https://github.com/AccelerationNet/access")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-access" version))
(sha256
- (base32 "1w56c9yjjydjshsgqxz57qlp2v3r4ilbisnsgiqphvxnhvd41y0v"))))
+ (base32 "0zdjqhb9rvnlq6nzmsp7372gi91k1rq9bz510m6hcki7g3r01iv5"))))
(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))))
+ (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-asdf-finalizers
- (sbcl-package->ecl-package sbcl-asdf-finalizers))
+(define-public ecl-access
+ (sbcl-package->ecl-package sbcl-access))
-(define-public cl-asdf-finalizers
- (sbcl-package->cl-source-package sbcl-asdf-finalizers))
+(define-public cl-access
+ (sbcl-package->cl-source-package sbcl-access))
-(define-public sbcl-asdf-system-connections
- (let ((commit "9f085240febccccff99d9d3bb687fcaafffd3f5e")
- (revision "1"))
+(define-public sbcl-acclimation
+ (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
(package
- (name "sbcl-asdf-system-connections")
- (version (git-version "0.8.4" revision commit))
+ (name "sbcl-acclimation")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/gwkkwg/asdf-system-connections")
+ (url "https://github.com/robert-strandh/Acclimation")
(commit commit)))
- (file-name (git-file-name "cl-asdf-system-connections" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y"))))
+ (base32
+ "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
(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.
+ (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.
-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"))))
+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-net.didierverna.asdf-flv
- (sbcl-package->cl-source-package sbcl-net.didierverna.asdf-flv))
+(define-public cl-acclimation
+ (sbcl-package->cl-source-package sbcl-acclimation))
-(define-public ecl-net.didierverna.asdf-flv
- (sbcl-package->ecl-package sbcl-net.didierverna.asdf-flv))
+(define-public ecl-acclimation
+ (sbcl-package->ecl-package sbcl-acclimation))
-(define-public sbcl-command-line-arguments
- (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe")
- (revision "1"))
+(define-public sbcl-acl-compat
+ ;; There does not seem to be proper releases.
+ (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5"))
(package
- (name "sbcl-command-line-arguments")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-acl-compat")
+ (version (git-version "0.1.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fare/command-line-arguments")
+ (url "git://git.code.sf.net/p/portableaserve/git")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "acl-compat" version))
(sha256
- (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq"))))
+ (base32 "0ak6mqp84sjr0a7h5svr16vra4bf4fcx6wpir0n88dc1vjwy5xqa"))))
(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))
+ (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-command-line-arguments
- (sbcl-package->cl-source-package sbcl-command-line-arguments))
+(define-public cl-acl-compat
+ (sbcl-package->cl-source-package sbcl-acl-compat))
(define-public sbcl-adopt
(package
@@ -1065,2256 +760,1795 @@ 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 cl-adopt
- (sbcl-package->cl-source-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.
-(define-public sbcl-clingon
- (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d")
- (revision "0"))
+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-clingon")
- (version (git-version "0.5.0" revision commit))
+ (name "sbcl-agutil")
+ (version (git-version "0.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dnaeon/clingon")
+ (url "https://github.com/alex-gutev/agutil/")
(commit commit)))
- (file-name (git-file-name "cl-clingon" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "11p9lplx0fc5ghx601i150vrd46zdbvw0hfrbrrrdqplxaqpywq5"))))
+ (base32 "1xpnyzksk2xld64b6lw6rw0gn5zxlb77jwna59sd4yl7kxhxlfpf"))))
(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))))
+ (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-clingon
- (sbcl-package->cl-source-package sbcl-clingon))
+(define-public cl-agutil
+ (sbcl-package->cl-source-package sbcl-agutil))
-(define-public ecl-clingon
- (sbcl-package->ecl-package sbcl-clingon))
+(define-public ecl-agutil
+ (sbcl-package->ecl-package sbcl-agutil))
-(define-public sbcl-command-line-args
+(define-public sbcl-alea
(package
- (name "sbcl-command-line-args")
- (version "0.1.1")
+ (name "sbcl-alea")
+ (version "1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.sr.ht/~whereiseveryone/command-line-args")
+ (url "https://github.com/eXodiquas/alea")
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-command-line-args" version))
+ (file-name (git-file-name "cl-alea" version))
(sha256
- (base32 "140xnz2v0v3hfg3dp2fhidw8ns6lxd3a5knm07wqdp48ksg119wy"))))
+ (base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz"))))
(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))
+ (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 ecl-command-line-args
- (sbcl-package->ecl-package sbcl-command-line-args))
+(define-public cl-alea
+ (sbcl-package->cl-source-package sbcl-alea))
-(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).
+(define-public ecl-alea
+ (sbcl-package->ecl-package sbcl-alea))
-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 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 cl-irc
- (sbcl-package->cl-source-package sbcl-cl-irc))
+(define-public ecl-alexa
+ (sbcl-package->ecl-package sbcl-alexa))
-(define-public ecl-cl-irc
- (sbcl-package->ecl-package sbcl-cl-irc))
+(define-public cl-alexa
+ (sbcl-package->cl-source-package sbcl-alexa))
-(define-public sbcl-coleslaw
- (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40")
+(define-public sbcl-alexandria
+ (let ((commit "009b7e532071d9777bdbd63b82d776555da95916")
(revision "0"))
(package
- (name "sbcl-coleslaw")
- (version (git-version "0.9.7" revision commit))
+ (name "sbcl-alexandria")
+ (version (git-version "1.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/coleslaw-org/coleslaw")
+ (url "https://gitlab.common-lisp.net/alexandria/alexandria.git")
(commit commit)))
- (file-name (git-file-name "cl-coleslaw" version))
+ (file-name (git-file-name "cl-alexandria" version))
(sha256
- (base32 "1w21a272q4x7nlr4kbmwwvkjvb4hpnw869byvy47vv361y7pimws"))))
+ (base32 "0pdj779j3nwzn8f1661vf00rrjrbks1xgiq0rvwjw6qyxsfqfnl9"))))
(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")
+ (list sbcl-rt))
+ (synopsis "Collection of portable utilities for Common Lisp")
(description
- "Coleslaw is a static site generator written in Common Lisp.")
- (license license:bsd-2))))
+ "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-coleslaw
- (sbcl-package->cl-source-package sbcl-coleslaw))
+(define-public cl-alexandria
+ (sbcl-package->cl-source-package sbcl-alexandria))
-(define-public ecl-coleslaw
- (sbcl-package->ecl-package sbcl-coleslaw))
+(define-public ecl-alexandria
+ (sbcl-package->ecl-package sbcl-alexandria))
-(define-public sbcl-cl-all
- (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace")
+(define-public sbcl-alexandria-plus
+ (let ((commit "adafb09838a84895bedb119f8253b89b6a04a2c5")
(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))
+ (name "sbcl-alexandria-plus")
+ ;; Version is stated in the ASD file.
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/aartaka/tripod")
+ (url "https://github.com/Symbolics/alexandria-plus")
(commit commit)))
- (file-name (git-file-name "cl-tripod" version))
+ (file-name (git-file-name "cl-alexandria-plus" version))
(sha256
- (base32 "0y8sns6njq9x7km58vpj7gx4cia9zkcpng3d38300xk0nnk2kz8w"))))
+ (base32 "1w9r19610h599303gqlx2x5n8mmdynss2gyl7xilg5h6v8z3hkfl"))))
(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))))))
+ '(#:asd-systems '("alexandria+")))
+ (native-inputs
+ (list sbcl-parachute))
(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")
+ (list sbcl-alexandria))
+ (home-page "https://symbolics.github.io/alexandria-plus/")
+ (synopsis "Conservative set of extensions to Alexandria utilities")
(description
- "Tripod is a Common Lisp web server aiming to ease plain text, HTML,
-and Gopher website hosting.")
- (license license:bsd-2))))
+ "@code{cl-alexandria-plus} is a conservative set of extensions to
+@code{cl-alexandria} utilities.")
+ (license license:ms-pl))))
-(define-public cl-tripod
- ;; No "bin" output for the source package.
- (let ((pkg (sbcl-package->cl-source-package sbcl-tripod)))
- (package/inherit pkg
- (outputs '("out")))))
+(define-public cl-alexandria-plus
+ (sbcl-package->cl-source-package sbcl-alexandria-plus))
-(define-public ecl-tripod
- ;; FIXME: Making a standalone binary doesn't work with ECL.
- (let ((pkg (sbcl-package->ecl-package sbcl-tripod)))
- (package/inherit pkg
- (outputs '("out"))
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:phases phases)
- #~(modify-phases #$phases
- (delete 'build-program))))))))
+(define-public ecl-alexandria-plus
+ (sbcl-package->ecl-package sbcl-alexandria-plus))
-(define-public sbcl-trivial-timeout
- (let ((commit "e70d9b4f7caeab83ea6ac50d724470fe49561e66")
- (revision "2"))
+(define-public sbcl-alloy
+ (let ((commit "628974de537affb5b44ad548347f67c16efffcfc")
+ (revision "3"))
(package
- (name "sbcl-trivial-timeout")
- (version (git-version "0.1.5" revision commit))
+ (name "sbcl-alloy")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/trivial-timeout")
+ (url "https://github.com/Shirakumo/alloy")
(commit commit)))
- (file-name (git-file-name "trivial-timeout" version))
+ (file-name (git-file-name "cl-alloy" version))
(sha256
- (base32 "0s8z9aj6b3kv21yiyk13cjylzf5zlnw9v86vcff477m1gk9yddjs"))))
+ (base32 "0fx294qwxshgijss000pbjbnbwxqvxyw6p3mva36qljhbbkw2fxy"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-lift))
- (home-page "https://github.com/hraban/trivial-timeout")
- (synopsis "Timeout library for Common Lisp")
+ (list sbcl-alexandria sbcl-parachute))
+ (inputs
+ (list sbcl-array-utils sbcl-closer-mop sbcl-documentation-utils
+ sbcl-float-features sbcl-colored sbcl-stealth-mixin
+ sbcl-cl-opengl sbcl-font-discovery sbcl-uax-14 sbcl-sdf))
+ (arguments
+ ;; Dismiss alloy-svg, since it is not completed:
+ ;; https://github.com/Shirakumo/alloy/issues/24
+ '(#:asd-systems '("alloy"
+ "alloy-animation"
+ "alloy-opengl"
+ "alloy-opengl-msdf"
+ "alloy-opengl-png"
+ "alloy-simple"
+ "alloy-simple-presentations"
+ "alloy-windowing")))
+ (home-page "https://shirakumo.github.io/alloy/")
+ (synopsis
+ "Common Lisp user interface protocol and toolkit implementation")
(description
- "This 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))))
+ "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-trivial-gray-streams
- (sbcl-package->cl-source-package sbcl-trivial-gray-streams))
+(define-public cl-alloy
+ (sbcl-package->cl-source-package sbcl-alloy))
-(define-public ecl-trivial-gray-streams
- (sbcl-package->ecl-package sbcl-trivial-gray-streams))
+(define-public ecl-alloy
+ (sbcl-package->ecl-package sbcl-alloy))
-(define-public sbcl-flexi-streams
- (let ((commit "74a1027311371a57258eba1bc908e050f5702277")
+(define-public sbcl-amb
+ (let ((commit "884bef69a1ea02f3b9deae0341e1a038ff31b896")
(revision "0"))
(package
- (name "sbcl-flexi-streams")
- (version (git-version "1.0.19" 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/edicl/flexi-streams")
+ (url "https://github.com/phoe/amb")
(commit commit)))
- (file-name (git-file-name "cl-flexi-streams" version))
+ (file-name (git-file-name "cl-amb" 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"))))
+ (base32 "1klh1aakklj1famrff0sccnwlv8238b1q446288aqnqgxxw6pf21"))))
(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.")
+ (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-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 cl-amb
+ (sbcl-package->cl-source-package sbcl-amb))
-(define-public ecl-select
- (sbcl-package->ecl-package sbcl-select))
+(define-public ecl-amb
+ (sbcl-package->ecl-package sbcl-amb))
-(define-public sbcl-cl-ppcre
+(define-public sbcl-anaphora
(package
- (name "sbcl-cl-ppcre")
- (version "2.1.1")
+ (name "sbcl-anaphora")
+ (version "0.9.8")
(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))
+ (url "https://github.com/tokenrove/anaphora")
+ (commit version)))
(sha256
- (base32 "0dwvr29diqzcg5n6jvbk2rnd90i05l7n828hhw99khmqd0kz7xsi"))))
+ (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b"))
+ (file-name (git-file-name "cl-anaphora" version))))
(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)))
+ (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-ppcre
- (sbcl-package->cl-source-package sbcl-cl-ppcre))
+(define-public cl-anaphora
+ (sbcl-package->cl-source-package sbcl-anaphora))
-(define-public ecl-cl-ppcre
- (sbcl-package->ecl-package sbcl-cl-ppcre))
+(define-public ecl-anaphora
+ (sbcl-package->ecl-package sbcl-anaphora))
-(define-public sbcl-one-more-re-nightmare
- (let ((commit "5b0b02e59f90964baf5737abd13300fa82f27667")
+;;; 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-one-more-re-nightmare")
+ (name "sbcl-antik-base")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/telekons/one-more-re-nightmare")
+ (url "https://gitlab.common-lisp.net/antik/antik.git")
(commit commit)))
- (file-name (git-file-name "cl-one-more-re-nightmare" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0mwgjgnp8dsf2zn0290px5q89z93zs0v4dhvs3rcir4mpiw8rbsn"))))
+ (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-test-systems '("one-more-re-nightmare-tests")
+ '(#:asd-systems '("antik-base"
+ "foreign-array")
#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
+ (add-after 'unpack 'fix-build
(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))
+ (for-each delete-file
+ '("antik.asd"
+ "physical-dimension.asd"
+ "science-data.asd"))
+ #t)))))
+ (synopsis "Scientific and engineering computation in Common Lisp")
+ (description
+ "Antik provides a foundation for scientific and engineering
+computation in Common Lisp. It is designed not only to facilitate
+numerical computations, but to permit the use of numerical computation
+libraries and the interchange of data and procedures, whether
+foreign (non-Lisp) or Lisp libraries. It is named after the
+Antikythera mechanism, one of the oldest examples of a scientific
+computer known.")
+ (home-page "https://common-lisp.net/project/antik/")
+ (license license:gpl3))))
-(define-public ecl-one-more-re-nightmare
- (sbcl-package->ecl-package sbcl-one-more-re-nightmare))
+(define-public cl-antik-base
+ (sbcl-package->cl-source-package sbcl-antik-base))
-(define-public sbcl-parse
- (let ((commit "2351ee78acac065fcf10b8713d3f404e2e910786")
- (revision "1"))
+(define-public ecl-antik-base
+ (let ((pkg (sbcl-package->ecl-package sbcl-antik-base)))
(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))))
+ (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 ecl-parse
- (sbcl-package->ecl-package sbcl-parse))
+(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-parse
- (sbcl-package->cl-source-package sbcl-parse))
+(define-public cl-antik
+ (sbcl-package->cl-source-package sbcl-antik))
-(define-public sbcl-re
- (let ((commit "cfbc1f482970221e80d445080a188fd5c755cd2c")
- (revision "1"))
+(define-public sbcl-april
+ (let ((commit "bdd74f168ec82f28fe4ab692f2c0af39441a5701")
+ (revision "3"))
(package
- (name "sbcl-re")
+ (name "sbcl-april")
(version (git-version "1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/massung/re")
- (commit commit)))
- (file-name (git-file-name "re" version))
- (sha256
- (base32 "1y2gq2sckspnq8118bix55p2j43dk9qn3p8a2rplp1ip2qxqbb1i"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-parse))
- (home-page "https://github.com/massung/re")
- (synopsis "Lua-style Pattern Matching for Common Lisp")
- (description
- "RE is a small, portable, lightweight, and quick, regular
-expression library for Common Lisp. It is a non-recursive, backtracing VM.")
- (license license:asl2.0))))
-
-(define-public ecl-re
- (sbcl-package->ecl-package sbcl-re))
-
-(define-public cl-re
- (sbcl-package->cl-source-package sbcl-re))
-
-(define-public sbcl-boost-json
- (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47")
- (revision "0"))
- (package
- (name "sbcl-boost-json")
- (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-boost/json")
+ (url "https://github.com/phantomics/april")
(commit commit)))
- (file-name (git-file-name "cl-boost-json" version))
+ (file-name (git-file-name "cl-april" version))
(sha256
- (base32 "12k0470899qsll2qixksxf2vrhjmskk3nzp1di9k04n1b29nrakd"))))
+ (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)
- (arguments
- '(#:phases
- (modify-phases %standard-phases
- ;; See <https://github.com/cl-boost/json/pull/2>.
- (add-after 'unpack 'fix-decode-symbol
- (lambda _
- (substitute* '("decode.lisp" "encode.lisp")
- (("formfeed") "page")))))))
- (home-page "https://github.com/cl-boost/json")
- (synopsis "JSON encoding and decoding for Common Lisp")
+ (inputs
+ (list sbcl-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
- "BOOST-JSON is a simple JSON parsing library for Common Lisp.")
+ "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-boost-json
- (sbcl-package->cl-source-package sbcl-boost-json))
+(define-public cl-april
+ (sbcl-package->cl-source-package sbcl-april))
-(define-public ecl-boost-json
- (sbcl-package->ecl-package sbcl-boost-json))
+(define-public ecl-april
+ (sbcl-package->ecl-package sbcl-april))
-(define-public sbcl-boost-parse
- (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50")
- (revision "0"))
+(define-public sbcl-archive
+ (let ((commit "631271c091ed02994bec3980cb288a2cf32c7cdc")
+ (revision "1"))
(package
- (name "sbcl-boost-parse")
- (version (git-version "1.0" revision commit))
+ (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/cl-boost/parse")
+ (url "https://github.com/AccelerationNet/arnesi")
(commit commit)))
- (file-name (git-file-name "cl-boost-parse" version))
+ (file-name (git-file-name "arnesi" version))
(sha256
- (base32 "0djnp392n9wgpr9r2ycnwkglad5mn285yvr53jx3g7anm2p8r0vf"))))
+ (base32 "0jgj2xgd1gq6rf8ia43lkmbrbxnp8rgs053br9azfa25ygk3ikbh"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/cl-boost/parse")
- (synopsis "Monadic parsing for Common Lisp")
+ (arguments
+ ;; FIXME: (Sharlatan-20210523T190315+0100): Tests failed on
+ ;; special-lisp-var-rebount-in/cc
+ ;;
+ ;; ; processing (TEST SPECIAL-LISP-VAR-REBOUND-IN/CC ...)
+ ;; ; wrote .../sbcl/arnesi/t/call-cc-tmp5GEXGEG5.fasl
+ ;; ; compilation finished in 0:00:00.028
+ ;; Unhandled SIMPLE-ERROR in thread
+ ;; #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>:
+ ;; Sorry, No walker for the special operater DECLARE defined.
+ ;;
+ ;; Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {100B768173}>
+ ;; 0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SIMPLE-ERROR "Sorry,
+ ;; No walker for the special operater ~S defined."
+ ;; {1001FAF9D3}> #<unused argument> :QUIT T)
+ ;;
+ `(#:tests? #f))
+ (native-inputs
+ (list sbcl-fiveam))
+ (inputs
+ `(("cl-ppcre" ,sbcl-cl-ppcre)
+ ("collectors" ,sbcl-collectors)
+ ("swank" ,sbcl-slime-swank)))
+ (home-page "https://github.com/AccelerationNet/arnesi")
+ (synopsis "Common Lisp utility suite")
(description
- "BOOST-PARSE is a simple token parsing library for Common Lisp.")
- (license license:asl2.0))))
+ "ARNESI is Common Lisp utilities library similar to ALEXANDRIA, ANAPHORA
+or GOLDEN-UTILS.")
+ (license license:bsd-3))))
-(define-public cl-boost-parse
- (sbcl-package->cl-source-package sbcl-boost-parse))
+(define-public ecl-arnesi
+ (sbcl-package->ecl-package sbcl-arnesi))
-(define-public ecl-boost-parse
- (sbcl-package->ecl-package sbcl-boost-parse))
+(define-public cl-arnesi
+ (sbcl-package->cl-source-package sbcl-arnesi))
-(define-public sbcl-boost-re
- (let ((commit "d279fc58abf76d0c40aa6cde42e17a0591bc2c5d")
+(define-public sbcl-array-operations
+ (let ((commit "75cbc3b1adb2e3ce2109489753d0f290b071e81b")
(revision "0"))
(package
- (name "sbcl-boost-re")
- (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/cl-boost/re")
+ (url "https://github.com/bendudson/array-operations")
(commit commit)))
- (file-name (git-file-name "cl-boost-re" version))
+ (file-name (git-file-name "array-operations" version))
(sha256
- (base32 "1h9c2rdhw6m1pm67gqbj46y2vb1kc3i1c9y3l4qhgfz14dbk80a2"))))
+ (base32 "0ip49hhq32w80qsc7jmspyda5r2rsszvw0mk2r3341cld78sz9ya"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-alexandria sbcl-clunit2))
(inputs
- (list sbcl-boost-parse))
- (home-page "https://github.com/cl-boost/re")
- (synopsis "Lua-style string pattern matching for Common Lisp")
+ (list sbcl-let-plus))
+ (synopsis "Simple array operations library for Common Lisp")
(description
- "BOOST-RE is a small, portable, lightweight, and quick, regular
-expression library for Common Lisp. It is a non-recursive, backtracking VM.")
- (license license:asl2.0))))
+ "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-boost-re
- (sbcl-package->cl-source-package sbcl-boost-re))
+(define-public cl-array-operations
+ (sbcl-package->cl-source-package sbcl-array-operations))
-(define-public ecl-boost-re
- (sbcl-package->ecl-package sbcl-boost-re))
+(define-public ecl-array-operations
+ (sbcl-package->ecl-package sbcl-array-operations))
-(define-public sbcl-boost-lexer
- (let ((commit "139ca9e9580f890698deec05061e495376b7735a")
+(define-public sbcl-array-utils
+ (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834")
(revision "0"))
(package
- (name "sbcl-boost-lexer")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-array-utils")
+ (version (git-version "1.2.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/cl-boost/lexer")
- (commit commit)))
- (file-name (git-file-name "cl-boost-lexer" version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/array-utils")
+ (commit commit)))
+ (file-name (git-file-name "cl-array-utils" version))
(sha256
- (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4"))))
+ (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
(inputs
- (list sbcl-boost-re))
- (home-page "https://github.com/cl-boost/lexer")
- (synopsis "String tokenizing for Common Lisp")
+ (list sbcl-documentation-utils))
+ (synopsis "Tiny collection of array and vector utilities for Common Lisp")
(description
- "BOOST-LEXER is a tokenizer for Common Lisp that makes heavy use of
-BOOST-RE.")
- (license license:asl2.0))))
+ "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-boost-lexer
- (sbcl-package->cl-source-package sbcl-boost-lexer))
+(define-public cl-array-utils
+ (sbcl-package->cl-source-package sbcl-array-utils))
-(define-public ecl-boost-lexer
- (sbcl-package->ecl-package sbcl-boost-lexer))
+(define-public ecl-array-utils
+ (sbcl-package->ecl-package sbcl-array-utils))
-(define-public sbcl-ubiquitous
- (let ((commit "35eb7bd9e1b3daee1705f6b41260775180cce8af")
- (revision "1"))
+(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-ubiquitous")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-arrow-macros")
+ (version (git-version "0.2.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/ubiquitous")
+ (url "https://github.com/hipeta/arrow-macros")
(commit commit)))
- (file-name (git-file-name "ubiquitous" version))
+ (file-name (git-file-name "arrow-macros" version))
(sha256
- (base32 "1xlkaqmjcpkiv2xl2s2pvvrv976dlc846wm16s1lj62iy1315i49"))))
+ (base32 "0q4vpysk4h9ghs5zmnzzilky9jyz7i8n0x0p98nq528crbrkh6c4"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)))
- (arguments
- '(#:asd-systems '("ubiquitous"
- "ubiquitous-concurrent")))
- (home-page "https://shinmera.github.io/ubiquitous/")
- (synopsis "Application configuration mechanism for Common Lisp")
+ (native-inputs (list sbcl-fiveam))
+ (home-page "https://github.com/hipeta/arrow-macros/")
+ (synopsis "Clojure-like arrow macros in 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))))
+ "Arrow-macros provides clojure-like arrow macros (ex. ->, ->>) and diamond wands
+in swiss-arrows.")
+ (license license:expat))))
-(define-public ecl-ubiquitous
- (sbcl-package->ecl-package sbcl-ubiquitous))
+(define-public cl-arrow-macros
+ (sbcl-package->cl-source-package sbcl-arrow-macros))
-(define-public cl-ubiquitous
- (sbcl-package->cl-source-package sbcl-ubiquitous))
+(define-public ecl-arrow-macros
+ (sbcl-package->ecl-package sbcl-arrow-macros))
-(define-public sbcl-uax-14
- (let ((commit "0432162525119c401d3d705bb9bcc9580a03914f")
- (revision "1"))
+(define-public sbcl-arrows
+ (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
+ (revision "0"))
(package
- (name "sbcl-uax-14")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-arrows")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/uax-14")
+ (url "https://gitlab.com/Harleqin/arrows.git")
(commit commit)))
- (file-name (git-file-name "uax-14" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1sb2s58k01yjaggaq8i7kbyfsh6mzyqbiz1vm59smxn9qqwd8apm"))))
+ (base32
+ "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
(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")
+ (list sbcl-hu.dwim.stefil))
+ (synopsis "Clojure-like arrow macros for Common Lisp")
(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)))
+ "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 ecl-zpb-ttf
- (sbcl-package->ecl-package sbcl-zpb-ttf))
+(define-public cl-arrows
+ (sbcl-package->cl-source-package sbcl-arrows))
-(define-public cl-zpb-ttf
- (sbcl-package->cl-source-package sbcl-zpb-ttf))
+(define-public ecl-arrows
+ (sbcl-package->ecl-package sbcl-arrows))
-(define-public sbcl-zip
- ;; named branch is outdated
- (let ((commit "688b1545dd7a4fe355556768bb03f8bd9b847a87")
+(define-public sbcl-asdf-finalizers
+ (let ((commit "7f537f6c598b662ae987c6acc268dd27c25977e0")
(revision "1"))
(package
- (name "sbcl-zip")
+ (name "sbcl-asdf-finalizers")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bluelisp/zip")
+ (url "https://gitlab.common-lisp.net/asdf/asdf-finalizers")
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0s08a6fq182fzsbfyvihqbdllq6gxcwkvphxnrd9wwz65dhg5y66"))
- (file-name (git-file-name "cl-zip" version))))
+ (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/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-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)))))
+ (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 ecl-zip
- (sbcl-package->ecl-package sbcl-zip))
+(define-public cl-asd-generator
+ (sbcl-package->cl-source-package sbcl-asd-generator))
-(define-public cl-zip
- (sbcl-package->cl-source-package sbcl-zip))
+(define-public ecl-asd-generator
+ (sbcl-package->ecl-package sbcl-asd-generator))
-(define-public sbcl-zippy
- (let ((commit "ed9bca591ded2ff27a9ac95d9a60827773a0e707")
+(define-public sbcl-asdf-system-connections
+ (let ((commit "9f085240febccccff99d9d3bb687fcaafffd3f5e")
(revision "1"))
(package
- (name "sbcl-zippy")
- (version (git-version "1.1.0" revision commit))
+ (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/Shinmera/zippy/")
+ (url "https://github.com/gwkkwg/asdf-system-connections")
(commit commit)))
+ (file-name (git-file-name "cl-asdf-system-connections" version))
(sha256
- (base32 "16cvyyf2nzd9r3fcy4w6d5wh8n3x833wldmrxmnzd3k2xrkhzfl9"))
- (file-name (git-file-name "zippy" version))))
+ (base32 "06kg0m8bv383qq3r34x0f8hz6p6zxcw02qn7kj960vcnrp5a5b3y"))))
(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)))
+ (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-cl-vectors
- (sbcl-package->ecl-package sbcl-cl-vectors))
+(define-public cl-asdf-system-connections
+ (sbcl-package->cl-source-package sbcl-asdf-system-connections))
-(define-public cl-vectors
- (sbcl-package->cl-source-package sbcl-cl-vectors))
+(define-public ecl-asdf-system-connections
+ (sbcl-package->ecl-package sbcl-asdf-system-connections))
-(define-public sbcl-spatial-trees
- ;; There have been no releases.
- (let ((commit "81fdad0a0bf109c80a53cc96eca2e093823400ba")
- (revision "1"))
+(define-public sbcl-aserve
+ ;; There does not seem to be proper releases.
+ (let ((commit "cac1d6920998ddcbee8310a873414732e707d8e5")
+ (revision "2"))
(package
- (name "sbcl-spatial-trees")
- (version (git-version "0" revision commit))
+ (name "sbcl-aserve")
+ (version (git-version "1.2.50" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/spatial-trees")
+ ;; 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 name version))
+ (file-name (git-file-name "aserve" version))
(sha256
- (base32
- "11rhc6h501dwcik2igkszz7b9n515cr99m5pjh4r2qfwgiri6ysa"))))
+ (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
- ;; 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")))
+ `(#: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
- (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")
+ `(("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
- "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))
+ "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-spatial-trees
- (sbcl-package->cl-source-package sbcl-spatial-trees))
+(define-public cl-aserve
+ (sbcl-package->cl-source-package sbcl-aserve))
-(define-public sbcl-flexichain
- ;; There are no releases.
- (let ((commit "9af644a6323f303a936a391b956babcbfe7b0c67")
- (revision "2"))
+(define-public sbcl-assoc-utils
+ (let ((commit "74af16a3c0f10ad35e406167de02984744fc7854")
+ (revision "1"))
(package
- (name "sbcl-flexichain")
- (version (git-version "1.5.1" revision commit))
+ (name "sbcl-assoc-utils")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Flexichain")
+ (url "https://github.com/fukamachi/assoc-utils")
(commit commit)))
- (file-name (git-file-name "cl-flexichain" version))
+ (file-name (git-file-name "cl-assoc-utils" version))
(sha256
- (base32 "1ivkffnkc1iqmpl1p1rgyfbbgjmjcid4iszvdql1jjz324lq94g6"))))
+ (base32 "1yac1v7zmdxj0p6rvwrrhyqvy7yjfhmqbchkwqhhr89gpjvvaick"))))
(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")
+ (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
- "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+))))
+ "@code{assoc-utils} provides utilities for manipulating association
+lists in Common Lisp.")
+ (license license:public-domain))))
-(define-public ecl-flexichain
- (sbcl-package->ecl-package sbcl-flexichain))
+(define-public cl-assoc-utils
+ (sbcl-package->cl-source-package sbcl-assoc-utils))
-(define-public cl-flexichain
- (sbcl-package->cl-source-package sbcl-flexichain))
+(define-public ecl-assoc-utils
+ (sbcl-package->ecl-package sbcl-assoc-utils))
-(define-public sbcl-cl-pdf
- (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213")
- (revision "3"))
+(define-public sbcl-atomichron
+ (let ((commit "5b3578bbad8c37ab559e56924d98c373efe11de5")
+ (revision "0"))
(package
- (name "sbcl-cl-pdf")
- (version (git-version "2.0.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/mbattyani/cl-pdf")
+ (url "https://github.com/no-defun-allowed/atomichron")
(commit commit)))
- (file-name (git-file-name "cl-pdf" version))
+ (file-name (git-file-name "cl-atomichron" version))
(sha256
- (base32 "0j7hbqv6yzrgx0inqinpw8h22728l53ccciw6iymzz4g92j9fzlq"))))
+ (base32 "1fmmhb3pbv7j4d1cc02zv24bpd0kd2agfjjcj46w3gmv1bb0hva1"))))
(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")
+ (list sbcl-atomics sbcl-bordeaux-threads))
+ (home-page "https://github.com/no-defun-allowed/atomichron")
+ (synopsis "Atomic metering library for Common Lisp")
(description
- "CL-PDF is a cross-platform Common Lisp library for generating PDF
-files.")
+ "@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 ecl-cl-pdf
- (sbcl-package->ecl-package sbcl-cl-pdf))
+(define-public cl-atomichron
+ (sbcl-package->cl-source-package sbcl-atomichron))
-(define-public cl-pdf
- (sbcl-package->cl-source-package sbcl-cl-pdf))
+(define-public ecl-atomichron
+ (sbcl-package->ecl-package sbcl-atomichron))
-(define-public sbcl-clx
- (let ((commit "38400456d66823e417d1d27d339b09885e25eb59")
- (revision "1"))
+(define-public sbcl-atomics
+ ;; No release in years.
+ (let ((commit "b7477024894e322bff9c85e6d81e5e8d1d4eae59")
+ (revision "2"))
(package
- (name "sbcl-clx")
- (version (git-version "0.7.5" revision commit))
+ (name "sbcl-atomics")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/sharplispers/clx")
- (commit commit)))
+ (uri (git-reference
+ (url "https://github.com/Shinmera/atomics")
+ (commit commit)))
+ (file-name (git-file-name "cl-atomics" version))
(sha256
- (base32 "1c05gjqh5lil2sgma0yap4mxd9y1cjkp933hyx1iaj14950nhfnl"))
- (file-name (git-file-name "cl-clx" version))))
+ (base32 "1ah6fgvfva0axnhj4sp1qy6gjyw41fkhpnv998di0wbp6hls8j39"))))
(build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-documentation-utils))
(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))))
+ (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-clx
- (sbcl-package->cl-source-package sbcl-clx))
+(define-public cl-atomics
+ (sbcl-package->cl-source-package sbcl-atomics))
-(define-public ecl-clx
- (sbcl-package->ecl-package sbcl-clx))
+(define-public ecl-atomics
+ (sbcl-package->ecl-package sbcl-atomics))
-(define-public sbcl-cl-wayland
- (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae")
- (revision "0"))
+(define-public sbcl-authentic
+ (let ((commit "4e9194dda227b98f56dda1c2a2480efcc2d1f973")
+ (revision "2"))
(package
- (name "sbcl-cl-wayland")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-authentic")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sdilts/cl-wayland")
+ (url "https://github.com/charje/cl-authentic")
(commit commit)))
- (file-name (git-file-name "cl-wayland" version))
+ (file-name (git-file-name "cl-authentic" version))
(sha256
- (base32 "1r4fn9dc0dz2b30k8z243yacx1y5z21qk4zh2ildj7ak51qx53zf"))))
+ (base32 "0ncsxrybnx0pjsndv3j8w4lphlpcsld8sxg3c5b46fb3a8nd4ssf"))))
(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"))))))))
+ (native-inputs
+ (list sbcl-fiveam))
(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))))
+ (list sbcl-clsql sbcl-ironclad))
+ (home-page "https://github.com/charje/cl-authentic")
+ (synopsis "User/password management for Common Lisp applications")
+ (description "Authentic provides a light-weight and extendible
+solution to user/password management for Common Lisp applications. It has
+features such as safe password storage in a database, password reset, user
+confirmation tokens, and user authentication.")
+ (license license:llgpl))))
-(define-public cl-wayland
- (sbcl-package->cl-source-package sbcl-cl-wayland))
+(define-public ecl-authentic
+ (sbcl-package->ecl-package sbcl-authentic))
-(define-public ecl-cl-wayland
- (sbcl-package->ecl-package sbcl-cl-wayland))
+(define-public cl-authentic
+ (sbcl-package->cl-source-package sbcl-authentic))
-(define-public sbcl-clx-truetype
- (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
- (revision "1"))
+(define-public sbcl-babel
+ ;; No release since 2014.
+ (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9")
+ (revision "3"))
(package
- (name "sbcl-clx-truetype")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-babel")
+ (version (git-version "0.5.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/l04m33/clx-truetype")
+ (url "https://github.com/cl-babel/babel")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-babel" version))
(sha256
- (base32
- "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- (substitute* "package.lisp"
- ((":export") ":export\n :+font-cache-filename+"))
- #t))))
+ (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-hu.dwim.stefil))
(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))))
+ (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-clx-truetype
- (sbcl-package->cl-source-package sbcl-clx-truetype))
+(define-public cl-babel
+ (sbcl-package->cl-source-package sbcl-babel))
-(define-public ecl-clx-truetype
- (sbcl-package->ecl-package sbcl-clx-truetype))
+(define-public ecl-babel
+ (sbcl-package->ecl-package sbcl-babel))
-(define-public sbcl-slynk
- ;; Update together with emacs-sly.
- (let ((commit "9c43bf65b967e12cef1996f1af5f0671d8aecbf4")
- (revision "9"))
+(define-public sbcl-binary-types
+ (let ((commit "9ec42042a50403961c08179a892ae3de725b1d7a"))
(package
- (name "sbcl-slynk")
- (version (git-version "1.0.43" revision commit))
+ (name "sbcl-binary-types")
+ (version (git-version "1.2" "1" commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/joaotavora/sly")
- (commit commit)))
+ (uri (git-reference
+ (url "https://github.com/frodef/binary-types/")
+ (commit commit)))
+ (file-name (git-file-name "binary-types" version))
(sha256
- (base32 "15nyr02ykkws4q79jcmxcawddg8sgq9v5l8k7jv7gg3hnpzxjlb2"))
- (file-name (git-file-name "cl-slynk" version))))
+ (base32 "0kp4xwblfxh7gmgqc38k9xzrqlcr0q1jm5167ma1pajdxd3182j8"))))
(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)))))))
+ (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-slynk
- (sbcl-package->cl-source-package sbcl-slynk))
+(define-public cl-binary-types
+ (sbcl-package->cl-source-package sbcl-binary-types))
-(define-public ecl-slynk
- (let ((pkg (sbcl-package->ecl-package sbcl-slynk)))
- (package
- (inherit pkg)
- (outputs '("out"))
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ((#:phases phases)
- `(modify-phases ,phases
- (delete 'build-image))))))))
+(define-public ecl-binary-types
+ (sbcl-package->ecl-package sbcl-binary-types))
-(define-public sbcl-parse-js
- (let ((commit "fbadc6029bec7039602abfc06c73bb52970998f6")
+(define-public sbcl-binascii
+ (let ((commit "0fb0a9e5773148fd04d50efef08c1cc10f6fc487")
(revision "1"))
(package
- (name "sbcl-parse-js")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-binascii")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://marijn.haverbeke.nl/git/parse-js")
+ (url "https://github.com/sharplispers/binascii")
(commit commit)))
- (file-name (git-file-name "cl-parse-js" version))
+ (file-name (git-file-name "cl-binascii" version))
(sha256
- (base32
- "1wddrnr5kiya5s3gp4cdq6crbfy9fqcz7fr44p81502sj3bvdv39"))))
+ (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)
- (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))
+ (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 ecl-parse-number
- (sbcl-package->ecl-package sbcl-parse-number))
+(define-public cl-binascii
+ (sbcl-package->cl-source-package sbcl-binascii))
-(define-public sbcl-iterate
- (package
- (name "sbcl-iterate")
- (version "1.5.3")
- (source
- (origin
+(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://gitlab.common-lisp.net/iterate/iterate.git")
- (commit version)))
- (file-name (git-file-name "cl-iterate" version))
+ (url "https://github.com/phoe/binding-arrows")
+ (commit commit)))
+ (file-name (git-file-name "cl-binding-arrows" 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:
+ (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}.
-@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)))
+This system is a fork of @code{arrows} with changes in semantics that make it
+impossible to merge back upstream.")
+ (license license:expat))))
-(define-public cl-iterate
- (sbcl-package->cl-source-package sbcl-iterate))
+(define-public ecl-binding-arrows
+ (sbcl-package->ecl-package sbcl-binding-arrows))
-(define-public ecl-iterate
- (sbcl-package->ecl-package sbcl-iterate))
+(define-public cl-binding-arrows
+ (sbcl-package->cl-source-package sbcl-binding-arrows))
-(define-public sbcl-charje.loop
- (package
- (name "sbcl-charje.loop")
- (version "0.0.0")
- (source
- (origin
+(define-public sbcl-binpack
+ (let ((commit "e67f56bb697bdeac81e28e1cca4a5d117a9cf125")
+ (revision "1"))
+ (package
+ (name "sbcl-binpack")
+ (version (git-version "0.0.1" revision commit))
+ (source
+ (origin
(method git-fetch)
(uri (git-reference
- (url "https://git.sr.ht/~charje/loop")
- (commit (string-append "v" version))))
- (file-name (git-file-name "cl-charje.loop" version))
+ (url "https://github.com/lispgames/binpack")
+ (commit commit)))
+ (file-name (git-file-name "binpack" 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+)))
+ (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-charje.loop
- (sbcl-package->cl-source-package sbcl-charje.loop))
+(define-public cl-binpack
+ (sbcl-package->cl-source-package sbcl-binpack))
-(define-public ecl-charje.loop
- (sbcl-package->ecl-package sbcl-charje.loop))
+(define-public ecl-binpack
+ (sbcl-package->ecl-package sbcl-binpack))
-(define-public sbcl-cl-uglify-js
- ;; There have been many bug fixes since the 2010 release.
- (let ((commit "429c5e1d844e2f96b44db8fccc92d6e8e28afdd5")
- (revision "1"))
+(define-public sbcl-bit-smasher
+ ;; No release.
+ (let ((commit "c2dcb3b5ec0e485484be681fe17c4e81e58790d9"))
(package
- (name "sbcl-cl-uglify-js")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-bit-smasher")
+ (version (git-version "1.0.2" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mishoo/cl-uglify-js")
+ (url "https://github.com/thephoeron/bit-smasher/")
(commit commit)))
- (file-name (git-file-name "cl-uglify-js" version))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
+ (base32 "0wjmwn06fjpw0rlpaksf3ab727p8fnzj58z7jajl3m0wqd4ii74w"))))
(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")
+ `(("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
- "@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")
+ "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-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 cl-bit-smasher
+ (sbcl-package->cl-source-package sbcl-bit-smasher))
-(define-public ecl-trivial-features
- (sbcl-package->ecl-package sbcl-trivial-features))
+(define-public ecl-bit-smasher
+ (sbcl-package->ecl-package sbcl-bit-smasher))
-(define-public sbcl-harmony
- (let ((commit "0b57483cc0341936c201b620f82a8542c606991f")
- (revision "0"))
+(define-public sbcl-bknr-datastore
+ (let ((commit "c98d44f47cc88d19ff91ca3eefbd9719a8ace022")
+ (revision "1"))
(package
- (name "sbcl-harmony")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-bknr-datastore")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/harmony")
+ (url "https://github.com/hanshuebner/bknr-datastore")
(commit commit)))
- (file-name (git-file-name "cl-harmony" version))
+ (file-name (git-file-name "bknr-datastore" version))
(sha256
- (base32 "0pqmfi3yi3gi7b7dyayrb621hp60rn7hasq0cl0fis3vg0fp5dja"))))
+ (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
- (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")
+ `(("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
- "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))))
+ "BKNR.DATASTORE is an in-memory CLOS based database with transactions
+for Common Lisp.")
+ (license license:bsd-0))))
-(define-public ecl-harmony
- (sbcl-package->ecl-package sbcl-harmony))
+(define-public cl-bknr-datastore
+ (sbcl-package->cl-source-package sbcl-bknr-datastore))
-(define-public cl-harmony
- (sbcl-package->cl-source-package sbcl-harmony))
+;; 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-hu.dwim.asdf
- (let ((commit "67cdf84390e530af4303cc4bc815fdf2a5e48f59"))
+(define-public sbcl-blackbird
+ (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
+ (revision "1"))
(package
- (name "sbcl-hu.dwim.asdf")
- (version "20200724")
+ (name "sbcl-blackbird")
+ (version (git-version "0.5.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.asdf")
+ (url "https://github.com/orthecreedence/blackbird")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "0p81jalilkaqw832a12s35q0z6rrarxjasm1jy6h4fvyj9pf0zkx"))))
+ "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
(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))))
+ (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-hu.dwim.asdf
- (sbcl-package->cl-source-package sbcl-hu.dwim.asdf))
+(define-public cl-blackbird
+ (sbcl-package->cl-source-package sbcl-blackbird))
-(define-public ecl-hu.dwim.asdf
- (sbcl-package->ecl-package sbcl-hu.dwim.asdf))
+(define-public ecl-blackbird
+ (sbcl-package->ecl-package sbcl-blackbird))
-(define-public sbcl-hu.dwim.graphviz
- (let ((commit "31522ca8b9a04d535b7cec20ef24d8bf3b26d52b")
- (revision "1"))
+(define-public sbcl-bobbin
+ (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce")
+ (revision "0"))
(package
- (name "sbcl-hu.dwim.graphviz")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-bobbin")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.graphviz")
+ (url "https://github.com/sjl/bobbin")
(commit commit)))
- (file-name (git-file-name "cl-hu.dwim.graphviz" version))
+ (file-name (git-file-name "cl-bobbin" version))
(sha256
- (base32 "0cz5g7d6817ajypp876k9m65sxxlf42x4bg04ya73aqci5s1vjwy"))))
+ (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm"))))
(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))
+ (list sbcl-1am))
(inputs
- (list graphviz sbcl-cffi sbcl-metabang-bind))
- (home-page "https://github.com/hu-dwim/hu.dwim.graphviz")
- (synopsis "Graphviz layouting using CFFI bindings")
+ (list sbcl-split-sequence))
+ (home-page "https://docs.stevelosh.com/bobbin/")
+ (synopsis "Simple (word) wrapping utilities for strings")
(description
- "This package provides CFFI bindings to the Graphviz library in Common
-Lisp.")
- (license license:public-domain))))
+ "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-hu.dwim.graphviz
- (sbcl-package->cl-source-package sbcl-hu.dwim.graphviz))
+(define-public cl-bobbin
+ (sbcl-package->cl-source-package sbcl-bobbin))
-(define-public ecl-hu.dwim.graphviz
- (sbcl-package->ecl-package sbcl-hu.dwim.graphviz))
+(define-public ecl-bobbin
+ (sbcl-package->ecl-package sbcl-bobbin))
-(define-public sbcl-cl-dot
- (let ((commit "73dfbb6e015a28ebed873266e4e8190e509b43de")
+(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-cl-dot")
- (version (git-version "0.9.0" revision commit))
+ (name "sbcl-bodge-queue")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/michaelw/cl-dot")
+ (url "https://github.com/borodust/bodge-queue")
(commit commit)))
- (file-name (git-file-name "cl-dot" version))
+ (file-name (git-file-name "bodge-queue" version))
(sha256
- (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa"))))
+ (base32 "148hjikqk8v2m30mj15xh89zni6szf9z3prav580qk9dqr8djjdr"))))
(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.")
+ (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-dot
- (sbcl-package->cl-source-package sbcl-cl-dot))
+(define-public cl-bodge-queue
+ (sbcl-package->cl-source-package sbcl-bodge-queue))
-(define-public ecl-cl-dot
- (sbcl-package->ecl-package sbcl-cl-dot))
+(define-public ecl-bodge-queue
+ (sbcl-package->ecl-package sbcl-bodge-queue))
-(define-public sbcl-cl-graph
- (let ((commit "c617de35390cb02db88bc5b5febffafdb8947ae8")
- (revision "2"))
+(define-public sbcl-bodge-utilities
+ (let ((commit "6304bac4abe06d53579e2c0fc4437d14ff077d9f")
+ (revision "1"))
(package
- (name "sbcl-cl-graph")
- (version (git-version "0.10.2" revision commit))
+ (name "sbcl-bodge-utilities")
+ (version (git-version "1.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/borodust/bodge-utilities")
+ (commit commit)))
+ (file-name (git-file-name "bodge-utilities" version))
+ (sha256
+ (base32 "1z1blj05q71vzh323qwyn9p3xs7v0mq2yhwfyzza5libp37wqm3c"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-alexandria
+ sbcl-cffi
+ sbcl-claw
+ sbcl-dissect
+ sbcl-local-time
+ sbcl-log4cl
+ sbcl-split-sequence
+ sbcl-static-vectors
+ sbcl-trivial-gray-streams))
+ (home-page "https://github.com/borodust/bodge-utilities")
+ (synopsis "Common Lisp utilities library for CL-BODGE")
+ (description
+ "This Common Lisp library provides utilities for the @emph{Bodge} library
+collection.")
+ (license license:expat))))
+
+(define-public cl-bodge-utilities
+ (sbcl-package->cl-source-package sbcl-bodge-utilities))
+
+(define-public ecl-bodge-utilities
+ (sbcl-package->ecl-package sbcl-bodge-utilities))
+
+(define-public sbcl-boost-json
+ (let ((commit "eca166f5ff1f10bad14e00b9fd5bf9fcf3691a47")
+ (revision "0"))
+ (package
+ (name "sbcl-boost-json")
+ (version (git-version "1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/cl-graph")
+ (url "https://github.com/cl-boost/json")
(commit commit)))
- (file-name (git-file-name "cl-graph" version))
+ (file-name (git-file-name "cl-boost-json" version))
(sha256
- (base32 "0g1abkph9zb0m9zz6q2471ml9q9acdhwyapk8ra3bisqpwlxvpyf"))))
+ (base32 "12k0470899qsll2qixksxf2vrhjmskk3nzp1di9k04n1b29nrakd"))))
(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")
+ '(#:phases
+ (modify-phases %standard-phases
+ ;; See <https://github.com/cl-boost/json/pull/2>.
+ (add-after 'unpack 'fix-decode-symbol
+ (lambda _
+ (substitute* '("decode.lisp" "encode.lisp")
+ (("formfeed") "page")))))))
+ (home-page "https://github.com/cl-boost/json")
+ (synopsis "JSON encoding and decoding for Common Lisp")
(description
- "This package provides a Common Lisp library for manipulating graphs
-and running graph algorithms.")
- (license license:expat))))
+ "BOOST-JSON is a simple JSON parsing library for Common Lisp.")
+ (license license:asl2.0))))
-;; NOTE: (Sharlatan-20221118T214734+0000): No ECL supoort
-;;
-;; ecl-cl-graph
+(define-public cl-boost-json
+ (sbcl-package->cl-source-package sbcl-boost-json))
-(define-public cl-cl-graph
- (sbcl-package->cl-source-package sbcl-cl-graph))
+(define-public ecl-boost-json
+ (sbcl-package->ecl-package sbcl-boost-json))
-(define-public sbcl-babel
- ;; No release since 2014.
- (let ((commit "627d6a60d0ffc82a3687b39ba8a99128031504d9")
- (revision "3"))
+(define-public sbcl-boost-lexer
+ (let ((commit "139ca9e9580f890698deec05061e495376b7735a")
+ (revision "0"))
(package
- (name "sbcl-babel")
- (version (git-version "0.5.0" revision commit))
+ (name "sbcl-boost-lexer")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-babel/babel")
+ (url "https://github.com/cl-boost/lexer")
(commit commit)))
- (file-name (git-file-name "cl-babel" version))
+ (file-name (git-file-name "cl-boost-lexer" version))
(sha256
- (base32 "1sndap9ykyyvrzlqm9smgqy49r3n67l926yg0hb7pm00plj0y380"))))
+ (base32 "01vsczb5cn62k2hkkn39xwh5fjn2x0b507n7afia98jnhhk3d5x4"))))
(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)))
+ (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-yacc
- (sbcl-package->cl-source-package sbcl-cl-yacc))
+(define-public cl-boost-lexer
+ (sbcl-package->cl-source-package sbcl-boost-lexer))
-(define-public ecl-cl-yacc
- (sbcl-package->ecl-package sbcl-cl-yacc))
+(define-public ecl-boost-lexer
+ (sbcl-package->ecl-package sbcl-boost-lexer))
-(define-public sbcl-eager-future2
- (let ((commit "54df8effd9d9eccac917509590286b5ac5f9cb30"))
+(define-public sbcl-boost-parse
+ (let ((commit "c8f7e536b950752f3e35003e7ee0446e0fd51b50")
+ (revision "0"))
(package
- (name "sbcl-eager-future2")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-boost-parse")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/vsedach/eager-future2.git")
+ (url "https://github.com/cl-boost/parse")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-boost-parse" version))
(sha256
- (base32
- "1qs1bv3m0ki8l5czhsflxcryh22r9d9g9a3a3b0cr0pl954q5rld"))))
+ (base32 "0djnp392n9wgpr9r2ycnwkglad5mn285yvr53jx3g7anm2p8r0vf"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-bordeaux-threads sbcl-trivial-garbage))
- (synopsis "Futures promises synchronization mechanism for Common Lisp")
+ (home-page "https://github.com/cl-boost/parse")
+ (synopsis "Monadic parsing 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+))))
+ "BOOST-PARSE is a simple token parsing library for Common Lisp.")
+ (license license:asl2.0))))
-(define-public cl-eager-future2
- (sbcl-package->cl-source-package sbcl-eager-future2))
+(define-public cl-boost-parse
+ (sbcl-package->cl-source-package sbcl-boost-parse))
-(define-public ecl-eager-future2
- (sbcl-package->ecl-package sbcl-eager-future2))
+(define-public ecl-boost-parse
+ (sbcl-package->ecl-package sbcl-boost-parse))
-(define-public sbcl-easy-routes
- (let ((commit "7832f8bf3d07825b5eb967a2ef04da7c40c18248")
+(define-public sbcl-boost-re
+ (let ((commit "d279fc58abf76d0c40aa6cde42e17a0591bc2c5d")
(revision "0"))
(package
- (name "sbcl-easy-routes")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-boost-re")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/easy-routes")
+ (url "https://github.com/cl-boost/re")
(commit commit)))
- (file-name (git-file-name "cl-easy-routes" version))
+ (file-name (git-file-name "cl-boost-re" version))
(sha256
- (base32 "1banw54kz2llzb9h5sm47ckfc9l348m7qncm0npsy0w837rxkyzx"))))
+ (base32 "1h9c2rdhw6m1pm67gqbj46y2vb1kc3i1c9y3l4qhgfz14dbk80a2"))))
(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")
+ (list sbcl-boost-parse))
+ (home-page "https://github.com/cl-boost/re")
+ (synopsis "Lua-style string pattern matching for Common Lisp")
(description
- "EASY-ROUTES is yet another routes handling system on top of
-Hunchentoot. It's just glue code for Restas routing subsystem (CL-ROUTES).
-
-It supports:
-@itemize
-@item dispatch based on HTTP method
-@item arguments extraction from the url path
-@item decorators
-@item URL generation from route names
-@end itemize
-
-This package provides EASY-ROUTES, EASY-ROUTES+DJULA and EASY-ROUTES+ERRORS
-systems.")
- (license license:expat))))
+ "BOOST-RE is a small, portable, lightweight, and quick, regular
+expression library for Common Lisp. It is a non-recursive, backtracking VM.")
+ (license license:asl2.0))))
-(define-public cl-easy-routes
- (sbcl-package->cl-source-package sbcl-easy-routes))
+(define-public cl-boost-re
+ (sbcl-package->cl-source-package sbcl-boost-re))
-(define-public ecl-easy-routes
- (sbcl-package->ecl-package sbcl-easy-routes))
+(define-public ecl-boost-re
+ (sbcl-package->ecl-package sbcl-boost-re))
-(define-public sbcl-jpl-util
- (let ((commit "0311ed374e19a49d43318064d729fe3abd9a3b62"))
+(define-public sbcl-bordeaux-fft
+ (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
+ (revision "0"))
(package
- (name "sbcl-jpl-util")
- (version "20151005")
+ (name "sbcl-bordeaux-fft")
+ (version (git-version "1.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- ;; Quicklisp uses this fork.
- (url "https://github.com/hawkir/cl-jpl-util")
+ (url "https://github.com/ahefner/bordeaux-fft")
(commit commit)))
- (file-name
- (git-file-name "jpl-util" version))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "0nc0rk9n8grkg3045xsw34whmcmddn2sfrxki4268g7kpgz0d2yz"))))
+ (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Collection of Common Lisp utility functions and macros")
+ (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/")
+ (synopsis "Fast Fourier Transform for Common Lisp")
(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))))
+ "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-jpl-util
- (sbcl-package->cl-source-package sbcl-jpl-util))
+(define-public cl-bordeaux-fft
+ (sbcl-package->cl-source-package sbcl-bordeaux-fft))
-(define-public ecl-jpl-util
- (sbcl-package->ecl-package sbcl-jpl-util))
+(define-public ecl-bordeaux-fft
+ (sbcl-package->ecl-package sbcl-bordeaux-fft))
-(define-public sbcl-piping
- (let ((commit "c7a4163c00dea7e72bf6ad33d6abac0d5826a656")
- (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-piping")
- (version (git-version "2.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/Shinmera/piping/")
+ (url "https://codeberg.org/glv/bst")
(commit commit)))
- (file-name (git-file-name "piping" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0in84qnfkynm36d4n4d6v87vprpi27xrydnga462wfhplji6klv5"))))
+ (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://shinmera.github.io/piping/")
- (synopsis "Library to enable simple message pipelines")
+ (native-inputs
+ (list sbcl-alexandria sbcl-fiveam))
+ (synopsis "Binary search tree for Common Lisp")
(description
- "This is a Common Lisp library to enable simple message pipelines.")
- (license license:zlib))))
+ "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-piping
- (sbcl-package->ecl-package sbcl-piping))
+(define-public cl-bst
+ (sbcl-package->cl-source-package sbcl-bst))
-(define-public cl-piping
- (sbcl-package->cl-source-package sbcl-piping))
+(define-public ecl-bst
+ (sbcl-package->ecl-package sbcl-bst))
-(define-public sbcl-bobbin
- (let ((commit "b454e8241b24ceab674eeeae464c8082b1b6d8ce")
+(define-public sbcl-bubble-operator-upwards
+ (let ((commit "846275a318b960de81b62caecb1e31930f70aef6")
(revision "0"))
(package
- (name "sbcl-bobbin")
- (version (git-version "1.0.1" revision commit))
+ (name "sbcl-bubble-operator-upwards")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sjl/bobbin")
+ (url "https://github.com/Hexstream/bubble-operator-upwards")
(commit commit)))
- (file-name (git-file-name "cl-bobbin" version))
+ (file-name (git-file-name "cl-bubble-operator-upwards" version))
(sha256
- (base32 "02lw7w8cbvnxw5acbz405rb5lcqsf4fx7dvj5ldr0lhgbyv1mjnm"))))
+ (base32 "0ybsy29ms3yrxgr7f2146lr6z4vm070dvdyzvwwxjh4dgm9na7bi"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-1am))
- (inputs
- (list sbcl-split-sequence))
- (home-page "https://docs.stevelosh.com/bobbin/")
- (synopsis "Simple (word) wrapping utilities for strings")
+ (list sbcl-parachute))
+ (home-page "https://www.hexstreamsoft.com/libraries/bubble-operator-upwards/")
+ (synopsis "Function that bubbles an operator upwards in a form")
(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))))
+ "@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-bobbin
- (sbcl-package->cl-source-package sbcl-bobbin))
+(define-public cl-bubble-operator-upwards
+ (sbcl-package->cl-source-package sbcl-bubble-operator-upwards))
-(define-public ecl-bobbin
- (sbcl-package->ecl-package sbcl-bobbin))
+(define-public ecl-bubble-operator-upwards
+ (sbcl-package->ecl-package sbcl-bubble-operator-upwards))
-(define-public sbcl-cl-pcg
- (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f")
- (revision "1"))
+(define-public sbcl-burgled-batteries3
+ (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
+ (revision "2"))
(package
- (name "sbcl-cl-pcg")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-burgled-batteries3")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sjl/cl-pcg")
+ (url "https://github.com/snmsts/burgled-batteries3")
(commit commit)))
- (file-name (git-file-name "cl-pcg" version))
+ (file-name (git-file-name "cl-burgled-batteries3" version))
(sha256
- (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4"))))
+ (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-1am))
- (home-page "https://github.com/sjl/cl-pcg")
- (synopsis "Permuted congruential generators in Common Lisp")
+ (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 is a bare-bones Permuted Congruential Generator implementation in
-pure Common Lisp.")
+ "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-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 cl-burgled-batteries3
+ (sbcl-package->cl-source-package sbcl-burgled-batteries3))
-(define-public cl-pcg
- (sbcl-package->cl-source-package sbcl-cl-pcg))
+(define-public ecl-burgled-batteries3
+ (sbcl-package->ecl-package sbcl-burgled-batteries3))
-(define-public sbcl-seedable-rng
- (let ((commit "aa1a1564b6e07e2698df37c7a98348c4f762cb15")
+(define-public sbcl-cache-while
+ (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7")
(revision "1"))
(package
- (name "sbcl-seedable-rng")
+ (name "sbcl-cache-while")
(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/charje/cache-while")
(commit commit)))
- (file-name (git-file-name "seedable-rng" version))
+ (file-name (git-file-name "cache-while" version))
(sha256
- (base32 "1ldpsbp3qrfzvknclsxj3sdyms1jf9ad20dvh4w0kw3zgahn2nr5"))))
+ (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3"))))
(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")
+ (home-page "https://github.com/charje/cache-while")
+ (synopsis "Temporary / one-time caching macro for Common Lisp")
(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 ecl-seedable-rng
- (sbcl-package->ecl-package sbcl-seedable-rng))
-
-(define-public cl-seedable-rng
- (sbcl-package->cl-source-package sbcl-seedable-rng))
-
-(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)))
+ "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-jpl-queues
- (sbcl-package->cl-source-package sbcl-jpl-queues))
+(define-public cl-cache-while
+ (sbcl-package->cl-source-package sbcl-cache-while))
-(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,1894 +2639,1489 @@ 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:
-
-@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))))
+ "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-esrap
- (sbcl-package->cl-source-package sbcl-esrap))
+(define-public cl-cambl
+ (sbcl-package->cl-source-package sbcl-cambl))
-(define-public ecl-esrap
- (sbcl-package->ecl-package sbcl-esrap))
+(define-public ecl-cambl
+ (sbcl-package->ecl-package sbcl-cambl))
-(define-public sbcl-split-sequence
+(define-public sbcl-canonicalized-initargs
(package
- (name "sbcl-split-sequence")
- (version "2.0.1")
+ (name "sbcl-canonicalized-initargs")
+ (version "2.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/split-sequence")
+ (url "https://github.com/Hexstream/canonicalized-initargs")
(commit (string-append "v" version))))
+ (file-name (git-file-name "cl-canonicalized-initargs" version))
(sha256
- (base32
- "172k7iv775kwism6304p6z7mqpjvipl57nq1bgvmbk445943fmhq"))
- (file-name (git-file-name "split-sequence" version))))
+ (base32 "0jmmjw86x9mmlfla4kdmdqf1fjrj0p2fmv1lc4k555mcf67mj2fq"))))
(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")
+ (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
- "A library for encoding text in various web-savvy encodings.")
- (home-page "https://quickdocs.org/html-encode/")
- (license license:expat)))
+ "This package provides a standard way to canonicalize slot values.")
+ (license license:unlicense)))
-(define-public cl-html-encode
- (sbcl-package->cl-source-package sbcl-html-encode))
+(define-public cl-canonicalized-initargs
+ (sbcl-package->cl-source-package sbcl-canonicalized-initargs))
-(define-public ecl-html-encode
- (sbcl-package->ecl-package sbcl-html-encode))
+(define-public ecl-canonicalized-initargs
+ (sbcl-package->ecl-package sbcl-canonicalized-initargs))
-(define-public sbcl-colorize
- (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
+(define-public sbcl-caveman
+ (let ((commit "35cd8bc6c322f9d88498405fc26168a1fb42ae1c") ; No release since 2012
+ (revision "2"))
(package
- (name "sbcl-colorize")
- (version (git-version "0.0.0" "1" commit))
+ (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/kingcons/colorize")
+ (url "https://github.com/fukamachi/caveman/")
(commit commit)))
+ (file-name (git-file-name "cl-caveman" version))
(sha256
- (base32
- "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
- (file-name (git-file-name "colorize" version))))
+ (base32 "1wvjm9m1fnapg0r9imhhcwgnhhqkkccnj3c0iw9yg1f72d7zhm2w"))))
(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))))
+ `(("ningle" ,cl-ningle)
+ ("lack" ,sbcl-lack)
+ ("cl-project" ,sbcl-cl-project)
+ ("dbi" ,sbcl-dbi)
+ ("sxql" ,sbcl-sxql)
+ ("cl-syntax" ,sbcl-cl-syntax)
+ ("myway" ,sbcl-myway)
+ ("quri" ,sbcl-quri)))
+ (native-inputs
+ `(("usocket" ,sbcl-usocket)
+ ("dexador" ,sbcl-dexador)
+ ("lack" ,sbcl-lack)
+ ("trivial-types" ,sbcl-trivial-types)
+ ("prove" ,sbcl-prove)))
+ (arguments
+ `(#:asd-systems '("caveman2"
+ "caveman2-db"
+ "caveman2-test"
+ "caveman-middleware-dbimanager")
+ ;; TODO: Tests fail with:
+ ;; writing /gnu/store/...-sbcl-caveman-2.4.0-1.faa5f7e/share/common-lisp/sbcl-source/caveman2/v2/t/tmp/myapp573/tests/myapp573.lisp
+ ;; While evaluating the form starting at line 38, column 0
+ ;; of #P"/tmp/guix-build-sbcl-caveman-2.4.0-1.faa5f7e.drv-0/source/v2/t/caveman.lisp":
+ ;; Unhandled ASDF/FIND-COMPONENT:MISSING-COMPONENT in thread #<SB-THREAD:THREAD "main thread" RUNNING
+ ;; {10009F8083}>:
+ ;; Component "myapp573" not found
+ ;;
+ ;; The above myapp573 component name is randomly generated by
+ ;; gensym on each test run. `(asdf:load-system *app-name*)` tries
+ ;; to load this component and fails.
+ ;; TODO: Ask fukamachi how to go around this.
+ #:tests? #f))
+ (synopsis "Lightweight web application framework in Common Lisp")
+ (description "Caveman is intended to be a collection of common parts for
+web applications. Caveman2 has three design goals:
-(define-public cl-colorize
- (sbcl-package->cl-source-package sbcl-colorize))
+@itemize
+@item Be extensible.
+@item Be practical.
+@item Don't force anything.
+@end itemize\n")
+ (license license:llgpl))))
-(define-public ecl-colorize
- (sbcl-package->ecl-package sbcl-colorize))
+(define-public cl-caveman
+ (package
+ (inherit
+ (sbcl-package->cl-source-package sbcl-caveman))
+ (propagated-inputs
+ `(("ningle" ,cl-ningle)))))
-(define-public sbcl-3bmd
- (let ((commit "e68b2d442f29b4534c1c8e2f2cdf7583643a2fc5")
- (revision "4"))
+(define-public ecl-caveman
+ (sbcl-package->ecl-package sbcl-caveman))
+
+(define-public sbcl-cells
+ (let ((commit "e8542b17fddd6340c1e237ce482a52327c8ead8e"))
(package
- (name "sbcl-3bmd")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cells")
+ (version (git-version "3.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/3bmd")
+ (url "https://github.com/kennytilton/cells")
(commit commit)))
+ (file-name (git-file-name "cl-cells" version))
(sha256
- (base32 "12xqih1gnwsn1baqm7bq3kxss73phn06gvd0v1h1vwsjd1xgpq3g"))
- (file-name (git-file-name "cl-3bmd" version))))
+ (base32 "0rkzvwq38lwb1045w54kw020pb9i63hxiawwhqkf8k1inhak3fdk"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems
- '("3bmd"
- "3bmd-ext-definition-lists"
- "3bmd-ext-math"
- "3bmd-ext-tables"
- "3bmd-ext-wiki-links"
- "3bmd-youtube"
- "3bmd-ext-code-blocks")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-python3-path
- (lambda _
- (substitute* "code-blocks.lisp"
- (("python3") (which "python3"))))))))
- (native-inputs
- (list sbcl-fiasco))
(inputs
- (list python
- python-pygments
- sbcl-alexandria
- sbcl-colorize
- sbcl-split-sequence
- sbcl-esrap))
- (home-page "https://github.com/3b/3bmd")
- (synopsis "Markdown processor in Command Lisp using esrap parser")
+ (list sbcl-utils-kt))
+ (arguments
+ ;; Tests fail with #<TYPE-ERROR expected-type: STREAM datum: NIL>.
+ '(#:tests? #f))
+ (home-page "https://github.com/kennytilton/cells")
+ (synopsis "Common Lisp implementation of the dataflow programming paradigm")
(description
- "This is a Common Lisp Markdown to HTML converter, using @command{esrap}
-for parsing, and grammar based on @command{peg-markdown}.")
- (license license:expat))))
+ "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-3bmd
- (sbcl-package->cl-source-package sbcl-3bmd))
+(define-public cl-cells
+ (sbcl-package->cl-source-package sbcl-cells))
-(define-public ecl-3bmd
- (sbcl-package->ecl-package sbcl-3bmd))
+(define-public ecl-cells
+ (sbcl-package->ecl-package sbcl-cells))
-(define-public sbcl-cl-fad
- ;; No release since 2019
- (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535")
- (revision "1"))
+(define-public sbcl-cephes
+ (let ((commit "d87146fa38c8425ffb5fe425eee5eb3e818bacd4")
+ (revision "0"))
(package
- (name "sbcl-cl-fad")
- (version (git-version "0.7.6" revision commit))
+ (name "sbcl-cephes")
+ (version (git-version "1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/cl-fad/")
+ (url "https://github.com/Lisp-Stat/cephes.cl")
(commit commit)))
+ (file-name (git-file-name "cl-cephes" version))
(sha256
- (base32 "0a1xqldrq170lflnns3xp6swpnvsvllf5vq0h7sz8jqh4riqlny6"))
- (file-name (git-file-name "cl-fad" version))))
+ (base32 "09adls1lwwzwm1jmvhf11arwlsy5w0bi2rmniahas824mysv77lr"))))
(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")
+ (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
- "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))))
+ "This package provides a common lisp CFFI wrapper for the SciPy version
+of Cephes special functions.")
+ (license license:ms-pl))))
-(define-public cl-fad
- (sbcl-package->cl-source-package sbcl-cl-fad))
+(define-public cl-cephes
+ (sbcl-package->cl-source-package sbcl-cephes))
-(define-public ecl-cl-fad
- (sbcl-package->ecl-package sbcl-cl-fad))
+(define-public ecl-cephes
+ (sbcl-package->ecl-package sbcl-cephes))
-(define-public sbcl-fn
- (let ((commit "8d8587d03a7b5e26b306fc90018e385d9e5acc2c")
+(define-public sbcl-cepl
+ (let ((commit "d1a10b6c8f4cedc07493bf06aef3a56c7b6f8d5b")
(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))
+ (name "sbcl-cepl")
+ (version (git-version "0.0.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/cbaggers/cepl")
+ (commit commit)))
+ (file-name (git-file-name "cepl" version))
+ (sha256
+ (base32 "0izbw2advqm3wailj3dpq6zqfrfirwn14pw5qmqh8i71r51xwmm2"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-opengl" ,sbcl-cl-opengl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("documentation-utils" ,sbcl-documentation-utils)
+ ("float-features" ,sbcl-float-features)
+ ("ieee-floats" ,sbcl-ieee-floats)
+ ("split-sequence" ,sbcl-split-sequence)
+ ("varjo" ,sbcl-varjo)))
+ (propagated-inputs
+ (list sbcl-quickproject))
+ (home-page "https://github.com/cbaggers/cepl")
+ (synopsis "Development playground to work with OpenGL")
+ (description
+ "CEPL (Code Evaluate Play Loop ) is a lispy and REPL-friendly Common Lisp
+library for working with OpenGL.
-(define-public 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.
+Its definition of success is making the user feel that GPU programming has
+always been part of the languages standard.
-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))))
+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-nibbles
- (sbcl-package->cl-source-package sbcl-nibbles))
+(define-public cl-cepl
+ (sbcl-package->cl-source-package sbcl-cepl))
-(define-public ecl-nibbles
- (sbcl-package->ecl-package sbcl-nibbles))
+(define-public ecl-cepl
+ (sbcl-package->ecl-package sbcl-cepl))
-(define-public sbcl-ironclad
+(define-public sbcl-cesdi
(package
- (name "sbcl-ironclad")
- (version "0.60")
+ (name "sbcl-cesdi")
+ (version "1.0.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/ironclad/")
- (commit (string-append "v" version))))
+ (url "https://github.com/Hexstream/cesdi")
+ (commit version)))
+ (file-name (git-file-name "cl-cesdi" version))
(sha256
- (base32 "122ldxiddkscb3li5wjrppr7vyn77znyjfgs8pbflrskzyxlabdd"))
- (file-name (git-file-name "cl-ironclad" version))))
+ (base32 "02f2pz5rw79ljkkx1ywh8nkpjj4g3z3s1lyvzqb8krbnx11wl0q9"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- ;; Tests only.
- (list sbcl-rt))
+ (list sbcl-parachute))
(inputs
- (list sbcl-bordeaux-threads sbcl-flexi-streams))
- (synopsis "Cryptographic toolkit written in Common Lisp")
+ (list sbcl-closer-mop))
+ (home-page "https://www.hexstreamsoft.com/libraries/cesdi/")
+ (synopsis "Ergonomic initialization of effective slot definition objects")
(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))))
+ "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-ini
- (sbcl-package->cl-source-package sbcl-cl-ini))
+(define-public cl-cesdi
+ (sbcl-package->cl-source-package sbcl-cesdi))
-(define-public ecl-cl-ini
- (sbcl-package->ecl-package sbcl-cl-ini))
+(define-public ecl-cesdi
+ (sbcl-package->ecl-package sbcl-cesdi))
-(define-public sbcl-pythonic-string-reader
- (let ((commit "47a70ba1e32362e03dad6ef8e6f36180b560f86a"))
+(define-public sbcl-cf
+ (let ((commit "fbc025b6f274687ee9acc8d07496d44999ac428e")
+ (revision "2"))
(package
- (name "sbcl-pythonic-string-reader")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-cf")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/smithzvk/pythonic-string-reader/")
+ (url "https://codeberg.org/glv/cl-cf")
(commit commit)))
+ (file-name (git-file-name "cl-cf" version))
(sha256
- (base32 "1b5iryqw8xsh36swckmz8rrngmc39k92si33fgy5pml3n9l5rq3j"))
- (file-name (git-file-name "pythonic-string-reader" version))))
+ (base32 "182laa57j9qs567g75qwf8vh4xb0d22lr94x84r32dy28mrwi5ig"))))
(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))))
+ (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-slime-swank
- (sbcl-package->cl-source-package sbcl-slime-swank))
+(define-public cl-cf
+ (sbcl-package->cl-source-package sbcl-cf))
-(define-public ecl-slime-swank
- (sbcl-package->ecl-package sbcl-slime-swank))
+(define-public ecl-cf
+ (sbcl-package->ecl-package sbcl-cf))
-(define-public sbcl-mgl-pax
- (let ((commit "6782eb041c152721972420dfafa192692d16b7ce")
+(define-public sbcl-cffi
+ (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112")
(revision "1"))
(package
- (name "sbcl-mgl-pax")
- (version (git-version "0.3.0" revision commit))
+ (name "sbcl-cffi")
+ (version (git-version "0.24.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/melisgl/mgl-pax")
+ (url "https://github.com/cffi/cffi")
(commit commit)))
+ (file-name (git-file-name "cl-cffi" version))
(sha256
- (base32 "0fjbzc2fn17m80lfsc8121sa0bk7fg42fqlwhm01sk1fj4s48pma"))
- (file-name (git-file-name "cl-mgl-pax" version))))
+ (base32 "1h7cw15f08gm6m4yz8hk7qkfwp7mwwnykjc5py6dhjakv0wh1g37"))))
(build-system asdf-build-system/sbcl)
- ;; (native-inputs
- ;; (list sbcl-try))
(inputs
- (list sbcl-3bmd
+ (list libffi
sbcl-alexandria
- sbcl-colorize
- sbcl-md5
- sbcl-named-readtables
- sbcl-pythonic-string-reader
- sbcl-slime-swank
- sbcl-trivial-utf-8))
+ sbcl-babel
+ sbcl-trivial-features))
+ (native-inputs
+ (list pkg-config
+ sbcl-bordeaux-threads
+ sbcl-rt))
(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/")
+ (list #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "libffi/libffi.lisp"
+ (("libffi.so.8" all)
+ (search-input-file inputs (string-append "/lib/" all))))
+ (substitute* "toolchain/c-toolchain.lisp"
+ (("\"cc\"")
+ (format #f "~S" (which "gcc"))))))
+ (add-after 'build 'install-headers
+ (lambda _
+ (install-file "grovel/common.h"
+ (string-append #$output
+ "/include/grovel")))))
+ #:asd-systems ''("cffi"
+ "cffi-libffi"
+ "cffi-uffi-compat")))
+ (home-page "https://common-lisp.net/project/cffi/")
+ (synopsis "Common Foreign Function Interface for Common Lisp")
+ (description "The Common Foreign Function Interface (CFFI)
+purports to be a portable foreign function interface for Common Lisp.
+The CFFI library is composed of a Lisp-implementation-specific backend
+in the CFFI-SYS package, and a portable frontend in the CFFI
+package.")
(license license:expat))))
-(define-public cl-mgl-pax
- (sbcl-package->cl-source-package sbcl-mgl-pax))
+(define-public cl-cffi
+ (sbcl-package->cl-source-package sbcl-cffi))
-(define-public ecl-mgl-pax
- (sbcl-package->ecl-package sbcl-mgl-pax))
+(define-public ecl-cffi
+ (sbcl-package->ecl-package sbcl-cffi))
-(define-public sbcl-40ants-doc
- (let ((commit "7725ff67a380e9ebfc6155e14d91e650f256711b")
+
+(define-public sbcl-cffi-c-ref
+ (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce")
(revision "0"))
(package
- (name "sbcl-40ants-doc")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-cffi-c-ref")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/40ants/doc")
+ (url "https://github.com/borodust/cffi-c-ref")
(commit commit)))
(sha256
- (base32 "1v6gnhrk02vsixmprzk4wvvj7vh11vp5waxyih0qz2ih8d38r5pg"))
- (file-name (git-file-name "cl-40ants-doc" version))))
+ (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z"))
+ (file-name (git-file-name "cffi-c-ref" 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")
+ (list sbcl-alexandria sbcl-cffi))
+ (synopsis "Streamlined access to foreign memory")
(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.")
+ "This Common Lisp library provides macros to access foreign memory.")
+ (home-page "https://github.com/borodust/cffi-c-ref")
(license license:expat))))
-(define-public cl-40ants-doc
- (sbcl-package->cl-source-package sbcl-40ants-doc))
+(define-public cl-cffi-c-ref
+ (sbcl-package->cl-source-package sbcl-cffi-c-ref))
-(define-public ecl-40ants-doc
- (sbcl-package->ecl-package sbcl-40ants-doc))
+(define-public ecl-cffi-c-ref
+ (sbcl-package->ecl-package sbcl-cffi-c-ref))
-(define-public sbcl-mssql
- (let ((commit "045602a19a32254108f2b75871049293f49731eb")
+(define-public sbcl-chanl
+ (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
(revision "1"))
(package
- (name "sbcl-mssql")
- (version (git-version "0.0.3" 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/archimag/cl-mssql")
+ (url "https://github.com/zkat/chanl")
(commit commit)))
- (file-name (git-file-name "cl-mssql" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "09i50adppgc1ybm3ka9vbindhwa2x29f9n3n0jkrryymdhb8zknm"))))
+ (base32
+ "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(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))))
+ (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 ecl-mssql
- (sbcl-package->ecl-package sbcl-mssql))
+(define-public cl-chanl
+ (sbcl-package->cl-source-package sbcl-chanl))
-(define-public cl-mssql
- (sbcl-package->cl-source-package sbcl-mssql))
+(define-public ecl-chanl
+ (sbcl-package->ecl-package sbcl-chanl))
-(define-public sbcl-anaphora
+(define-public sbcl-charje.documentation
(package
- (name "sbcl-anaphora")
- (version "0.9.8")
+ (name "sbcl-charje.documentation")
+ (version "0.0.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tokenrove/anaphora")
- (commit version)))
+ (url "https://git.sr.ht/~charje/documentation")
+ (commit (string-append "v" version))))
(sha256
- (base32 "1ds5ab0rzkrhfl29xpvmvyxmkdyj9mi19p330pz603lx95njjc0b"))
- (file-name (git-file-name "cl-anaphora" version))))
+ (base32
+ "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc"))
+ (file-name (git-file-name "cl-charje.documentation" version))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-rt))
- (synopsis "The anaphoric macro collection from Hell")
- (description
- "Anaphora is the anaphoric macro collection from Hell: it includes many
-new fiends in addition to old friends like @command{aif} and
-@command{awhen}.")
- (home-page "https://github.com/tokenrove/anaphora")
- (license license:public-domain)))
-
-(define-public cl-anaphora
- (sbcl-package->cl-source-package sbcl-anaphora))
-
-(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))
+ (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 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-charje.documentation
+ (sbcl-package->cl-source-package sbcl-charje.documentation))
-(define-public ecl-cl-cairo2
- (sbcl-package->ecl-package sbcl-cl-cairo2))
+(define-public ecl-charje.documentation
+ (sbcl-package->ecl-package sbcl-charje.documentation))
-(define-public cl-cairo2
- (sbcl-package->cl-source-package sbcl-cl-cairo2))
+(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 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
+(define-public cl-charje.loop
+ (sbcl-package->cl-source-package sbcl-charje.loop))
-@itemize
-@item Types for representing colors in HSV and RGB spaces.
-@item Simple conversion functions between the above types (and also
-hexadecimal representation for RGB).
-@item Some predefined colors (currently X11 color names – of course the
-library does not depend on X11).Because color in your terminal is nice.
-@end itemize
+(define-public ecl-charje.loop
+ (sbcl-package->ecl-package sbcl-charje.loop))
-This library is no longer supported by its author.")
- (home-page "https://github.com/tpapp/cl-colors")
- (license license:boost1.0))))
+(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-colors
- (sbcl-package->cl-source-package sbcl-cl-colors))
+(define-public cl-chemboy
+ (sbcl-package->cl-source-package sbcl-chemboy))
-(define-public ecl-cl-colors
- (sbcl-package->ecl-package sbcl-cl-colors))
+(define-public ecl-chemboy
+ (sbcl-package->ecl-package sbcl-chemboy))
-(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 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-format-colors
- (sbcl-package->cl-source-package sbcl-format-colors))
+(define-public cl-chemical-compounds
+ (sbcl-package->cl-source-package sbcl-chemical-compounds))
-(define-public ecl-format-colors
- (sbcl-package->ecl-package sbcl-format-colors))
+(define-public ecl-chemical-compounds
+ (sbcl-package->ecl-package sbcl-chemical-compounds))
-(define-public sbcl-cl-ansi-text
- (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c"))
+(define-public sbcl-chipz
+ (let ((version "0.8")
+ (commit "82a17d39c78d91f6ea63a03aca8f9aa6069a5e11")
+ (revision "2"))
(package
- (name "sbcl-cl-ansi-text")
- (version (git-version "2.0.1" "1" commit))
+ (name "sbcl-chipz")
+ (version (git-version version revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pnathan/cl-ansi-text")
+ (url "https://github.com/sharplispers/chipz")
(commit commit)))
+ (file-name (git-file-name "cl-chipz" version))
(sha256
- (base32
- "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14"))
- (file-name (git-file-name "cl-ansi-text" version))))
+ (base32 "1n4f22i9j8iapjd6yx1z348rggcybvg9h794kx9libjgz4bs371h"))))
(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")
+ (list sbcl-flexi-streams))
+ (home-page "http://method-combination.net/lisp/chipz/")
+ (synopsis
+ "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
+data")
(description
- "@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))))
+ "DEFLATE data, defined in RFC1951, forms the core of popular
+compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
+Chipz also provides for decompressing data in those formats as well. BZIP2 is
+the format used by the popular compression tool bzip2.")
+ ;; The author describes it as "MIT-like"
+ (license license:expat))))
-(define-public cl-ansi-text
- (sbcl-package->cl-source-package sbcl-cl-ansi-text))
+(define-public cl-chipz
+ (sbcl-package->cl-source-package sbcl-chipz))
-(define-public ecl-cl-ansi-text
- (sbcl-package->ecl-package sbcl-cl-ansi-text))
+(define-public ecl-chipz
+ (sbcl-package->ecl-package sbcl-chipz))
-(define-public sbcl-proc-parse
- (let ((commit "ac3636834d561bdc2686c956dbd82494537285fd"))
+(define-public sbcl-chirp
+ (let ((commit "01c79fa41939688216d1f86d0766a687becb0654")
+ (revision "1"))
(package
- (name "sbcl-proc-parse")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-chirp")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/proc-parse")
+ (url "https://github.com/Shinmera/chirp")
(commit commit)))
+ (file-name (git-file-name "chirp" version))
(sha256
- (base32
- "06rnl0h4cx6xv2wj3jczmmcxqn2703inmmvg1s4npbghmijsybfh"))
- (file-name (git-file-name "proc-parse" version))))
+ (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)))
- (native-inputs
- (list sbcl-prove))
- (arguments
- '(#:asd-systems '("proc-parse-test"
- "proc-parse")))
- (synopsis "Procedural vector parser")
+ ("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 is a string/octets parser library for Common Lisp with speed and
-readability in mind. Unlike other libraries, the code is not a
-pattern-matching-like, but a char-by-char procedural parser.")
- (home-page "https://github.com/fukamachi/proc-parse")
- (license license:bsd-2))))
+ "This package provides a Common Lisp Twitter client featuring full API
+coverage.")
+ (license license:zlib))))
-(define-public cl-proc-parse
- (sbcl-package->cl-source-package sbcl-proc-parse))
+(define-public cl-chirp
+ (sbcl-package->cl-source-package sbcl-chirp))
-(define-public ecl-proc-parse
- (sbcl-package->ecl-package sbcl-proc-parse))
+(define-public ecl-chirp
+ (sbcl-package->ecl-package sbcl-chirp))
-(define-public sbcl-parse-float
- (let ((commit "3074765101e41222b6b624a66aaf1e6416379f9c")
- (revision "2"))
+(define-public sbcl-chlorophyll
+ (let ((commit "f2a50ad36d2fb11823c0e5a8da08a0de89c5c35f")
+ (revision "1"))
(package
- (name "sbcl-parse-float")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-chlorophyll")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/soemraws/parse-float")
+ (url "https://github.com/gorozhin/chlorophyll")
(commit commit)))
+ (file-name (git-file-name "cl-chlorophyll" version))
(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))))
+ (base32 "1hgl8sjsmyqx4gs77q4p94b63zgpxk1wi9w9niki8j0213dr1s3y"))))
(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")
+ (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
- "@command{cl-strings} is a small, portable, dependency-free set of
-utilities that make it even easier to manipulate text in Common Lisp. It has
-100% test coverage and works at least on sbcl, ecl, ccl, abcl and clisp.")
- (home-page "https://github.com/vityok/cl-string-match")
- (license license:bsd-3))))
+ "This package provides a Common Lisp system CHLOROPHYLL which
+implements an ANSI escape code functionality.")
+ (license license:expat))))
-(define-public cl-string-match
- (sbcl-package->cl-source-package sbcl-cl-string-match))
+(define-public cl-chlorophyll
+ (sbcl-package->cl-source-package sbcl-chlorophyll))
-(define-public ecl-cl-string-match
- (sbcl-package->ecl-package sbcl-cl-string-match))
+(define-public ecl-chlorophyll
+ (sbcl-package->ecl-package sbcl-chlorophyll))
-(define-public sbcl-cl-punch
+(define-public sbcl-chronicity
(package
- (name "sbcl-cl-punch")
- (version "0.2")
+ (name "sbcl-chronicity")
+ (version "0.4.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/windymelt/cl-punch")
+ (url "https://github.com/chaitanyagupta/chronicity")
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-punch" version))
+ (file-name (git-file-name "chronicity" version))
(sha256
- (base32 "1vmbaz9y9lq4wvi8mfbyif8vc9yfk2i0qd3ysbzl152wx32dbzs3"))))
+ (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-prove))
+ (list sbcl-lisp-unit))
(inputs
- (list sbcl-cl-syntax))
- (home-page "https://github.com/windymelt/cl-punch")
- (synopsis "Anonymous lambda literal in Common Lisp, respecting Scala")
+ (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
- "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-puri
- (let ((commit "4bbab89d9ccbb26346899d1f496c97604fec567b")
- (revision "2"))
- (package
- (name "sbcl-puri")
- (version (git-version "1.5.7" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "http://git.kpe.io/puri.git")
- (commit commit)))
- (file-name (git-file-name "puri" 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))))
- (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))))
-
-(define-public cl-puri
- (sbcl-package->cl-source-package sbcl-puri))
+ "CHRONICITY is Common Lisp natural language date and time parser inspired
+by Ruby's @code{Chronic}.")
+ (license license:bsd-3)))
-(define-public ecl-puri
- (sbcl-package->ecl-package sbcl-puri))
+(define-public ecl-chronicity
+ (sbcl-package->ecl-package sbcl-chronicity))
-(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.
+(define-public cl-chronicity
+ (sbcl-package->cl-source-package sbcl-chronicity))
-It's a part of QITAB umbrella project.")
- (license license:expat))))
+(define-public sbcl-chunga
+ (package
+ (name "sbcl-chunga")
+ (version "1.1.7")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/edicl/chunga")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-trivial-gray-streams))
+ (home-page "https://edicl.github.io/chunga/")
+ (synopsis "Portable chunked streams for Common Lisp")
+ (description
+ "Chunga implements streams capable of chunked encoding on demand as
+defined in RFC 2616.")
+ (license license:bsd-2)))
-(define-public ecl-qmynd
- (sbcl-package->ecl-package sbcl-qmynd))
+(define-public cl-chunga
+ (sbcl-package->cl-source-package sbcl-chunga))
-(define-public cl-qmynd
- (sbcl-package->cl-source-package sbcl-qmynd))
+(define-public ecl-chunga
+ (sbcl-package->ecl-package sbcl-chunga))
-(define-public sbcl-queues
- (let ((commit "47d4da65e9ea20953b74aeeab7e89a831b66bc94"))
+(define-public sbcl-ciel
+ (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a")
+ (revision "0"))
(package
- (name "sbcl-queues")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-ciel")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/oconnore/queues")
+ (url "https://github.com/ciel-lang/CIEL")
(commit commit)))
- (file-name (git-file-name "queues" version))
+ (file-name (git-file-name "ciel" version))
(sha256
- (base32
- "0wdhfnzi4v6d97pggzj2aw55si94w4327br94jrmyvwf351wqjvv"))))
+ (base32 "1bwafbbsppxqvijf43dii55mpzrklh6faj2m5dhajg2f2m8qckgi"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-fiveam))
(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")
+ (list sbcl-access
+ sbcl-alexandria
+ sbcl-arrow-macros
+ sbcl-bordeaux-threads
+ sbcl-cl-ansi-text
+ sbcl-cl-ansi-text
+ sbcl-cl-cron
+ sbcl-cl-csv
+ sbcl-cl-json-pointer
+ sbcl-cl-ppcre
+ sbcl-cl-punch
+ sbcl-cl-reexport
+ sbcl-cl-str
+ sbcl-clesh
+ sbcl-clingon
+ sbcl-closer-mop
+ sbcl-cmd
+ sbcl-dbi
+ sbcl-defstar
+ sbcl-deploy
+ sbcl-dexador
+ sbcl-dissect
+ sbcl-easy-routes
+ sbcl-file-notify
+ sbcl-fn
+ sbcl-for
+ sbcl-fset
+ sbcl-generic-cl
+ sbcl-hunchentoot
+ sbcl-local-time
+ sbcl-log4cl
+ sbcl-lparallel
+ sbcl-lquery
+ sbcl-metabang-bind
+ sbcl-modf
+ sbcl-named-readtables
+ sbcl-nodgui
+ sbcl-parse-float
+ sbcl-parse-number
+ sbcl-printv
+ sbcl-pythonic-string-reader
+ sbcl-quicksearch
+ sbcl-quri
+ sbcl-repl-utilities
+ sbcl-serapeum
+ sbcl-shasht
+ sbcl-shlex
+ sbcl-spinneret
+ sbcl-sxql
+ sbcl-trivia
+ sbcl-trivial-arguments
+ sbcl-trivial-do
+ sbcl-trivial-monitored-thread
+ sbcl-trivial-package-local-nicknames
+ sbcl-trivial-types
+ sbcl-vgplot
+ sbcl-which))
+ (home-page "http://ciel-lang.org/")
+ (synopsis "CIEL Is an Extended Lisp")
(description
- "This is a simple queue library for Common Lisp with features such as
-non-consing thread safe queues and fibonacci priority queues.")
+ "CIEL is a ready-to-use collection of libraries providing: a binary, to
+run CIEL scripts; a simple full-featured REPL for the terminal; a Lisp library
+and a core image .")
(license license:expat))))
-(define-public cl-queues
- (sbcl-package->cl-source-package sbcl-queues))
+(define-public cl-ciel
+ (sbcl-package->cl-source-package sbcl-ciel))
-(define-public ecl-queues
- (sbcl-package->ecl-package sbcl-queues))
+(define-public ecl-ciel
+ (sbcl-package->ecl-package sbcl-ciel))
-(define-public sbcl-glsl-packing
- (let ((commit "03628159468a8e5b7f2a1d5e78b77053e136794a")
+(define-public sbcl-circular-streams
+ (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
(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))))
+ (name "sbcl-circular-streams")
+ (version (git-version "0.1.0" revision commit))
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/fukamachi/circular-streams")
+ (commit commit)))
+ (file-name (git-file-name name version))
+ (sha256
+ (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ ;; The tests depend on cl-test-more which is now prove. Prove
+ ;; tests aren't working for some reason.
+ `(#:tests? #f))
+ (inputs
+ (list sbcl-fast-io sbcl-trivial-gray-streams))
+ (home-page "https://github.com/fukamachi/circular-streams")
+ (synopsis "Circularly readable streams for Common Lisp")
+ (description
+ "Circular-Streams allows you to read streams circularly by wrapping real
+streams. Once you reach end-of-file of a stream, it's file position will be
+reset to 0 and you're able to read it again.")
+ (license license:llgpl))))
-(define-public ecl-glsl-packing
- (sbcl-package->ecl-package sbcl-glsl-packing))
+(define-public cl-circular-streams
+ (sbcl-package->cl-source-package sbcl-circular-streams))
-(define-public cl-glsl-packing
- (sbcl-package->cl-source-package sbcl-glsl-packing))
+(define-public ecl-circular-streams
+ (sbcl-package->ecl-package sbcl-circular-streams))
-(define-public sbcl-glsl-spec
- (let ((commit "f04476f7da89355ae6856b33283c60ba95c6555d")
+(define-public sbcl-cl-abnf
+ ;; There are no releases
+ (let ((commit "ba1fbb104dedbdaddb1ef93d2e4da711bd96cd70")
(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))))
+ (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 ecl-glsl-spec
- (sbcl-package->ecl-package sbcl-glsl-spec))
+(define-public cl-abnf
+ (sbcl-package->cl-source-package sbcl-cl-abnf))
-(define-public cl-glsl-spec
- (sbcl-package->cl-source-package sbcl-glsl-spec))
+(define-public ecl-cl-abnf
+ (sbcl-package->ecl-package sbcl-cl-abnf))
-(define-public sbcl-rtg-math
- (let ((commit "29fc5b3d0028a4a11a82355ecc8cca62662c69e0")
- (revision "1"))
+(define-public sbcl-cl-algebraic-data-type
+ (let ((commit "b2568428193a512d141d6b615772d50ceb5f9bca"))
(package
- (name "sbcl-rtg-math")
- (version (git-version "0.0.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/cbaggers/rtg-math")
+ (url "https://github.com/stylewarning/cl-algebraic-data-type")
(commit commit)))
- (file-name (git-file-name "rtg-math" version))
+ (file-name (git-file-name "cl-algebraic-data-type" version))
(sha256
- (base32 "0bhxxnv7ldkkb18zdxyz2rj2a3iawzq2kcp7cn5i91iby7n0082x"))))
+ (base32 "1lnqxcv8pd5z8n0g5p2l0dbljx9pqiv18hxl0vhsh7ldhkrjv2jx"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-documentation-utils sbcl-glsl-spec))
- (home-page "https://github.com/cbaggers/rtg-math")
- (synopsis "Common Lisp library of game-related math functions")
+ (list sbcl-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
- "RTG-MATH provides a selection of the math routines most commonly needed
-for making realtime graphics in Lisp.")
- (license license:bsd-2))))
+ "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-rtg-math
- (sbcl-package->ecl-package sbcl-rtg-math))
+(define-public cl-algebraic-data-type
+ (sbcl-package->cl-source-package sbcl-cl-algebraic-data-type))
-(define-public cl-rtg-math
- (sbcl-package->cl-source-package sbcl-rtg-math))
+(define-public ecl-algebraic-data-type
+ (sbcl-package->ecl-package sbcl-cl-algebraic-data-type))
-(define-public sbcl-varjo
- (let ((commit "9e77f30220053155d2ef8870ceba157f75e538d4")
- (revision "1"))
+(define-public sbcl-cl-all
+ (let ((commit "4ce1ea9d9f33c0dd6212044e7952a0c854757ace")
+ (revision "0"))
(package
- (name "sbcl-varjo")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-all")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cbaggers/varjo")
+ (url "https://github.com/Shinmera/cl-all")
(commit commit)))
- (file-name (git-file-name "varjo" version))
+ (file-name (git-file-name "cl-all" version))
(sha256
- (base32 "1p9x1wj576x5d31yvls9r1avkjkyhri7kyxbjfkg9z93a1w18j9z"))))
+ (base32 "0n4sjarj373zpxn78m32rmhxnsnr8qahdslrd9vrkkwjpzar2bwp"))))
(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))
+ (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-varjo
- (sbcl-package->cl-source-package sbcl-varjo))
+(define-public cl-all
+ (sbcl-package->cl-source-package sbcl-cl-all))
-(define-public sbcl-cffi
- (let ((commit "33970351e71bb5f12ba56fc40270089e948ae112")
- (revision "1"))
+(define-public sbcl-cl-ana
+ (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e")
+ (revision "2"))
(package
- (name "sbcl-cffi")
- (version (git-version "0.24.1" revision commit))
+ (name "sbcl-cl-ana")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cffi/cffi")
+ (url "https://github.com/ghollisjr/cl-ana")
(commit commit)))
- (file-name (git-file-name "cl-cffi" version))
+ (file-name (git-file-name "cl-ana" version))
(sha256
- (base32 "1h7cw15f08gm6m4yz8hk7qkfwp7mwwnykjc5py6dhjakv0wh1g37"))))
+ (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list openmpi ;; for hdf-cffi
+ pkg-config
+ sbcl-cl-fad))
(inputs
- (list libffi
+ (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-babel
- sbcl-trivial-features))
- (native-inputs
- (list pkg-config
- sbcl-bordeaux-threads
- sbcl-rt))
+ 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* "libffi/libffi.lisp"
- (("libffi.so.8" all)
- (search-input-file inputs (string-append "/lib/" all))))
- (substitute* "toolchain/c-toolchain.lisp"
- (("\"cc\"")
- (format #f "~S" (which "gcc"))))))
- (add-after 'build 'install-headers
+ (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 _
- (install-file "grovel/common.h"
- (string-append #$output
- "/include/grovel")))))
- #:asd-systems ''("cffi"
- "cffi-libffi"
- "cffi-uffi-compat")))
- (home-page "https://common-lisp.net/project/cffi/")
- (synopsis "Common Foreign Function Interface for Common Lisp")
- (description "The Common Foreign Function Interface (CFFI)
-purports to be a portable foreign function interface for Common Lisp.
-The CFFI library is composed of a Lisp-implementation-specific backend
-in the CFFI-SYS package, and a portable frontend in the CFFI
-package.")
- (license license:expat))))
-
-(define-public cl-cffi
- (sbcl-package->cl-source-package sbcl-cffi))
+ (substitute* (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 ecl-cffi
- (sbcl-package->ecl-package sbcl-cffi))
+(define-public cl-ana
+ (sbcl-package->cl-source-package sbcl-cl-ana))
-(define-public sbcl-cffi-c-ref
- (let ((commit "8123cbb6034c5f7921a0766107cfb8c4e8efd5ce")
- (revision "0"))
+(define-public sbcl-cl-annot
+ (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
+ (revision "1"))
(package
- (name "sbcl-cffi-c-ref")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cl-annot")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/borodust/cffi-c-ref")
+ (url "https://github.com/m2ym/cl-annot")
(commit commit)))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1a3pp6xcisabqir3rp1gvvjfdxcvpm8yr35p38nri9azsinmmc7z"))
- (file-name (git-file-name "cffi-c-ref" version))))
+ (base32 "1wq1gs9jjd5m6iwrv06c2d7i5dvqsfjcljgbspfbc93cg5xahk4n"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-cffi))
- (synopsis "Streamlined access to foreign memory")
+ (list sbcl-alexandria))
+ (home-page "https://github.com/m2ym/cl-annot")
+ (synopsis "Python-like Annotation Syntax for Common Lisp")
(description
- "This Common Lisp library provides macros to access foreign memory.")
- (home-page "https://github.com/borodust/cffi-c-ref")
- (license license:expat))))
+ "@code{cl-annot} is an general annotation library for Common Lisp.")
+ (license license:llgpl))))
-(define-public cl-cffi-c-ref
- (sbcl-package->cl-source-package sbcl-cffi-c-ref))
+(define-public cl-annot
+ (sbcl-package->cl-source-package sbcl-cl-annot))
-(define-public ecl-cffi-c-ref
- (sbcl-package->ecl-package sbcl-cffi-c-ref))
+(define-public ecl-cl-annot
+ (sbcl-package->ecl-package sbcl-cl-annot))
-(define-public sbcl-ffa
- (let ((commit "b7012f51c4c37d1e759ff9cf78cea178504d8e07")
- (revision "1"))
+(define-public sbcl-cl-ansi-text
+ (let ((commit "8b129d83c7511b54cdd9d4123825a2d06349b25c"))
(package
- (name "sbcl-ffa")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-ansi-text")
+ (version (git-version "2.0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/tpapp/ffa")
+ (url "https://github.com/pnathan/cl-ansi-text")
(commit commit)))
- (file-name (git-file-name "cl-ffa" version))
(sha256
- (base32 "0l7kqcjp3sn1129hpwq6zhjqc0ydx9gc53z7k13i38x3z1asap7a"))))
+ (base32
+ "0nk7ajqfa937w1iy3zy86jjbw8yffm05cqs4wxkgl97v6kmmya14"))
+ (file-name (git-file-name "cl-ansi-text" version))))
(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")
+ (list sbcl-alexandria sbcl-cl-colors2))
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis "ANSI terminal color implementation 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")
+ "@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-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 cl-ansi-text
+ (sbcl-package->cl-source-package sbcl-cl-ansi-text))
-(define-public ecl-cl-sqlite
- (sbcl-package->ecl-package sbcl-cl-sqlite))
+(define-public ecl-cl-ansi-text
+ (sbcl-package->ecl-package sbcl-cl-ansi-text))
-(define-public sbcl-cl-raylib
- (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d")
- (revision "0"))
+(define-public sbcl-cl-ascii-table
+ (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
+ (revision "1"))
(package
- (name "sbcl-cl-raylib")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-ascii-table")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/longlene/cl-raylib")
+ (url "https://github.com/telephil/cl-ascii-table")
(commit commit)))
- (file-name (git-file-name "cl-raylib" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1kighj35g6dn426mhr2ppz3gm49v1q4n42ydn619pclrqwyrnc2z"))))
+ (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
(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.")
+ (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-raylib
- (sbcl-package->cl-source-package sbcl-cl-raylib))
+(define-public cl-ascii-table
+ (sbcl-package->cl-source-package sbcl-cl-ascii-table))
-(define-public ecl-cl-raylib
- (sbcl-package->ecl-package sbcl-cl-raylib))
+(define-public ecl-cl-ascii-table
+ (sbcl-package->ecl-package sbcl-cl-ascii-table))
-(define-public sbcl-cl-redis
- (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d")
- (revision "0"))
+(define-public sbcl-cl-async
+ (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
+ (revision "1"))
(package
- (name "sbcl-cl-redis")
- (version (git-version "2.3.8" revision commit))
+ (name "sbcl-cl-async")
+ (version (git-version "0.6.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/vseloved/cl-redis")
+ (url "https://github.com/orthecreedence/cl-async")
(commit commit)))
- (file-name (git-file-name "cl-redis" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0x5ahxb5cx37biyn3cjycshhm1rr9p5cf1a9l5hd1n1xjxm2f8vi"))))
+ (base32
+ "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
(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)
+ ("bordeaux-threads" ,sbcl-bordeaux-threads)
+ ("cffi" ,sbcl-cffi)
+ ("cl-libuv" ,sbcl-cl-libuv)
("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.")
+ ("fast-io" ,sbcl-fast-io)
+ ("openssl" ,openssl)
+ ("static-vectors" ,sbcl-static-vectors)
+ ("trivial-features" ,sbcl-trivial-features)
+ ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
+ ("vom" ,sbcl-vom)))
+ (arguments
+ `(#:asd-systems '("cl-async"
+ "cl-async-repl"
+ "cl-async-ssl")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/ssl/package.lisp"
+ (("libcrypto\\.so")
+ (search-input-file inputs "/lib/libcrypto.so"))
+ (("libssl\\.so")
+ (search-input-file inputs "/lib/libssl.so"))))))))
+ (synopsis "Asynchronous operations for Common Lisp")
+ (description
+ "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-redis
- (sbcl-package->cl-source-package sbcl-cl-redis))
+(define-public cl-async
+ (sbcl-package->cl-source-package sbcl-cl-async))
-(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 ecl-cl-async
+ (sbcl-package->ecl-package sbcl-cl-async))
-(define-public sbcl-parenscript
- ;; Source archives are overwritten on every release, we use the Git repo instead.
- (let ((commit "7a1ac46353cecd144fc91915ba9f122aafcf4766"))
+(define-public sbcl-cl-async-future
+ (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
+ (revision "1"))
(package
- (name "sbcl-parenscript")
- (version (git-version "2.7.1" "1" commit))
+ (name "sbcl-cl-async-future")
+ (version (git-version "0.4.4.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/parenscript/parenscript")
+ (url "https://github.com/orthecreedence/cl-async-future")
(commit commit)))
- (file-name (git-file-name "parenscript" version))
+ (file-name (git-file-name name version))
(sha256
(base32
- "0c22lqarrpbq82dg1sb3y6mp6w2faczp34ymzhnmff88yfq1xzsf"))))
+ "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
(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")
+ (list sbcl-blackbird))
+ (native-inputs
+ (list sbcl-cl-async sbcl-eos))
+ (synopsis "Futures implementation for Common Lisp")
(description
- "Parenscript is a translator from an extended subset of Common Lisp to
-JavaScript. Parenscript code can run almost identically on both the
-browser (as JavaScript) and server (as Common Lisp).
-
-Parenscript code is treated the same way as Common Lisp code, making the full
-power of Lisp macros available for JavaScript. This provides a web
-development environment that is unmatched in its ability to reduce code
-duplication and provide advanced meta-programming facilities to web
-developers.
-
-At the same time, Parenscript is different from almost all other \"language
-X\" to JavaScript translators in that it imposes almost no overhead:
-
-@itemize
-@item No run-time dependencies: Any piece of Parenscript code is runnable
-as-is. There are no JavaScript files to include.
-@item Native types: Parenscript works entirely with native JavaScript data
-types. There are no new types introduced, and object prototypes are not
-touched.
-@item Native calling convention: Any JavaScript code can be called without the
-need for bindings. Likewise, Parenscript can be used to make efficient,
-self-contained JavaScript libraries.
-@item Readable code: Parenscript generates concise, formatted, idiomatic
-JavaScript code. Identifier names are preserved. This enables seamless
-debugging in tools like Firebug.
-@item Efficiency: Parenscript introduces minimal overhead for advanced Common
-Lisp features. The generated code is almost as fast as hand-written
-JavaScript.
-@end itemize\n")
- (license license:bsd-3))))
-
-(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)))
+ "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-json
- (sbcl-package->cl-source-package sbcl-cl-json))
+(define-public cl-async-future
+ (sbcl-package->cl-source-package sbcl-cl-async-future))
-(define-public ecl-cl-json
- (sbcl-package->ecl-package sbcl-cl-json))
+(define-public ecl-cl-async-future
+ (sbcl-package->ecl-package sbcl-cl-async-future))
-(define-public sbcl-cl-json-pointer
- (let ((commit "f6760e2a02972783f96b92a15f801e14a6828e0c")
- (revision "0"))
+(define-public sbcl-cl-autowrap
+ (let ((revision "2")
+ (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4"))
+ ;; no taged branches
(package
- (name "sbcl-cl-json-pointer")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-autowrap")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/y2q-actionman/cl-json-pointer")
+ (url "https://github.com/rpav/cl-autowrap")
(commit commit)))
- (file-name (git-file-name "cl-json-pointer" version))
+ (file-name (git-file-name "cl-autowrap" version))
(sha256
- (base32 "0b7a755wc2ghsd1pv7d32877b21h4nssp41xs017anbmj55czb2h"))))
+ (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw"))))
(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")))
+ `(#:asd-systems '("cl-plus-c" "cl-autowrap")))
(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))))
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-json" ,sbcl-cl-json)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("defpackage-plus" ,sbcl-defpackage-plus)
+ ("trivial-features" ,sbcl-trivial-features)))
+ (home-page "https://github.com/rpav/cl-autowrap")
+ (synopsis "FFI wrapper generator for Common Lisp")
+ (description "This is a c2ffi-based wrapper generator for Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-json-pointer
- (sbcl-package->cl-source-package sbcl-cl-json-pointer))
+(define-public cl-autowrap
+ (sbcl-package->cl-source-package sbcl-cl-autowrap))
-(define-public ecl-cl-json-pointer
- (sbcl-package->ecl-package sbcl-cl-json-pointer))
+(define-public ecl-cl-autowrap
+ (sbcl-package->ecl-package sbcl-cl-autowrap))
-(define-public sbcl-unix-opts
- (let ((commit "0e61f34b2ecf62288437810d4abb31e572048b04")
+(define-public sbcl-cl-base32
+ (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
(revision "1"))
(package
- (name "sbcl-unix-opts")
- (version (git-version "0.1.7" revision commit))
+ (name "sbcl-cl-base32")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/libre-man/unix-opts")
+ (url "https://github.com/hargettp/cl-base32")
(commit commit)))
- (file-name (git-file-name "unix-opts" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "16mcqpzwrz808p9n3wwl99ckg3hg7yihw08y1i4l7c92aldbkasq"))))
+ (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/hankhero/cl-json")
- (synopsis "Unix-style command line options parser")
+ (native-inputs
+ (list sbcl-lisp-unit))
+ (synopsis "Common Lisp library for base32 encoding and decoding")
(description
- "This is a minimalistic parser of command line options. The main
-advantage of the library is the ability to concisely define command line
-options once and then use this definition for parsing and extraction of
-command line arguments, as well as printing description of command line
-options (you get --help for free). This way you don't need to repeat
-yourself. Also, @command{unix-opts} doesn't depend on anything and
-precisely controls the behavior of the parser via Common Lisp restarts.")
+ "This 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-unix-opts
- (sbcl-package->cl-source-package sbcl-unix-opts))
+(define-public cl-base32
+ (sbcl-package->cl-source-package sbcl-cl-base32))
-(define-public ecl-unix-opts
- (sbcl-package->ecl-package sbcl-unix-opts))
+(define-public ecl-cl-base32
+ (sbcl-package->ecl-package sbcl-cl-base32))
-(define-public sbcl-trivial-garbage
- (let ((commit "3474f6414b73d4e3aa2d5c53080f4247a34f6380")
- (revision "0"))
+(define-public sbcl-cl-base58
+ (let ((commit "f446835b4104896e0eed6a61d2ceb4ad22f589d8")
+ (revision "1"))
(package
- (name "sbcl-trivial-garbage")
- (version (git-version "0.21" revision commit))
+ (name "sbcl-cl-base58")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/trivial-garbage/trivial-garbage")
+ (url "https://github.com/eudoxia0/cl-base58/")
(commit commit)))
- (file-name (git-file-name "cl-trivial-garbage" version))
+ (file-name (git-file-name "cl-base58" version))
(sha256
- (base32 "0rfwxvwg0kpcaa0hsi035yrkfdfks4bq8d9azmrww2f0rmv9g6sd"))))
+ (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-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.")
+ (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-ucons
- (sbcl-package->cl-source-package sbcl-ucons))
+(define-public cl-base58
+ (sbcl-package->cl-source-package sbcl-cl-base58))
-(define-public ecl-ucons
- (sbcl-package->ecl-package sbcl-ucons))
+(define-public ecl-cl-base58
+ (sbcl-package->ecl-package sbcl-cl-base58))
-(define-public sbcl-clobber
- (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98")
- (revision "0"))
+(define-public sbcl-cl-base64
+ (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
(package
- (name "sbcl-clobber")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-base64")
+ (version (git-version "3.3.4" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Clobber")
+ (url "http://git.kpe.io/cl-base64.git/")
(commit commit)))
- (file-name (git-file-name "cl-clobber" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n"))))
+ (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)
- (home-page "https://github.com/robert-strandh/Clobber")
- (synopsis "Common Lisp Library for transaction-oriented databases")
+ (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
- "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))))
+ "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-clobber
- (sbcl-package->cl-source-package sbcl-clobber))
+(define-public cl-base64
+ (sbcl-package->cl-source-package sbcl-cl-base64))
-(define-public ecl-clobber
- (sbcl-package->ecl-package sbcl-clobber))
+(define-public ecl-cl-base64
+ (sbcl-package->ecl-package sbcl-cl-base64))
-(define-public sbcl-closer-mop
- (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc")
- (revision "3"))
+(define-public sbcl-cl-cairo2
+ (let ((commit "41ae45aac86553c46f4bb460f80e1fb620930f5b")
+ (revision "1"))
(package
- (name "sbcl-closer-mop")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-cairo2")
+ (version (git-version "0.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pcostanza/closer-mop")
+ (url "https://github.com/rpav/cl-cairo2")
(commit commit)))
+ (file-name (git-file-name "cl-cairo2" version))
(sha256
- (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16"))
- (file-name (git-file-name "cl-closer-mop" version ))))
+ (base32 "0cpfgyxw6pz7y033dlya8c4vjmkpw127zdq3a9xclp9q8jbdlb7q"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pcostanza/closer-mop")
- (synopsis "Rectifies absent or incorrect CLOS MOP features")
- (description "Closer to MOP is a compatibility layer that rectifies many
-of the absent or incorrect CLOS MOP features across a broad range of Common
-Lisp implementations.")
- (license license:expat))))
+ (arguments
+ `(#: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-closer-mop
- (sbcl-package->cl-source-package sbcl-closer-mop))
+(define-public cl-cairo2
+ (sbcl-package->cl-source-package sbcl-cl-cairo2))
-(define-public ecl-closer-mop
- (sbcl-package->ecl-package sbcl-closer-mop))
+(define-public ecl-cl-cairo2
+ (sbcl-package->ecl-package sbcl-cl-cairo2))
(define-public sbcl-cl-cffi-gtk
(let ((commit "1700fe672c65455c1fc33061ec92a3df84287ec7")
@@ -5374,2232 +4203,915 @@ is a library for creating graphical user interfaces.")
(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")
+(define-public sbcl-cl-change-case
+ (let ((commit "45c70b601125889689e0c1c37d7e727a3a0af022")
(revision "1"))
(package
- (name "sbcl-lparallel")
- (version (git-version "2.8.4" revision commit))
+ (name "sbcl-cl-change-case")
+ (version (git-version "0.2.0" revision commit))
+ (home-page "https://github.com/rudolfochrist/cl-change-case")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/lparallel/")
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-lparallel" version))
+ (file-name (git-file-name "cl-change-case" version))
(sha256
- (base32 "0nv2dx8cl25g68icqhw95yr5mygm86lcjzmzijql51na1p60g6y9"))))
+ (base32 "0qmk341zzcsbf8sq0w9ix3r080zg4ri6vzxym63lhdjfzwz3y8if"))))
(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")
+ (list sbcl-cl-ppcre sbcl-cl-ppcre-unicode))
+ (native-inputs
+ (list sbcl-fiveam))
+ (synopsis
+ "Convert Common Lisp strings between camelCase, PascalCase and more")
(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+))))
+ "@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-markup
- (sbcl-package->cl-source-package sbcl-cl-markup))
+(define-public cl-change-case
+ (sbcl-package->cl-source-package sbcl-cl-change-case))
-(define-public ecl-cl-markup
- (sbcl-package->ecl-package sbcl-cl-markup))
+(define-public ecl-cl-change-case
+ (sbcl-package->ecl-package sbcl-cl-change-case))
-;;; 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")
+(define-public sbcl-cl-charms
+ (let ((commit "64aba59d89f85bc5c9402e445873965338a66a02")
(revision "1"))
(package
- (name "sbcl-markup-reader")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-charms")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/moderninterpreters/markup")
+ (url "https://github.com/HiTECNOLOGYs/cl-charms")
(commit commit)))
- (file-name (git-file-name "markup-reader" version))
+ (file-name (git-file-name "cl-charms" version))
(sha256
- (base32 "0i3v938j8zpzkd6p9j8gadp5zndjcdxhswj1qgsp592v6497rpzj"))))
+ (base32 "1jczaypa9dhxr34yyhsxb6lrdnircjx8am4iqkc3shfpjn32q323"))))
(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")
+ ("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
- "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)))
+ "@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-xml-emitter
- (sbcl-package->cl-source-package sbcl-xml-emitter))
+(define-public cl-charms
+ (sbcl-package->cl-source-package sbcl-cl-charms))
-(define-public ecl-xml-emitter
- (sbcl-package->ecl-package sbcl-xml-emitter))
+(define-public ecl-cl-charms
+ (sbcl-package->ecl-package sbcl-cl-charms))
-(define-public sbcl-kdlcl
- (let ((commit "dd4a48a3473c3c8fb34d4a37f87d6a1776c5875c")
+(define-public sbcl-cl-collider
+ (let ((commit "a46908896982868955b29bfb3a5337a0af489b0b")
(revision "0"))
(package
- (name "sbcl-kdlcl")
- (version (git-version "1.0" revision commit))
- (source
+ (name "sbcl-cl-collider")
+ (version (git-version "2018.7.15" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/chee/kdlcl")
+ (url "https://github.com/byulparan/cl-collider")
(commit commit)))
- (file-name (git-file-name "cl-kdlcl" version))
+ (file-name (git-file-name "cl-collider" 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)))
+ (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-mustache
- (sbcl-package->cl-source-package sbcl-cl-mustache))
+(define-public cl-collider
+ (sbcl-package->cl-source-package sbcl-cl-collider))
-(define-public ecl-cl-mustache
- (sbcl-package->ecl-package sbcl-cl-mustache))
+(define-public ecl-cl-collider
+ (sbcl-package->ecl-package sbcl-cl-collider))
-(define-public sbcl-cl-css
- (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
+(define-public sbcl-cl-colors
+ (let ((commit "827410584553f5c717eec6182343b7605f707f75"))
(package
- (name "sbcl-cl-css")
- (version (git-version "0.1" "1" commit))
+ (name "sbcl-cl-colors")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/inaimathi/cl-css/")
+ (url "https://github.com/tpapp/cl-colors")
(commit commit)))
- (file-name (git-file-name "cl-css" version))
(sha256
(base32
- "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
+ "0l446lday4hybsm9bq3jli97fvv8jb1d33abg79vbylpwjmf3y9a"))
+ (file-name (git-file-name "cl-colors" version))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/inaimathi/cl-css/")
- (synopsis "Non-validating, inline CSS generator for Common Lisp")
+ (inputs
+ (list sbcl-alexandria sbcl-let-plus))
+ (synopsis "Simple color library 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))
+ "This is a very simple color library for Common Lisp, providing
-(define-public ecl-cl-css
- (sbcl-package->ecl-package sbcl-cl-css))
+@itemize
+@item Types for representing colors in HSV and RGB spaces.
+@item Simple conversion functions between the above types (and also
+hexadecimal representation for RGB).
+@item Some predefined colors (currently X11 color names – of course the
+library does not depend on X11).Because color in your terminal is nice.
+@end itemize
-(define-public sbcl-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))))
+This library is no longer supported by its author.")
+ (home-page "https://github.com/tpapp/cl-colors")
+ (license license:boost1.0))))
-(define-public cl-portable-threads
- (sbcl-package->cl-source-package sbcl-portable-threads))
+(define-public cl-colors
+ (sbcl-package->cl-source-package sbcl-cl-colors))
-(define-public ecl-portable-threads
- (sbcl-package->ecl-package sbcl-portable-threads))
+(define-public ecl-cl-colors
+ (sbcl-package->ecl-package sbcl-cl-colors))
-(define-public sbcl-usocket
+(define-public sbcl-cl-colors2
(package
- (name "sbcl-usocket")
- (version "0.8.6")
+ (name "sbcl-cl-colors2")
+ (version "0.6.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/usocket/usocket/")
+ (url "https://codeberg.org/cage/cl-colors2")
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-usocket" version))
+ (file-name (git-file-name "cl-colors2" version))
(sha256
- (base32 "0by8hhg6gijdbq5vjykd374rmvqyikp4synpyk0wjcl7rk3r0vgn"))))
+ (base32 "0vnvlq9xixs04768q7hapsi16cjp3ych6mypvs6chihd5dal4cnd"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-rt))
+ (list sbcl-clunit2))
(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")
+ (list sbcl-alexandria sbcl-cl-ppcre sbcl-parse-number))
+ (synopsis "Color library for 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:
+ "This is a very simple color library for Common Lisp, providing:
@itemize
-@item It does not support any special tags (like processing instructions).
-@item It is not validating, even skips DTD's all together.
+@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")
- (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))))
+ (home-page "https://codeberg.org/cage/cl-colors2")
+ (license license:boost1.0)))
-(define-public cl-trivial-clipboard
- (sbcl-package->cl-source-package sbcl-trivial-clipboard))
+(define-public cl-colors2
+ (sbcl-package->cl-source-package sbcl-cl-colors2))
-(define-public ecl-trivial-clipboard
- (sbcl-package->ecl-package sbcl-trivial-clipboard))
+(define-public ecl-cl-colors2
+ (sbcl-package->ecl-package sbcl-cl-colors2))
-(define-public sbcl-trivial-backtrace
- (let ((commit "7f90b4a4144775cca0728791e4b92ac2557b07a1")
+(define-public sbcl-cl-conspack
+ (let ((commit "6e529d7b3a7223ef1bb5c7b9f18384ba67b50b09")
(revision "2"))
(package
- (name "sbcl-trivial-backtrace")
- (version (git-version "1.1.0" revision commit))
+ (name "sbcl-cl-conspack")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/trivial-backtrace")
+ (url "https://github.com/conspack/cl-conspack")
(commit commit)))
- (file-name (git-file-name "trivial-backtrace" version))
+ (file-name (git-file-name "cl-conspack" version))
(sha256
- (base32 "11j0p3vgmnn5q84xw7sacr5p3cvff2hfhsh2is8xpm2iwxc723kn"))))
+ (base32 "0y5wp5c89ph44k2xjppy1c1jf2ac3q9yrk22da2rkwnbxn0h1a8d"))))
(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")
+ '(#: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
- "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))))
+ "This package provides a CONSPACK implementation for Common Lisp.")
+ (license license:bsd-3))))
-(define-public cl-trivial-backtrace
- (sbcl-package->cl-source-package sbcl-trivial-backtrace))
+(define-public cl-conspack
+ (sbcl-package->cl-source-package sbcl-cl-conspack))
-(define-public ecl-trivial-backtrace
- (sbcl-package->ecl-package sbcl-trivial-backtrace))
+(define-public ecl-cl-conspack
+ (sbcl-package->ecl-package sbcl-cl-conspack))
-(define-public sbcl-rfc2388
- (let ((commit "591bcf7e77f2c222c43953a80f8c297751dc0c4e")
+(define-public sbcl-cl-cont
+ (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
(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))
+ (name "sbcl-cl-cont")
+ (version (git-version "0.3.8" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/cl-plus-ssl/cl-plus-ssl")
+ (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
(commit commit)))
- (file-name (git-file-name "cl+ssl" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s"))))
+ (base32
+ "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
(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")
+ (list sbcl-alexandria sbcl-closer-mop))
+ (native-inputs
+ (list sbcl-rt))
+ (synopsis "Delimited continuations for Common Lisp")
(description
- "This library is a fork of SSL-CMUCL. The original SSL-CMUCL source
-code was written by Eric Marsden and includes contributions by Jochen Schmidt.
-Development into CL+SSL was done by David Lichteblau.")
- (license license:expat))))
+ "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-cl+ssl
- (sbcl-package->cl-source-package sbcl-cl+ssl))
+(define-public cl-cont
+ (sbcl-package->cl-source-package sbcl-cl-cont))
-(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 ecl-cl-cont
+ (sbcl-package->ecl-package sbcl-cl-cont))
-(define-public sbcl-kons-9
- (let ((commit "fe0b3228ca28c316457d35f9e7c67edc83b2a4cc")
- (revision "0"))
+(define-public sbcl-cl-containers
+ (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f")
+ (revision "4"))
(package
- (name "sbcl-kons-9")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-containers")
+ (version (git-version "0.12.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/kaveh808/kons-9")
+ (url "https://github.com/hraban/cl-containers")
(commit commit)))
- (file-name (git-file-name "cl-kons-9" version))
+ (file-name (git-file-name "cl-containers" version))
(sha256
- (base32 "1kdwva4qj1s5vmbv6gbmpnk56ahaf8n2kvij5xjlfyk7nriy4bbi"))))
+ (base32
+ "1nrql8s1j123v5gscy99lxvhlzp0ijig9x94w30v3lwfa58hf90l"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("kons-9")
- #:asd-test-systems '("kons-9/testsuite")))
(native-inputs
- (list sbcl-alexandria sbcl-confidence))
+ (list sbcl-lift))
(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")
+ (list sbcl-asdf-system-connections
+ sbcl-metatilities-base
+ sbcl-moptilities))
+ (arguments
+ '(#:asd-systems '("cl-containers"
+ "cl-containers/with-moptilities"
+ "cl-containers/with-utilities")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'relax-version-checks
+ (lambda _
+ (substitute* "cl-containers.asd"
+ (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
+ "\"metatilities-base\""))
+ (substitute* "cl-containers-test.asd"
+ (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
+ "\"lift\""))
+ #t)))))
+ (synopsis "Container library for Common Lisp")
(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)))))
+ "Common Lisp ships with a set of powerful built in data structures
+including the venerable list, full featured arrays, and hash-tables.
+CL-containers enhances and builds on these structures by adding containers
+that are not available in native Lisp (for example: binary search trees,
+red-black trees, sparse arrays and so on), and by providing a standard
+interface so that they are simpler to use and so that changing design
+decisions becomes significantly easier.")
+ (home-page "https://common-lisp.net/project/cl-containers/")
+ (license license:expat))))
-(define-public cl-kons-9
- (sbcl-package->cl-source-package sbcl-kons-9))
+(define-public cl-containers
+ (sbcl-package->cl-source-package sbcl-cl-containers))
-;; 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 ecl-cl-containers
+ (sbcl-package->ecl-package sbcl-cl-containers))
-(define-public sbcl-kmrcl
- (let ((version "1.111")
- (commit "4a27407aad9deb607ffb8847630cde3d041ea25a")
+(define-public sbcl-cl-cookie
+ (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
(revision "1"))
(package
- (name "sbcl-kmrcl")
- (version (git-version version revision commit))
+ (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 "http://git.kpe.io/kmrcl.git/")
+ (url home-page)
(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)
+ (base32
+ "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
(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))))
+ `(("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-kmrcl
- (sbcl-package->cl-source-package sbcl-kmrcl))
+(define-public cl-cookie
+ (sbcl-package->cl-source-package sbcl-cl-cookie))
-(define-public ecl-kmrcl
- (sbcl-package->ecl-package sbcl-kmrcl))
+(define-public ecl-cl-cookie
+ (sbcl-package->ecl-package sbcl-cl-cookie))
-(define-public sbcl-cl-base64
- (let ((commit "577683b18fd880b82274d99fc96a18a710e3987a"))
+(define-public sbcl-cl-coroutine
+ (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
+ (revision "1"))
(package
- (name "sbcl-cl-base64")
- (version (git-version "3.3.4" "1" commit))
+ (name "sbcl-cl-coroutine")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://git.kpe.io/cl-base64.git/")
+ (url "https://github.com/takagi/cl-coroutine")
(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))))
+ (base32
+ "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
(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")
+ (inputs
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-cont" ,sbcl-cl-cont)))
+ (native-inputs
+ (list sbcl-prove))
+ (arguments
+ `(;; TODO: Fix the tests. They fail with:
+ ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
+ #:tests? #f
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-tests
+ (lambda _
+ (substitute* "cl-coroutine-test.asd"
+ (("cl-test-more")
+ "prove"))
+ #t)))))
+ (synopsis "Coroutine library for Common Lisp")
(description
- "This 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))))
+ "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-base64
- (sbcl-package->cl-source-package sbcl-cl-base64))
+(define-public cl-coroutine
+ (sbcl-package->cl-source-package sbcl-cl-coroutine))
-(define-public ecl-cl-base64
- (sbcl-package->ecl-package sbcl-cl-base64))
+(define-public ecl-cl-coroutine
+ (sbcl-package->ecl-package sbcl-cl-coroutine))
-(define-public sbcl-chunga
+(define-public sbcl-cl-cpus
(package
- (name "sbcl-chunga")
- (version "1.1.7")
+ (name "sbcl-cl-cpus")
+ (version "0.0.3")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/chunga")
- (commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (url "https://github.com/muyinliu/cl-cpus")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-cpus" version))
(sha256
- (base32 "0jzn3nyb3f22gm983rfk99smqs3mhb9ivjmasvhq9qla5cl9pyhd"))))
+ (base32 "0sdaff9hpsx7bpkkkqavmxmrrlc2d61gmqjjgn8xchncng4a0rf8"))))
(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-cffi))
+ (home-page "https://github.com/muyinliu/cl-cpus")
+ (synopsis "Common Lisp feature to get number of CPUs")
(description
- "Chunga implements streams capable of chunked encoding on demand as
-defined in RFC 2616.")
- (license license:bsd-2)))
+ "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-chunga
- (sbcl-package->cl-source-package sbcl-chunga))
+(define-public cl-cpus
+ (sbcl-package->cl-source-package sbcl-cl-cpus))
-(define-public ecl-chunga
- (sbcl-package->ecl-package sbcl-chunga))
+(define-public ecl-cl-cpus
+ (sbcl-package->ecl-package sbcl-cl-cpus))
-(define-public sbcl-cl-who
- (let ((version "1.1.4")
- (commit "07dafe9b351c32326ce20b5804e798f10d4f273d")
- (revision "3"))
+(define-public sbcl-cl-cron
+ (let ((commit "092aef5d5666fb43c04258e4043f609670a20456")
+ (revision "0"))
(package
- (name "sbcl-cl-who")
- (version (git-version version revision commit))
+ (name "sbcl-cl-cron")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/cl-who")
+ (url "https://github.com/ciel-lang/cl-cron")
(commit commit)))
- (file-name (git-file-name "cl-who" version))
+ (file-name (git-file-name "cl-cron" version))
(sha256
- (base32
- "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5"))))
+ (base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d"))))
(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")
+ (inputs
+ (list sbcl-bordeaux-threads))
+ (home-page "https://github.com/ciel-lang/cl-cron/")
+ (synopsis "Run cron like jobs in Common Lisp")
(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))))
+ "@code{cl-cron} is a simple tool that provides cron like facilities
+directly inside of Common Lisp.")
+ (license license:gpl3+))))
-(define-public cl-who
- (sbcl-package->cl-source-package sbcl-cl-who))
+(define-public cl-cron
+ (sbcl-package->cl-source-package sbcl-cl-cron))
-(define-public ecl-cl-who
- (sbcl-package->ecl-package sbcl-cl-who))
+(define-public ecl-cl-cron
+ (sbcl-package->ecl-package sbcl-cl-cron))
-(define-public sbcl-chipz
- (let ((version "0.8")
- (commit "82a17d39c78d91f6ea63a03aca8f9aa6069a5e11")
- (revision "2"))
+(define-public sbcl-cl-css
+ (let ((commit "8fe654c8f0cf95b300718101cce4feb517f78e2f"))
(package
- (name "sbcl-chipz")
- (version (git-version version revision commit))
+ (name "sbcl-cl-css")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/chipz")
+ (url "https://github.com/inaimathi/cl-css/")
(commit commit)))
- (file-name (git-file-name "cl-chipz" version))
+ (file-name (git-file-name "cl-css" version))
(sha256
- (base32 "1n4f22i9j8iapjd6yx1z348rggcybvg9h794kx9libjgz4bs371h"))))
+ (base32
+ "1lc42zi2sw11fl2589sc19nr5sd2p0wy7wgvgwaggxa5f3ajhsmd"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-flexi-streams))
- (home-page "http://method-combination.net/lisp/chipz/")
- (synopsis
- "Common Lisp library for decompressing deflate, zlib, gzip, and bzip2
-data")
+ (home-page "https://github.com/inaimathi/cl-css/")
+ (synopsis "Non-validating, inline CSS generator for Common Lisp")
(description
- "DEFLATE data, defined in RFC1951, forms the core of popular
-compression formats such as zlib (RFC 1950) and gzip (RFC 1952). As such,
-Chipz also provides for decompressing data in those formats as well. BZIP2 is
-the format used by the popular compression tool bzip2.")
- ;; The author describes it as "MIT-like"
+ "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-chipz
- (sbcl-package->cl-source-package sbcl-chipz))
-
-(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 cl-css
+ (sbcl-package->cl-source-package sbcl-cl-css))
-(define-public ecl-cl-tls
- (sbcl-package->ecl-package sbcl-cl-tls))
+(define-public ecl-cl-css
+ (sbcl-package->ecl-package sbcl-cl-css))
-(define-public sbcl-dns-client
- (let ((commit "9f252e9c2bb61c57a6cd367e21ad366b0d3e87e0")
- (revision "0"))
+(define-public sbcl-cl-csv
+ (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
+ (revision "2"))
(package
- (name "sbcl-dns-client")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-csv")
+ (version (git-version "1.0.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/dns-client")
+ (url "https://github.com/AccelerationNet/cl-csv")
(commit commit)))
- (file-name (git-file-name "cl-dns-client" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1b6g2wvydwmv1k68favjyq4gfalfxfyl5i0hyh640wdaz2rfvi4n"))))
+ (base32
+ "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
(build-system asdf-build-system/sbcl)
(arguments
- ;; No tests provided.
+ ;; See: https://github.com/AccelerationNet/cl-csv/pull/34
`(#:tests? #f))
(inputs
- (list sbcl-documentation-utils sbcl-usocket))
- (home-page "https://shinmera.github.io/dns-client/")
- (synopsis "DNS protocol client for Common Lisp")
+ `(("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 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))))
+ "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-lisp-pay
- (sbcl-package->cl-source-package sbcl-lisp-pay))
+(define-public cl-csv
+ (sbcl-package->cl-source-package sbcl-cl-csv))
-(define-public ecl-lisp-pay
- (sbcl-package->ecl-package sbcl-lisp-pay))
+(define-public ecl-cl-csv
+ (sbcl-package->ecl-package sbcl-cl-csv))
-(define-public sbcl-stripe
- (let ((commit "b59631d21d63e101de6eb96b56941471504ba644")
- (revision "0"))
+(define-public sbcl-cl-debug
+ (let ((commit "b334280806104ee7f7d3aec666bf7e08d2f89b31")
+ (revision "1"))
(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
+ (name "sbcl-cl-debug")
+ (version (git-version "1.0.0" revision commit))
+ (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))
+ (url "https://github.com/kmx-io/cl-debug")
+ (commit commit)))
+ (file-name (git-file-name "cl-debug" 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)))
+ (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-drakma
- (sbcl-package->cl-source-package sbcl-drakma))
+(define-public cl-debug
+ (sbcl-package->cl-source-package sbcl-cl-debug))
-(define-public ecl-drakma
- (sbcl-package->ecl-package sbcl-drakma))
+(define-public ecl-cl-debug
+ (sbcl-package->ecl-package sbcl-cl-debug))
-(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-cl-dejavu
+ (let ((commit "9d68ced4edee6f96fead42cb4835d0ff4a158373")
(revision "1"))
(package
- (name "sbcl-hunchentoot")
- (version (git-version "1.3.0" revision commit))
+ (name "sbcl-cl-dejavu")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/hunchentoot")
+ (url "https://github.com/dkochmanski/cl-dejavu")
(commit commit)))
- (file-name (git-file-name "cl-hunchentoot" version))
+ (file-name (git-file-name "cl-dejavu" version))
(sha256
- (base32 "1h7ggmmzvgwr4p6j3ai0dqrw30q5309l13w4c03gqrapvwrb65l0"))))
+ (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0"))))
(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")
+ (home-page "https://github.com/dkochmanski/cl-dejavu")
+ (synopsis "DejaVu fonts for Common Lisp")
(description
- "Hunchentoot is a web server written in Common Lisp and at the same
-time a toolkit for building dynamic websites. As a stand-alone web server,
-Hunchentoot is capable of HTTP/1.1 chunking (both directions), persistent
-connections (keep-alive), and SSL.")
- (license license:bsd-2))))
+ "This is a repackage of the original DejaVu Fonts with some convenience
+functions.")
+ (license (list license:cc0
+ (license:x11-style "http://dejavu-fonts.org/"))))))
-(define-public cl-hunchentoot
- (sbcl-package->cl-source-package sbcl-hunchentoot))
+(define-public cl-dejavu
+ (sbcl-package->cl-source-package sbcl-cl-dejavu))
-(define-public ecl-hunchentoot
- (package
- (inherit (sbcl-package->ecl-package sbcl-hunchentoot))
- (arguments
- ;; Tests fail on ECL with 'Socket error in "socket": EINVAL'.
- '(#:tests? #f))))
+(define-public ecl-dejavu
+ (sbcl-package->ecl-package sbcl-cl-dejavu))
-(define-public sbcl-hunchentoot-errors
- (let ((commit "69eb3bcea59ed1ccf3dd1960e6d48fb21f1dadab")
+(define-public sbcl-cl-difflib
+ (let ((commit "98eb335c693f1881584b83ca7be4a0fe05355c4e")
(revision "0"))
(package
- (name "sbcl-hunchentoot-errors")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-difflib")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/mmontone/hunchentoot-errors")
+ (url "https://github.com/wiseman/cl-difflib")
(commit commit)))
- (file-name (git-file-name "cl-hunchentoot-errors" version))
+ (file-name
+ (git-file-name name version))
(sha256
- (base32 "0fab7s8qhhs713cw014qqvzm5z61wmxm2fcbkarhg41cz3li9k1j"))))
+ (base32 "08if0abhqg191xcz9s7xv8faqq51nswzp8hw423fkqjzr24pmq48"))))
(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")
+ ;; 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
- "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.")
+ "A Common Lisp library for computing differences between
+sequences based on the Python difflib module.")
(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 cl-difflib
+ (sbcl-package->cl-source-package sbcl-cl-difflib))
-(define-public ecl-trivial-types
- (sbcl-package->ecl-package sbcl-trivial-types))
+(define-public ecl-cl-difflib
+ (sbcl-package->ecl-package sbcl-cl-difflib))
-(define-public sbcl-cl-annot
- (let ((commit "c99e69c15d935eabc671b483349a406e0da9518d")
+(define-public sbcl-cl-diskspace
+ (let ((commit "2dce2d0387d58221c452bd76c7b9b7a7de81ef55")
(revision "1"))
(package
- (name "sbcl-cl-annot")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-diskspace")
+ (version (git-version "0.3.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/m2ym/cl-annot")
+ (url "https://github.com/muyinliu/cl-diskspace")
(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"))
+ (file-name (git-file-name "cl-diskspace" version))
(sha256
- (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
+ (base32 "0l19hxqw6b8i5i1jdbr45k1xib9axcwdagsp3y8wkb35g6wwc0s7"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:phases
+ `(#: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")
+ (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
- "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
-is a collection of Common Lisp Utilities, things that everybody writes since
-they're not part of the official standard. There are some very useful things
-there; the only problems are that they aren't implemented as well as you'd
-like (some aren't implemented at all) and they aren't conveniently packaged
-and maintained. It takes quite a bit of work to carefully implement utilities
-for common use, commented and documented, with error checking placed
-everywhere some dumb user might make a mistake.")
- (license license:public-domain))))
+ "CL-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-utilities
- (sbcl-package->cl-source-package sbcl-cl-utilities))
+(define-public cl-diskspace
+ (sbcl-package->cl-source-package sbcl-cl-diskspace))
-(define-public ecl-cl-utilities
- (sbcl-package->ecl-package sbcl-cl-utilities))
+(define-public ecl-cl-diskspace
+ (sbcl-package->ecl-package sbcl-cl-diskspace))
-(define-public sbcl-map-set
- (let ((commit "7b4b545b68b8")
+(define-public sbcl-cl-docutils
+ (let ((commit "756b5ad42360e84d8225fa69815bdd1623ceaa40")
(revision "1"))
(package
- (name "sbcl-map-set")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-docutils")
+ (version (git-version "0.1.1" revision commit))
(source
(origin
- (method url-fetch)
- (uri (string-append
- "https://bitbucket.org/tarballs_are_good/map-set/get/"
- commit ".tar.gz"))
+ (method git-fetch)
+ (uri
+ (git-reference
+ (url "https://github.com/willijar/cl-docutils/")
+ (commit commit)))
+ (file-name (git-file-name "cl-docutils" version))
(sha256
- (base32 "1sx5j5qdsy5fklspfammwb16kjrhkggdavm922a9q86jm5l0b239"))))
+ (base32
+ "132bxlj0jlhiabi29mygmkcbbgyb5s1yz1xdfhm3pgrf9f8605gg"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://bitbucket.org/tarballs_are_good/map-set")
- (synopsis "Set-like data structure")
+ (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
- "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))))
+ "@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-xsubseq
- (sbcl-package->cl-source-package sbcl-xsubseq))
+(define-public cl-docutils
+ (sbcl-package->cl-source-package sbcl-cl-docutils))
-(define-public ecl-xsubseq
- (sbcl-package->ecl-package sbcl-xsubseq))
+(define-public ecl-cl-docutils
+ (sbcl-package->ecl-package sbcl-cl-docutils))
-(define-public sbcl-smart-buffer
- (let ((commit "09b9a9a0b3abaa37abe9a730f5aac2643dca4e62")
- (revision "1"))
+(define-public sbcl-cl-dot
+ (let ((commit "73dfbb6e015a28ebed873266e4e8190e509b43de")
+ (revision "0"))
(package
- (name "sbcl-smart-buffer")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-dot")
+ (version (git-version "0.9.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/smart-buffer")
+ (url "https://github.com/michaelw/cl-dot")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-dot" version))
(sha256
- (base32 "0qz1zzxx0wm5ff7gpgsq550a59p0qj594zfmm2rglj97dahj54l7"))))
+ (base32 "0mcvzqfcg5rzr8rz8aa2yr2jl3ifflaksvps08zj71hbhiacqpxa"))))
(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")
+ (home-page "https://github.com/michaelw/cl-dot")
+ (synopsis "Generate Graphviz dot output from arbitrary Lisp data")
(description
- "Smart-buffer provides an output buffer which changes the destination
-depending on content size.")
- (license license:bsd-3))))
+ "CL-DOT is a Common Lisp library for generating Graphviz dot output from
+arbitrary Lisp data.")
+ (license license:expat))))
-(define-public cl-smart-buffer
- (sbcl-package->cl-source-package sbcl-smart-buffer))
+(define-public cl-dot
+ (sbcl-package->cl-source-package sbcl-cl-dot))
-(define-public ecl-smart-buffer
- (sbcl-package->ecl-package sbcl-smart-buffer))
+(define-public ecl-cl-dot
+ (sbcl-package->ecl-package sbcl-cl-dot))
-(define-public sbcl-fast-http
- (let ((commit "502a37715dcb8544cc8528b78143a942de662c5a")
- (revision "2"))
+(define-public sbcl-cl-emb
+ (let ((commit "fd8652174d048d4525a81f38cdf42f4fa519f840")
+ (revision "1"))
(package
- (name "sbcl-fast-http")
- (version (git-version "0.2.0" revision commit))
+ (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/fukamachi/fast-http")
+ (url "https://github.com/38a938c2/cl-emb")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0al2g7g219jjljsf7b23pbilpgacxy5as5gs2nqf76b5qni396mi"))))
+ (base32 "1xcm31n7afh5316lwz8iqbjx7kn5lw0l11arg8mhdmkx42aj4gkk"))))
(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))))
+ (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-fast-http
- (sbcl-package->cl-source-package sbcl-fast-http))
+(define-public cl-emb
+ (sbcl-package->cl-source-package sbcl-cl-emb))
-(define-public ecl-fast-http
- (sbcl-package->ecl-package sbcl-fast-http))
+(define-public ecl-cl-emb
+ (sbcl-package->ecl-package sbcl-cl-emb))
-(define-public sbcl-static-vectors
+(define-public sbcl-cl-environments
(package
- (name "sbcl-static-vectors")
- (version "1.8.9")
+ (name "sbcl-cl-environments")
+ (version "0.4")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sionescu/static-vectors")
+ (url "https://github.com/alex-gutev/cl-environments")
(commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-environments" version))
(sha256
- (base32 "079qa20lhanzsz1qf4iags91n0ziylbjgbcymm5a5qj7yryas4fw"))))
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-alexandria sbcl-cffi))
+ (base32 "10jxj043d2dw5vc0i0lz0lsa4qszn8him5is8jdhl4nsyfcazmky"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/sionescu/static-vectors")
- (synopsis "Allocate SIMPLE-ARRAYs in static memory")
+ (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
- "With @code{static-vectors}, you can create vectors allocated in static
-memory.")
+ "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-static-vectors
- (sbcl-package->cl-source-package sbcl-static-vectors))
-
-(define-public ecl-static-vectors
- (sbcl-package->ecl-package sbcl-static-vectors))
-
-(define-public sbcl-marshal
- (let ((commit "eff1b15f2b0af2f26f71ad6a4dd5c4beab9299ec")
- (revision "1"))
- (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
- (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
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Rudolph-Miller/jonathan")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "14x4iwz3mbag5jzzzr4sb6ai0m9r4q4kyypbq32jmsk2dx1hi807"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove sbcl-legion))
- (inputs
- (list sbcl-cl-syntax sbcl-fast-io sbcl-proc-parse sbcl-cl-ppcre))
- (home-page "https://rudolph-miller.github.io/jonathan/overview.html")
- (synopsis "JSON encoder and decoder")
- (description
- "High performance JSON encoder and decoder. Currently support: SBCL,
-CCL.")
- ;; Author specifies the MIT license
- (license license:expat))))
-
-(define-public cl-jonathan
- (sbcl-package->cl-source-package sbcl-jonathan))
-
-(define-public ecl-jonathan
- (sbcl-package->ecl-package sbcl-jonathan))
-
-(define-public sbcl-http-body
- (let ((commit "3e4bedd6a9d9bc4e1dc0a45e5b55360ae30fd388")
- (revision "2"))
- (package
- (name "sbcl-http-body")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/http-body")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0kcg43l5674drzid9cj938q0ki5z25glx296rl239dm7yfmxlzz2"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("http-body-test" "http-body")))
- (native-inputs
- (list sbcl-assoc-utils sbcl-prove sbcl-trivial-utf-8))
- (inputs
- (list sbcl-babel
- sbcl-cl-ppcre
- sbcl-fast-http
- sbcl-flexi-streams
- sbcl-jonathan
- sbcl-trivial-gray-streams
- sbcl-cl-utilities
- sbcl-quri))
- (home-page "https://github.com/fukamachi/http-body")
- (synopsis "HTTP POST data parser")
- (description
- "HTTP-Body parses HTTP POST data and returns POST parameters. It
-supports application/x-www-form-urlencoded, application/json, and
-multipart/form-data.")
- (license license:bsd-2))))
-
-(define-public cl-http-body
- (sbcl-package->cl-source-package sbcl-http-body))
-
-(define-public ecl-http-body
- (sbcl-package->ecl-package sbcl-http-body))
-
-(define-public sbcl-ciel
- (let ((commit "6cc1cef5e37e9f495c8163271a5de48de99f348a")
- (revision "0"))
- (package
- (name "sbcl-ciel")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/ciel-lang/CIEL")
- (commit commit)))
- (file-name (git-file-name "ciel" version))
- (sha256
- (base32 "1bwafbbsppxqvijf43dii55mpzrklh6faj2m5dhajg2f2m8qckgi"))))
- (build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (inputs
- (list sbcl-access
- sbcl-alexandria
- sbcl-arrow-macros
- sbcl-bordeaux-threads
- sbcl-cl-ansi-text
- sbcl-cl-ansi-text
- sbcl-cl-cron
- sbcl-cl-csv
- sbcl-cl-json-pointer
- sbcl-cl-ppcre
- sbcl-cl-punch
- sbcl-cl-reexport
- sbcl-cl-str
- sbcl-clesh
- sbcl-clingon
- sbcl-closer-mop
- sbcl-cmd
- sbcl-dbi
- sbcl-defstar
- sbcl-deploy
- sbcl-dexador
- sbcl-dissect
- sbcl-easy-routes
- sbcl-file-notify
- sbcl-fn
- sbcl-for
- sbcl-fset
- sbcl-generic-cl
- sbcl-hunchentoot
- sbcl-local-time
- sbcl-log4cl
- sbcl-lparallel
- sbcl-lquery
- sbcl-metabang-bind
- sbcl-modf
- sbcl-named-readtables
- sbcl-nodgui
- sbcl-parse-float
- sbcl-parse-number
- sbcl-printv
- sbcl-pythonic-string-reader
- sbcl-quicksearch
- sbcl-quri
- sbcl-repl-utilities
- sbcl-serapeum
- sbcl-shasht
- sbcl-shlex
- sbcl-spinneret
- sbcl-sxql
- sbcl-trivia
- sbcl-trivial-arguments
- sbcl-trivial-do
- sbcl-trivial-monitored-thread
- sbcl-trivial-package-local-nicknames
- sbcl-trivial-types
- sbcl-vgplot
- sbcl-which))
- (home-page "http://ciel-lang.org/")
- (synopsis "CIEL Is an Extended Lisp")
- (description
- "CIEL is a ready-to-use collection of libraries providing: a binary, to
-run CIEL scripts; a simple full-featured REPL for the terminal; a Lisp library
-and a core image .")
- (license license:expat))))
-
-(define-public cl-ciel
- (sbcl-package->cl-source-package sbcl-ciel))
-
-(define-public ecl-ciel
- (sbcl-package->ecl-package sbcl-ciel))
-
-(define-public sbcl-circular-streams
- (let ((commit "e770bade1919c5e8533dd2078c93c3d3bbeb38df")
- (revision "1"))
- (package
- (name "sbcl-circular-streams")
- (version (git-version "0.1.0" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/fukamachi/circular-streams")
- (commit commit)))
- (file-name (git-file-name name version))
- (sha256
- (base32 "1wpw6d5cciyqcf92f7mvihak52pd5s47kk4qq6f0r2z2as68p5rs"))))
- (build-system asdf-build-system/sbcl)
- (arguments
- ;; The tests depend on cl-test-more which is now prove. Prove
- ;; tests aren't working for some reason.
- `(#:tests? #f))
- (inputs
- (list sbcl-fast-io sbcl-trivial-gray-streams))
- (home-page "https://github.com/fukamachi/circular-streams")
- (synopsis "Circularly readable streams for Common Lisp")
- (description
- "Circular-Streams allows you to read streams circularly by wrapping real
-streams. Once you reach end-of-file of a stream, it's file position will be
-reset to 0 and you're able to read it again.")
- (license license:llgpl))))
-
-(define-public cl-circular-streams
- (sbcl-package->cl-source-package sbcl-circular-streams))
-
-(define-public ecl-circular-streams
- (sbcl-package->ecl-package sbcl-circular-streams))
-
-(define-public sbcl-trivial-rfc-1123
- (let ((commit "9ef59c3fdec08b0e3c9ed02d39533887b6d1b8e3")
- (revision "0"))
- (package
- (name "sbcl-trivial-rfc-1123")
- (version (git-version "0.0.0" revision commit))
- (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 cl-environments
+ (sbcl-package->cl-source-package sbcl-cl-environments))
-(define-public ecl-trivial-rfc-1123
- (sbcl-package->ecl-package sbcl-trivial-rfc-1123))
+(define-public ecl-cl-environments
+ (sbcl-package->ecl-package sbcl-cl-environments))
-(define-public sbcl-lack
- (let ((commit "abff8efeb0c3a848e6bb0022f2b8b7fa3a1bc88b")
+(define-public sbcl-cl-fad
+ ;; No release since 2019
+ (let ((commit "3f4d32d3aa1093966046d001411a852eb8f4b535")
(revision "1"))
(package
- (name "sbcl-lack")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-cl-fad")
+ (version (git-version "0.7.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/lack")
+ (url "https://github.com/edicl/cl-fad/")
(commit commit)))
- (file-name (git-file-name "lack" version))
(sha256
- (base32 "1avh4ygcj9xcx4m17nj0wnxxaisk26w4ljs2bibzxaln24x7pi85"))))
+ (base32 "0a1xqldrq170lflnns3xp6swpnvsvllf5vq0h7sz8jqh4riqlny6"))
+ (file-name (git-file-name "cl-fad" version))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-prove))
+ (list sbcl-cl-ppcre sbcl-unit-test))
(inputs
- `(("circular-streams" ,sbcl-circular-streams)
- ("http-body" ,sbcl-http-body)
- ("ironclad" ,sbcl-ironclad)
- ("local-time" ,sbcl-local-time)
- ("quri" ,sbcl-quri)
- ("trivial-mimes" ,sbcl-trivial-mimes)))
- (arguments
- '(#:asd-systems '("lack"
- "lack-request"
- "lack-response"
- "lack-component"
- "lack-util"
- "lack-middleware-backtrace"
- "lack-middleware-static")
- ;; XXX: Component :CLACK not found
- #:tests? #f))
- (home-page "https://github.com/fukamachi/lack")
- (synopsis "Lack, the core of Clack")
+ (list sbcl-alexandria sbcl-bordeaux-threads))
+ (synopsis "Portable pathname library for Common Lisp")
(description
- "Lack is a Common Lisp library which allows web applications to be
-constructed of modular components. It was originally a part of Clack, however
-it's going to be rewritten as an individual project since Clack v2 with
-performance and simplicity in mind.")
- (license license:llgpl))))
-
-(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))
- (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)))
+ "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-postgres+local-time
- (sbcl-package->cl-source-package sbcl-cl-postgres+local-time))
+(define-public cl-fad
+ (sbcl-package->cl-source-package sbcl-cl-fad))
-(define-public ecl-cl-postgres+local-time
- (sbcl-package->ecl-package sbcl-cl-postgres+local-time))
+(define-public ecl-cl-fad
+ (sbcl-package->ecl-package sbcl-cl-fad))
-(define-public sbcl-chronicity
+(define-public sbcl-cl-fast-ecs
(package
- (name "sbcl-chronicity")
- (version "0.4.1")
+ (name "sbcl-cl-fast-ecs")
+ (version "0.2.2")
(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))
+ (url "https://gitlab.com/lockie/cl-fast-ecs")
+ (commit version)))
+ (file-name (git-file-name "cl-fast-ecs" version))
(sha256
- (base32 "0rzrl9is2v1aqbm0sym0qx3blnpd0bl13dkkmll6mb3983k2mkax"))))
+ (base32 "00nw5nwzcz8x1x1lycmjik8pcqzxrl896j0xjjl33rjljsmj45sx"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-lisp-unit))
+ (list sbcl-chlorophyll sbcl-cl-mock sbcl-parachute))
(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")
+ (list sbcl-alexandria sbcl-trivial-garbage))
+ (home-page "https://lockie.gitlab.io/cl-fast-ecs/")
+ (synopsis "Blazingly fast Entity-Component-System microframework")
(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"))
- (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))
+ "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.
-(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))))
+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-ningle
- (sbcl-package->cl-source-package sbcl-ningle))
+(define-public cl-fast-ecs
+ (sbcl-package->cl-source-package sbcl-cl-fast-ecs))
-(define-public ecl-ningle
- (sbcl-package->ecl-package sbcl-ningle))
+(define-public ecl-cl-fast-ecs
+ (sbcl-package->ecl-package sbcl-cl-fast-ecs))
(define-public sbcl-cl-fastcgi
(let ((commit "de8b49b26de9863996ec18db28af8ab7e8ac4e20")
@@ -7644,43 +5156,6 @@ mostly Common Lisp implementation.")
(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"))
@@ -7722,703 +5197,611 @@ built at runtime.")
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"))
+(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-clack")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-cl-fond")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/clack")
+ (url "https://github.com/Shirakumo/cl-fond")
(commit commit)))
- (file-name (git-file-name "cl-clack" version))
+ (file-name (git-file-name "cl-fond" version))
(sha256
- (base32 "0sfmvqmsg9z13x0v77448rpdqgyprdq739nsbrjw9a28hv9jmkg9"))))
+ (base32 "03ygcw1azb44bhdsqcq99xi4ci0by76ap5jf5l2d1vfxq04v8grq"))))
(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))))
+ 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-clack
- (sbcl-package->cl-source-package sbcl-clack))
+(define-public cl-fond
+ (sbcl-package->cl-source-package sbcl-cl-fond))
-(define-public ecl-clack
- (sbcl-package->ecl-package sbcl-clack))
+(define-public ecl-cl-fond
+ (sbcl-package->ecl-package sbcl-cl-fond))
-(define-public sbcl-cl-log
- (let ((commit "8f4b766d51e02245c310526cf1e4534ce634f837")
- (revision "1"))
- (package
- (name "sbcl-cl-log")
- (version "1.0.1")
- (source
- (origin
+(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/nicklevine/cl-log")
- (commit commit)))
+ (url "https://github.com/alex-gutev/cl-form-types")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name name version))
(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))))
+ (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.
-(define-public cl-log
- (sbcl-package->cl-source-package sbcl-cl-log))
+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-log
- (sbcl-package->ecl-package sbcl-cl-log))
+Macros and symbol-macros are fully expanded and all special forms, except
+@code{CATCH}, are supported.")
+ (license license:expat)))
-(define-public sbcl-log4cl
- (let ((commit "fe3da517147d023029782ced7cd989ba24f1e62d")
- (revision "2"))
+(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-log4cl")
- (version (git-version "1.1.4" revision commit))
+ (inherit pkg)
+ (arguments
+ ;; FIXME: Syntax error in declaration (TYPE T (FORM &KEY STRICT
+ ;; EXPAND-COMPILER-MACROS (TEST (QUOTE FORM-TYPE=))))
+ ;; An error occurred during initialization: COMPILE-FILE-ERROR while...
+ ;; See <https://github.com/alex-gutev/cl-form-types/issues/22>.
+ '(#:tests? #f)))))
+
+(define-public sbcl-cl-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/sharplispers/log4cl")
+ (url "https://github.com/rpav/cl-freetype2")
(commit commit)))
- (file-name (git-file-name "cl-log4cl" version))
+ (file-name (git-file-name "cl-freetype2" version))
(sha256
- (base32 "0n119sy35k9yl4n18az1sw9a7saa5jh3v44863b305by1p5xdy7k"))))
+ (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-stefil))
+ (list sbcl-fiveam))
(inputs
- (list sbcl-bordeaux-threads))
- (home-page "https://github.com/7max/log4cl")
- (synopsis "Common Lisp logging framework, modeled after Log4J")
+ (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 Common Lisp logging framework that can log at various levels
-and mix text with expressions.")
- (license license:asl2.0))))
+ "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-log4cl
- (sbcl-package->cl-source-package sbcl-log4cl))
+(define-public cl-freetype2
+ (sbcl-package->cl-source-package sbcl-cl-freetype2))
-(define-public ecl-log4cl
- (sbcl-package->ecl-package sbcl-log4cl))
+(define-public ecl-cl-freetype2
+ (sbcl-package->ecl-package sbcl-cl-freetype2))
-(define-public sbcl-printv
- (let ((commit "e717a7fe076dae861a96117b2f9af29db8d2294d")
- (revision "2"))
+(define-public sbcl-cl-gamepad
+ (let ((commit "d5b99fbaa2e39294d23061699e8f1e761eda7205")
+ (revision "3"))
(package
- (name "sbcl-printv")
- (version (git-version "0.1.0" 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/danlentz/printv")
+ (url "https://github.com/Shirakumo/cl-gamepad")
(commit commit)))
- (file-name (git-file-name "cl-printv" version))
+ (file-name (git-file-name "cl-gamepad" version))
(sha256
- (base32 "07agyzkwp3w2r4d2anrmr8h00yngpr5dq9mjd3m4kzhn1jcmilfb"))))
+ (base32 "0y6kg9wq92p07i1chm1v7j7p77iqc5c985pdvmmivcip8zmd4hm4"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list figlet))
(arguments
- `(#:phases
+ `(#:tests? #f ; No tests
+ #:phases
(modify-phases %standard-phases
- (add-after 'unpack 'patch-figlet-executable
+ (add-after 'unpack 'patch-evdev-lib-path
(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")
+ (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
- "@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-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))))
+ "This is a library to provide cross-platform access to gamepads,
+joysticks, and other such HID devices.")
+ (license license:zlib))))
-(define-public ecl-cl-debug
- (sbcl-package->ecl-package sbcl-cl-debug))
+(define-public cl-gamepad
+ (sbcl-package->cl-source-package sbcl-cl-gamepad))
-(define-public cl-debug
- (sbcl-package->cl-source-package sbcl-cl-debug))
+(define-public ecl-cl-gamepad
+ (sbcl-package->ecl-package sbcl-cl-gamepad))
-(define-public sbcl-verbose
- (let ((commit "c5b7ecd465be61b35af17ef57564697b88397174")
- (revision "1"))
+(define-public sbcl-cl-geometry
+ (let ((commit "24eddedc47b931cec27361752736ef0b54fc9984"))
(package
- (name "sbcl-verbose")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-cl-geometry")
+ (version (git-version "0.0.3" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/verbose/")
+ (url "https://github.com/vydd/cl-geometry")
(commit commit)))
- (file-name (git-file-name "verbose" version))
+ (file-name (git-file-name "cl-cl-geometry" version))
(sha256
- (base32 "0r51ydj5v7afi2jrlscbhxprv13d9vzg5316g1yzwaxc1kzsdsw6"))))
+ (base32 "188xrd8plvc34gz7q01zmkdrzxbpwzln103l5dl78pa4a6vzz34h"))))
(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")
+ (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 Common Lisp library providing logging faciltiy similar to
-@code{CL-LOG} and @code{LOG4CL}.")
- (license license:zlib))))
+ "This is a system for two dimensional computational geometry for Common Lisp.
-(define-public ecl-verbose
- (sbcl-package->ecl-package sbcl-verbose))
+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-verbose
- (sbcl-package->cl-source-package sbcl-verbose))
+(define-public cl-cl-geometry
+ (sbcl-package->cl-source-package sbcl-cl-geometry))
-(define-public sbcl-vgplot
- (let ((commit "76329928a3709387c0779175af56ec49d16bcd35")
- (revision "0"))
+(define-public ecl-cl-geometry
+ (sbcl-package->ecl-package sbcl-cl-geometry))
+
+(define-public sbcl-cl-glfw3
+ (let ((commit "32c3f34d592d55ee7ce932ed85804c1a9c4158c6")
+ (revision "1"))
(package
- (name "sbcl-vgplot")
+ (name "sbcl-cl-glfw3")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/volkers/vgplot")
+ (url "https://github.com/AlexCharlton/cl-glfw3")
(commit commit)))
- (file-name (git-file-name "vgplot" version))
+ (file-name (git-file-name "cl-glfw3" version))
(sha256
- (base32 "1vc5fd787xa8831wjbmwrpg17f9isi5k8dmb85fsysz47plbvi1y"))))
+ (base32 "1wzr43nckdx4rlgxzhm1r4kfc264q969mc43y0js9ramh7l8gba5"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
+ (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-cl-fad sbcl-cl-ppcre sbcl-ltk))
- (home-page "https://github.com/volkers/vgplot")
- (synopsis "Common lisp library interfacing to the gnuplot utility")
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("cl-opengl" ,sbcl-cl-opengl)
+ ("glfw" ,glfw)
+ ("trivial-main-thread" ,sbcl-trivial-main-thread)))
+ (home-page "https://github.com/AlexCharlton/cl-glfw3")
+ (synopsis "Common Lisp bindings to GLFW version 3.x")
(description
- "This package provides an interface to the @code{gnuplot} plotting
-utility. The intention of the API is to resemble to some of the plot commands
-of octave or matlab.")
- (license license:gpl3+))))
+ "This package provides a Common Lisp bindings to @code{glfw}, an OpenGL
+application development library.")
+ (license license:bsd-2))))
-(define-public cl-vgplot
- (sbcl-package->cl-source-package sbcl-vgplot))
+(define-public cl-glfw3
+ (sbcl-package->cl-source-package sbcl-cl-glfw3))
-(define-public ecl-vgplot
- (sbcl-package->ecl-package sbcl-vgplot))
+(define-public ecl-cl-glfw3
+ (sbcl-package->ecl-package sbcl-cl-glfw3))
-(define-public sbcl-find-port
- (let ((commit "811727f88d7f000623bf92fdb0e64678a7112a28")
- (revision "2"))
+(define-public sbcl-cl-glib
+ (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57")
+ (revision "1"))
(package
- (name "sbcl-find-port")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/eudoxia0/find-port")
+ (name "sbcl-cl-glib")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/bohonghuang/cl-glib")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-glib" version))
(sha256
- (base32
- "1fw6q7d2bxxb7fqk548ylq8mx4sz95yc0q5h0rwd0mnqjrbwbari"))))
- (native-inputs
- (list sbcl-fiveam))
+ (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" ))))
+ (build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject")))
(inputs
- (list sbcl-usocket))
- (synopsis "Find open ports programmatically in Common Lisp")
- (description "This is a small Common Lisp library that finds an open
-port within a range.")
- (license license:expat))))
+ (list 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-find-port
- (sbcl-package->cl-source-package sbcl-find-port))
+(define-public cl-glib
+ (sbcl-package->cl-source-package sbcl-cl-glib))
-(define-public ecl-find-port
- (sbcl-package->ecl-package sbcl-find-port))
+(define-public ecl-cl-glib
+ (sbcl-package->ecl-package sbcl-cl-glib))
-(define-public sbcl-numpy-file-format
- (let ((commit "e440c7bbc0d86b9abf73acb0fa665b77b82a6c98")
- (revision "2"))
+(define-public sbcl-cl-gltf
+ (let ((commit "7a3af05a7f491d8973b217f096806ef12a97474b")
+ (revision "1"))
(package
- (name "sbcl-numpy-file-format")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-gltf")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/numpy-file-format")
+ (url "https://github.com/Shirakumo/cl-gltf")
(commit commit)))
- (file-name (git-file-name "cl-numpy-file-format" version))
+ (file-name (git-file-name "cl-gltf" version))
(sha256
- (base32 "1n0nixc44z1cymm20wif0l2100ydv0h69l6i6xz5bmwcb2zc4gqr"))))
+ (base32 "1d64fg2l2c0wns3wpp1xypd8687gnp3k70fv9fb48m1kpzg4kvrh"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; No tests provided.
+ `(#:tests? #f))
(inputs
- (list sbcl-ieee-floats sbcl-trivial-features))
- (home-page "https://github.com/marcoheisig/numpy-file-format")
- (synopsis "Read and write NumPy .npy and .npz files")
+ (list sbcl-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
- "The NUMPY-FILE-FORMAT library is a Common Lisp library for reading and
-writing NumPy @file{.npy} and @file{.npz} files.")
- (license license:expat))))
+ "This package provides a Common Lisp parser for glTF file format.")
+ (license license:zlib))))
-(define-public cl-numpy-file-format
- (sbcl-package->cl-source-package sbcl-numpy-file-format))
+(define-public cl-gltf
+ (sbcl-package->cl-source-package sbcl-cl-gltf))
-(define-public ecl-numpy-file-format
- (sbcl-package->ecl-package sbcl-numpy-file-format))
+;; FIXME: ECL part is failing
+;; ;;; Internal error:
+;;
+;; ** There is no package with the name SEQUENCE.An error occurred during
+;; initialization: COMPILE-FILE-ERROR while compiling #<cl-source-file
+;; "trivial-extensible-sequences" "fallback">.
+;;
+;; See <https://github.com/Shirakumo/cl-gltf/issues/3>
+;;
+;; (define-public ecl-cl-gltf
+;; (sbcl-package->ecl-package sbcl-cl-gltf))
-(define-public sbcl-py4cl
- (let ((commit "2f2a008dd6162d4446803971292fe1b323fe0dd5")
- (revision "2"))
+(define-public sbcl-cl-gobject-introspection
+ (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9")
+ (revision "3"))
(package
- (name "sbcl-py4cl")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-gobject-introspection")
+ (version (git-version "0.3" revision commit))
+ (home-page "https://github.com/andy128k/cl-gobject-introspection")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bendudson/py4cl")
+ (url home-page)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-gobject-introspection" version))
(sha256
- (base32
- "1zx1kpfpd8mi1qaa7gr32mki6nvl6pqcs3437fvn4xa3yf7ybsha"))
- (modules '((guix build utils)))))
+ (base32 "0xwmj4b3whz12i474g54krp1v6h0fpvsx8lgwpk6rkli9xc71wc3"))))
(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))
+ (list glib
+ gobject-introspection
+ sbcl-alexandria
+ sbcl-cffi
+ sbcl-iterate
+ sbcl-trivial-garbage))
+ (native-inputs
+ (list sbcl-fiveam))
(arguments
'(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-python3-path
+ (add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/python-process.lisp"
- (("\\*python-command\\* \"python\"")
- (string-append "*python-command* "
- "\""
- (search-input-file inputs "/bin/python3")
- "\"")))))
- (add-after 'unpack 'replace-*base-directory*-var
- (lambda* (#:key outputs #:allow-other-keys)
- ;; In the ASD, the author makes an attempt to
- ;; programatically determine the location of the
- ;; source-code so lisp can call into "py4cl.py". We can
- ;; hard-code this since we know where this file will
- ;; reside.
- (substitute* "src/python-process.lisp"
- (("py4cl/config:\\*base-directory\\*")
- (string-append
- "\""
- (assoc-ref outputs "out")
- "/share/common-lisp/"
- (%lisp-type)
- "/py4cl/"
- "\""))))))))
- (synopsis "Call python from Common Lisp")
+ (substitute* "src/init.lisp"
+ (("libgobject-2\\.0\\.so")
+ (search-input-file inputs "/lib/libgobject-2.0.so"))
+ (("libgirepository-1\\.0\\.so")
+ (search-input-file inputs
+ "/lib/libgirepository-1.0.so"))))))))
+ (synopsis "Common Lisp bindings to GObject Introspection")
(description
- "Py4CL is a bridge between Common Lisp and Python, which enables Common
-Lisp to interact with Python code. It uses streams to communicate with a
-separate python process, the approach taken by cl4py. This is different to
-the CFFI approach used by burgled-batteries, but has the same goal.")
- (home-page "https://github.com/bendudson/py4cl")
- ;; MIT License
- (license license:expat))))
+ "This library is a bridge between Common Lisp and GObject
+Introspection, which enables Common Lisp programs to access the full interface
+of C+GObject libraries without the need of writing dedicated bindings.")
+ (license (list license:bsd-3
+ ;; Tests are under a different license.
+ license:llgpl)))))
-(define-public cl-py4cl
- (sbcl-package->cl-source-package sbcl-py4cl))
+(define-public cl-gobject-introspection
+ (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
-(define-public ecl-py4cl
- (sbcl-package->ecl-package sbcl-py4cl))
+(define-public ecl-cl-gobject-introspection
+ (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
-(define-public sbcl-schemeish
- (let ((commit "dff57bafae5d0cffa104c8fdc4146502f32d7f85")
+(define-public sbcl-cl-gobject-introspection-wrapper
+ (let ((commit "2d197cba7e7d734ac8a2e181e5e709e5b218bada")
(revision "1"))
(package
- (name "sbcl-schemeish")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-gobject-introspection-wrapper")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/chebert/schemeish")
+ (url "https://github.com/bohonghuang/cl-gobject-introspection-wrapper")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-gobject-introspection-wrapper" version))
(sha256
- (base32 "0q9b07spmhg1b576cnnacvkf7zr3mab2rdydfylbn92y9mms9vyj"))))
+ (base32 "05np2zs5806ib6qfz7d6knyaz6llxgwvjqavl1fsz5hcga40296s"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-trivial-arguments))
- (synopsis "Scheme style syntax/macros/functions for Common Lisp")
+ (list sbcl-alexandria
+ sbcl-cl-gobject-introspection
+ sbcl-cl-ppcre))
+ (home-page
+ "https://github.com/bohonghuang/cl-gobject-introspection-wrapper")
+ (synopsis
+ "Wrap and call GObject Introspection FFI function in Common Lisp")
(description
- "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))))
+ "This library converts the elements from GObject Introspection into
+Common Lisp-style definitions, based on cl-gobject-introspection.")
+ (license license:lgpl3+))))
-(define-public cl-schemeish
- (sbcl-package->cl-source-package sbcl-schemeish))
+(define-public cl-gobject-introspection-wrapper
+ (sbcl-package->cl-source-package sbcl-cl-gobject-introspection-wrapper))
-(define-public ecl-schemeish
- (sbcl-package->ecl-package sbcl-schemeish))
+(define-public ecl-cl-gobject-introspection-wrapper
+ (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper))
-(define-public sbcl-parse-declarations
- (let ((commit "549aebbfb9403a7fe948654126b9c814f443f4f2")
- (revision "1"))
+(define-public sbcl-cl-gopher
+ (let ((commit "0899e7fa2134206f9d9778c7d53c49b7a59ff070")
+ (revision "3"))
(package
- (name "sbcl-parse-declarations")
- (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 (string-append
- "https://gitlab.common-lisp.net/parse-declarations/"
- "parse-declarations.git"))
+ (url "https://github.com/knusbaum/cl-gopher")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-gopher" version))
(sha256
- (base32 "03g5qks4c59nmxa48pbslxkfh77h8hn8566jddp6m9pl15dzzpxd"))))
+ (base32 "1ky4s33m5d0wvdaqji12pxr93qqfl5x62zjp3m4ihbdj0ws3yw2f"))
+ (snippet
+ '(begin
+ ;; These files are mostly examples (that assume Quicklisp) which
+ ;; drag the SBCL package into the CL package.
+ (for-each delete-file
+ '("cl-gopher-network.lsh"
+ "cl-gopher-start.lsh"))
+ #t))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("parse-declarations-1.0")))
- (home-page "https://common-lisp.net/project/parse-declarations/")
- (synopsis "Parse, filter, and build declarations")
+ (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
- "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))))
+ "@code{cl-gopher} is a Common Lisp library for interacting with the
+Gopher protocol.
-(define-public cl-parse-declarations
- (sbcl-package->cl-source-package sbcl-parse-declarations))
+It is suitable for building both clients and servers, and provides a sample
+client.")
+ (license license:bsd-2))))
-(define-public ecl-parse-declarations
- (sbcl-package->ecl-package sbcl-parse-declarations))
+(define-public cl-gopher
+ (sbcl-package->cl-source-package sbcl-cl-gopher))
-(define-public sbcl-burgled-batteries3
- (let ((commit "f65f454d13bb6c40e17e9ec62e41eb5069e09760")
+(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-burgled-batteries3")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-graph")
+ (version (git-version "0.10.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/snmsts/burgled-batteries3")
+ (url "https://github.com/hraban/cl-graph")
(commit commit)))
- (file-name (git-file-name "cl-burgled-batteries3" version))
+ (file-name (git-file-name "cl-graph" version))
(sha256
- (base32
- "1nzn7jawrfajyzwfnzrg2cmn9xxadcqh4szbpg0jggkhdkdzz4wa"))
- (patches
- (search-patches "sbcl-burgled-batteries3-fix-signals.patch"))))
+ (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
- #: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\".*") "")))))))
+ #:asd-systems '("cl-graph" "cl-graph+hu.dwim.graphviz")))
(native-inputs
- (list sbcl-cl-fad sbcl-lift sbcl-cl-quickcheck))
+ (list sbcl-lift sbcl-moptilities))
(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.")
+ (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
- "Bind extends the idea of of let and destructing to provide a uniform
-syntax for all your accessor needs. It combines @code{let},
-@code{destructuring-bind}, @code{with-slots}, @code{with-accessors}, structure
-editing, property or association-lists, and @code{multiple-value-bind} and a
-whole lot more into a single form.")
- (home-page "https://common-lisp.net/project/metabang-bind/")
- ;; MIT License
+ "This package provides a Common Lisp library for manipulating graphs
+and running graph algorithms.")
(license license:expat))))
-(define-public cl-metabang-bind
- (sbcl-package->cl-source-package sbcl-metabang-bind))
+(define-public cl-cl-graph
+ (sbcl-package->cl-source-package sbcl-cl-graph))
-(define-public ecl-metabang-bind
- (sbcl-package->ecl-package sbcl-metabang-bind))
+;; NOTE: (Sharlatan-20221118T214734+0000): No ECL support
+;;
+;; ecl-cl-graph
-(define-public sbcl-fare-csv
- (let ((commit "f877a238dcbf587a89359cccf2128919a94a348c")
+(define-public sbcl-cl-grnm
+ (let ((commit "778a312e9eb3d3de7541457b516ea3d9055a15aa")
(revision "0"))
(package
- (name "sbcl-fare-csv")
- (version (git-version "1.0.4" revision commit))
+ (name "sbcl-cl-grnm")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/frideau/fare-csv")
+ (url "https://github.com/quil-lang/cl-grnm")
(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))
+ (file-name (git-file-name "cl-grnm" version))
(sha256
- (base32
- "01wsr1aap3jdzhn4hrqjbhsjx6qci9dbd3gh4gayv1p49rbg8aqr"))))
+ (base32 "1hb5n37n3x2ylrghcqsia2g9a6f5wg24l659jiz4ncpi5bsv4m3s"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.stefil))
- (synopsis "Collection of utilities and data structures")
+ (synopsis "Common Lisp implementation of (grid restrained) Nelder-Mead")
(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
+ "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-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 cl-grnm
+ (sbcl-package->cl-source-package sbcl-cl-grnm))
-(define-public ecl-fare-mop
- (sbcl-package->ecl-package sbcl-fare-mop))
+(define-public ecl-cl-grnm
+ (sbcl-package->ecl-package sbcl-cl-grnm))
-(define-public cl-fare-mop
- (sbcl-package->cl-source-package sbcl-fare-mop))
+(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")
-(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))))
+ ;; 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 ecl-inferior-shell
- (sbcl-package->ecl-package sbcl-inferior-shell))
+(define-public cl-gserver
+ (sbcl-package->cl-source-package sbcl-cl-gserver))
-(define-public cl-inferior-shell
- (sbcl-package->cl-source-package sbcl-inferior-shell))
+(define-public ecl-cl-gserver
+ (sbcl-package->ecl-package sbcl-cl-gserver))
(define-public sbcl-cl-gss
(let ((commit "60086f4fd3b82316352e7f2288edbd58f03e08c5")
@@ -8460,213 +5843,120 @@ 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 ecl-cl-gss
- (sbcl-package->ecl-package sbcl-cl-gss))
-
(define-public cl-gss
(sbcl-package->cl-source-package sbcl-cl-gss))
-(define-public sbcl-trivial-utf-8
- (let ((commit "6ca9943588cbc61ad22a3c1ff81beb371e122394")
- (revision "2"))
+(define-public ecl-cl-gss
+ (sbcl-package->ecl-package sbcl-cl-gss))
+
+(define-public sbcl-cl-gtk4
+ (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4")
+ (revision "1"))
(package
- (name "sbcl-trivial-utf-8")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-gtk4")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url (string-append "https://gitlab.common-lisp.net/"
- "trivial-utf-8/trivial-utf-8.git"))
- (commit commit)))
- (file-name (git-file-name "cl-trivial-utf-8" version))
+ (uri (git-reference
+ (url "https://github.com/bohonghuang/cl-gtk4")
+ (commit commit)))
+ (file-name (git-file-name "cl-gtk4" version))
(sha256
- (base32 "0gzgbyzbbhny5y1lq2x82vfy4b4p1snq1sy9lj82hdq7lkyj03ss"))))
- (arguments
- ;; Guix incorrectly assumes the "8" is part of the version
- ;; number and lobs it off.
- `(#:asd-systems '("trivial-utf-8")))
+ (base32 "0mprmmvbagnflvhynn51l42nbwr08rld99ls0c48m5lpjn0ja4zc"))))
(build-system asdf-build-system/sbcl)
- (synopsis "UTF-8 input/output library")
+ (arguments
+ '(#:asd-systems '("cl-gtk4" "cl-gdk4")))
+ ;; propagate because it at least requires the typelib files at runtime
+ (propagated-inputs (list gtk))
+ (inputs
+ (list gobject-introspection
+ sbcl-cl-glib
+ sbcl-cl-gobject-introspection-wrapper))
+ (home-page "https://github.com/bohonghuang/cl-gtk4")
+ (synopsis "GTK4 bindings for Common Lisp")
(description
- "The Babel library solves a similar problem while understanding more
-encodings. Trivial UTF-8 was written before Babel existed, but for new
-projects you might be better off going with Babel. The one plus that Trivial
-UTF-8 has is that it doesn't depend on any other libraries.")
- (home-page "https://common-lisp.net/project/trivial-utf-8/")
- (license license:bsd-3))))
+ "This library provides GTK4 bindings for Common Lisp via Gobject
+Introspection, in the cl-gtk4 ASDF system.")
+ (license license:lgpl3))))
-(define-public cl-trivial-utf-8
- (sbcl-package->cl-source-package sbcl-trivial-utf-8))
+(define-public cl-gtk4
+ (sbcl-package->cl-source-package sbcl-cl-gtk4))
-(define-public ecl-trivial-utf-8
- (sbcl-package->ecl-package sbcl-trivial-utf-8))
+(define-public ecl-cl-gtk4
+ (sbcl-package->ecl-package sbcl-cl-gtk4))
-(define-public sbcl-trivial-utilities
- (let ((commit "279ff255562628196942632c543d91c357067221")
- (revision "0"))
+(define-public sbcl-cl-hamt
+ ;; No release
+ (let ((commit "7a99eaaca1f952029def9ad5a2b80a612a712208"))
(package
- (name "sbcl-trivial-utilities")
- (version (git-version "0.4.0" revision commit))
+ (name "sbcl-cl-hamt")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/ediethelm/trivial-utilities")
+ (url "https://github.com/danshapero/cl-hamt/")
(commit commit)))
- (file-name (git-file-name "trivial-utilities" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0k1xmn5f5dik7scadw0vyy67mik4ypnfqbhlv2vsg9afxzbpx2dz"))))
+ (base32 "1ycbd73ykfj5j9sdhlzamyv18qbjj6xqf7fhm4fa0nsyr6sr3rf5"))))
(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")
+ (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 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))))
+ "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-trivial-utilities
- (sbcl-package->cl-source-package sbcl-trivial-utilities))
+(define-public cl-hamt
+ (sbcl-package->cl-source-package sbcl-cl-hamt))
-(define-public ecl-trivial-utilities
- (sbcl-package->ecl-package sbcl-trivial-utilities))
+(define-public ecl-cl-hamt
+ (sbcl-package->ecl-package sbcl-cl-hamt))
-(define-public sbcl-idna
+(define-public sbcl-cl-heap
(package
- (name "sbcl-idna")
- (build-system asdf-build-system/sbcl)
- (version "0.2.2")
- (home-page "https://github.com/antifuchs/idna")
+ (name "sbcl-cl-heap")
+ (version "0.1.6")
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit version)))
- (file-name (git-file-name name version))
+ (method url-fetch)
+ (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
+ "cl-heap_" version ".tar.gz"))
(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")
+ "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
(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"))))
- (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))))
+ (list sbcl-xlunit))
+ (arguments
+ '(#:asd-test-systems '("cl-heap-tests")))
+ (synopsis "Heap and priority queue data structures for Common Lisp")
+ (description
+ "CL-HEAP provides various implementations of heap data structures (a
+binary heap and a Fibonacci heap) as well as an efficient priority queue.")
+ (home-page "https://common-lisp.net/project/cl-heap/")
+ (license license:gpl3+)))
-(define-public cl-iolib
- (let ((parent (sbcl-package->cl-source-package sbcl-iolib)))
- (package
- (inherit parent)
- (propagated-inputs
- ;; Need header to compile.
- (modify-inputs (package-propagated-inputs parent)
- (prepend libfixposix))))))
+(define-public cl-heap
+ (sbcl-package->cl-source-package sbcl-cl-heap))
-(define-public ecl-iolib
- (sbcl-package->ecl-package sbcl-iolib))
+(define-public ecl-cl-heap
+ (sbcl-package->ecl-package sbcl-cl-heap))
-(define-public sbcl-ieee-floats
- (let ((commit "566b51a005e81ff618554b9b2f0b795d3b29398d")
+(define-public sbcl-cl-hooks
+ (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
(revision "1"))
(package
- (name "sbcl-ieee-floats")
+ (name "sbcl-cl-hooks")
(build-system asdf-build-system/sbcl)
- (version (git-version "20170924" revision commit))
- (home-page "https://github.com/marijnh/ieee-floats/")
+ (version (git-version "0.2.1" revision commit))
+ (home-page "https://github.com/scymtym/architecture.hooks")
(source
(origin
(method git-fetch)
@@ -8676,3923 +5966,4094 @@ and @code{kqueue(2)}), a pathname library and file-system utilities.")
(file-name (git-file-name name version))
(sha256
(base32
- "1xyj49j9x3lc84cv3dhbf9ja34ywjk1c46dklx425fxw9mkwm83m"))))
+ "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
+ (inputs
+ (list sbcl-alexandria sbcl-let-plus sbcl-trivial-garbage
+ sbcl-closer-mop))
(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))))
+ (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-ieee-floats
- (sbcl-package->cl-source-package sbcl-ieee-floats))
+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-ieee-floats
- (sbcl-package->ecl-package sbcl-ieee-floats))
+@itemize
-(define sbcl-closure-common
- (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
- (revision "1"))
+@item There can be only one method for each combination of specializers and
+qualifiers. As a result this kind of extension point cannot be used by
+multiple extensions independently.
+@item Removing code previously attached via a @code{:before}, @code{:after} or
+@code{:around} method can be cumbersome.
+@item There could be other or even multiple extension points besides @code{:before}
+and @code{:after} in a single method.
+@item Attaching codes to individual objects using eql specializers can be
+cumbersome.
+@item Introspection of code attached a particular extension point is
+cumbersome since this requires enumerating and inspecting the methods of a
+generic function.
+@end itemize
+
+This library tries to complement some of these weaknesses of method-based
+extension-points via the concept of hooks.")
+ (license license:llgpl))))
+
+(define-public cl-hooks
+ (sbcl-package->cl-source-package sbcl-cl-hooks))
+
+(define-public ecl-cl-hooks
+ (sbcl-package->ecl-package sbcl-cl-hooks))
+
+(define-public sbcl-cl-html-diff
+ (let ((commit "5a0b39d1c524278d6f60851d7786bb2585614310")
+ (revision "0"))
(package
- (name "sbcl-closure-common")
- (build-system asdf-build-system/sbcl)
- (version (git-version "20101006" revision commit))
- (home-page "https://common-lisp.net/project/cxml/")
+ (name "sbcl-cl-html-diff")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/closure-common")
+ (url "https://github.com/wiseman/cl-html-diff")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name
+ (git-file-name name version))
(sha256
- (base32
- "0k5r2qxn122pxi301ijir3nayi9sg4d7yiy276l36qmzwhp4mg5n"))))
+ (base32 "1varnijivzd4jpimn1cz8p5ks713zzha5cgl4vmb0xr8ahravwzb"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("babel" ,sbcl-babel)))
- (synopsis "Support Common Lisp library for CXML")
- (description "Closure-common is an internal helper library. The name
-Closure is a reference to the web browser it was originally written for.")
- ;; TODO: License?
- (license #f))))
+ (list sbcl-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 sbcl-cxml
- (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
+(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-cxml")
+ (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/sharplispers/cxml")
+ (url "https://github.com/rotatef/cl-html5-parser")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-html5-parser" version))
(sha256
- (base32
- "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
+ (base32 "04if61wigylsmn996rbfl8ylsd0d9hzdmg7p2wiglncibjzcl5k9"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-closure-common sbcl-puri sbcl-trivial-gray-streams))
- (synopsis "Common Lisp XML parser")
- (description "CXML implements a namespace-aware, validating XML 1.0
-parser as well as the DOM Level 2 Core interfaces. Two parser interfaces are
-offered, one SAX-like, the other similar to StAX.")
- (home-page "https://common-lisp.net/project/cxml/")
- (license license:llgpl))))
+ (native-inputs
+ (list sbcl-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 cl-cxml
- (sbcl-package->cl-source-package sbcl-cxml))
+(define-public cl-html5-parser
+ (sbcl-package->cl-source-package sbcl-cl-html5-parser))
-(define-public ecl-cxml
- (sbcl-package->ecl-package sbcl-cxml))
+(define-public ecl-cl-html5-parser
+ (sbcl-package->ecl-package sbcl-cl-html5-parser))
-(define-public sbcl-cxml-rng
- (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b")
- (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-cxml-rng")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-https-everywhere")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "http://www.lichteblau.com/git/cxml-rng.git")
+ (url "https://github.com/ruricolist/cl-https-everywhere/")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql"))))
+ (base32 "1wcvx1icwym1ncd6wl1wxzkyyndrm796caalbklvjd4a2cbl3xxi"))))
(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))
+ (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+)))))
-;; FIXME: Fails on ECL with
-;; In function STRUCTURE-SET, the value of the first argument is
-;; #<empty 0x7fffeb0fd440>
-;; which is not of the expected type %TYPED-PATTERN.
-;; (define-public ecl-cxml-rng
-;; (sbcl-package->ecl-package sbcl-cxml-rng))
+(define-public cl-https-everywhere
+ (sbcl-package->cl-source-package sbcl-cl-https-everywhere))
-(define-public sbcl-cl-reexport
- (let ((commit "03ad7a0e7307e510b3b25a622d3c5f8a077879b4")
- (revision "2"))
+(define-public sbcl-cl-i18n
+ (let ((commit "acb162a12dac50fc46d83da8934fce85d19e31c4")
+ (revision "3"))
(package
- (name "sbcl-cl-reexport")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/takagi/cl-reexport")
+ (name "sbcl-cl-i18n")
+ (version (git-version "0.5.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/takagi/cl-reexport")
+ (url "https://codeberg.org/cage/cl-i18n")
(commit commit)))
- (file-name (git-file-name "cl-reexport" version))
+ (file-name (git-file-name "cl-i18n" version))
(sha256
- (base32
- "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc"))))
+ (base32 "1y29cirmlyc406a45sdx39spvnjzbs772c977075ccicz46qaxz7"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria))
- (native-inputs
- (list sbcl-prove))
- (synopsis "Reexport external symbols in other Common Lisp packages")
+ (list sbcl-alexandria sbcl-babel sbcl-cl-ppcre-unicode))
+ (synopsis "Internationalisation framework 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.")
+ "This is a Gettext-style internationalisation framework for Common
+Lisp.")
+ (home-page "https://codeberg.org/cage/cl-i18n")
(license license:llgpl))))
-(define-public cl-reexport
- (sbcl-package->cl-source-package sbcl-cl-reexport))
+(define-public cl-i18n
+ (sbcl-package->cl-source-package sbcl-cl-i18n))
-(define-public ecl-cl-reexport
- (sbcl-package->ecl-package sbcl-cl-reexport))
+(define-public ecl-cl-i18n
+ (sbcl-package->ecl-package sbcl-cl-i18n))
-(define-public sbcl-cl-cookie
- (let ((commit "cea55aed8b9ad25fafd13defbcb9fe8f41b29546")
- (revision "1"))
+(define-public sbcl-cl-indentify
+ (let ((commit "eb770f434defa4cd41d84bca822428dfd0dbac53"))
(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")
+ (name "sbcl-cl-indentify")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/yitzchak/cl-indentify")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name name commit))
(sha256
- (base32
- "090g7z75h98zvc1ldx0vh4jn4086dhjm2w30jcwkq553qmyxwl8h"))))
+ (base32 "0ha36bhg474vr76vfhr13szc8cfdj1ickg92k1icz791bqaqg67p"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("proc-parse" ,sbcl-proc-parse)
- ("alexandria" ,sbcl-alexandria)
- ("quri" ,sbcl-quri)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)))
+ (list sbcl-alexandria sbcl-command-line-arguments
+ sbcl-trivial-gray-streams))
(native-inputs
- (list sbcl-prove))
- (arguments
- '(#:asd-systems '("cl-cookie-test" "cl-cookie")))
- (synopsis "HTTP cookie manager for Common Lisp")
- (description "cl-cookie is a Common Lisp library featuring parsing of
-cookie headers, cookie creation, cookie jar creation and more.")
- (license license:bsd-2))))
+ (list sbcl-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-cookie
- (sbcl-package->cl-source-package sbcl-cl-cookie))
+(define-public cl-indentify
+ (sbcl-package->cl-source-package sbcl-cl-indentify))
-(define-public ecl-cl-cookie
- (sbcl-package->ecl-package sbcl-cl-cookie))
+(define-public ecl-cl-indentify
+ (sbcl-package->ecl-package sbcl-cl-indentify))
-(define-public sbcl-dexador
- (let ((commit "051cbb784ea3015cef9731eb5a624f3122de84b5")
- (revision "2"))
+(define-public sbcl-cl-inflector
+ (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
+ (revision "1"))
(package
- (name "sbcl-dexador")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.9.15" revision commit))
- (home-page "https://github.com/fukamachi/dexador")
+ (name "sbcl-cl-inflector")
+ (version (git-version "0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/AccelerationNet/cl-inflector")
(commit commit)))
- (file-name (git-file-name "cl-dexador" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1sggpi43la8dai102fmkzysh7760hvk6q68f0pkbb9187vz8nd3y"))))
+ (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lisp-unit2))
(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.")
+ (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-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-inflector
+ (sbcl-package->cl-source-package sbcl-cl-inflector))
-(define-public ecl-dexador
- (sbcl-package->ecl-package sbcl-dexador))
+(define-public ecl-cl-inflector
+ (sbcl-package->ecl-package sbcl-cl-inflector))
-(define-public sbcl-lisp-namespace
- (let ((commit "699fccb6727027343bb5fca69162a3113996edfc")
- (revision "2"))
+(define-public sbcl-cl-ini
+ (let ((commit "e630acb405022a7ae11969bf908669fee1191ab7")
+ (revision "0"))
(package
- (name "sbcl-lisp-namespace")
- (build-system asdf-build-system/sbcl)
+ (name "sbcl-cl-ini")
(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)
+ (url "https://github.com/compufox/cl-ini")
(commit commit)))
- (file-name (git-file-name "cl-lisp-namespace" version))
+ (file-name (git-file-name "sbcl-cl-ini" 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))))
+ (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-lisp-namespace
- (sbcl-package->cl-source-package sbcl-lisp-namespace))
+(define-public cl-ini
+ (sbcl-package->cl-source-package sbcl-cl-ini))
-(define-public ecl-lisp-namespace
- (sbcl-package->ecl-package sbcl-lisp-namespace))
+(define-public ecl-cl-ini
+ (sbcl-package->ecl-package sbcl-cl-ini))
-(define-public sbcl-trivial-cltl2
- (let ((commit "8a3bda30dc25d2f65fcf514d0eb6e6db75252c61")
- (revision "2"))
+(define-public sbcl-cl-inotify
+ (let ((commit "66f29e01ec28355ebba8292411b4de90eebd76a3")
+ (revision "0"))
(package
- (name "sbcl-trivial-cltl2")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1.1" revision commit))
- (home-page "https://github.com/Zulu-Inuoe/trivial-cltl2")
+ (name "sbcl-cl-inotify")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (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
- "08cnzb9rnczn4pn2zpf0587ny4wjy1mjndy885fz9pw7xrlx37ip"))))
- (synopsis "Simple CLtL2 compatibility layer for Common Lisp")
- (description "This library is a portable compatibility layer around
-\"Common Lisp the Language, 2nd
-Edition\" (@url{https://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node102.html})
-and it exports symbols from implementation-specific packages.")
- (license license:llgpl))))
+ (base32 "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-trivial-cltl2
- (sbcl-package->cl-source-package sbcl-trivial-cltl2))
+(define-public cl-inotify
+ (sbcl-package->cl-source-package sbcl-cl-inotify))
-(define-public ecl-trivial-cltl2
- (sbcl-package->ecl-package sbcl-trivial-cltl2))
+(define-public ecl-cl-inotify
+ (sbcl-package->ecl-package sbcl-cl-inotify))
-(define-public sbcl-introspect-environment
- (let ((commit "8fb20a1a33d29637a22943243d1482a20c32d6ae")
- (revision "2"))
+(define-public sbcl-cl-interpol
+ (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa")
+ (revision "1"))
(package
- (name "sbcl-introspect-environment")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/Bike/introspect-environment")
+ (name "sbcl-cl-interpol")
+ (version (git-version "0.2.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/edicl/cl-interpol")
(commit commit)))
- (file-name (git-file-name "cl-introspect-environment" version))
+ (file-name (git-file-name "cl-interpol" version))
(sha256
- (base32 "1p48jnr1im47529w0ciyar4hfwbivqi57zgllkmfrav09ffigk9s"))))
+ (base32
+ "1kr00zf62m7la7rxa2m5w49r9cyzamc106hvjcc8ffmi7a4jw490"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-cl-unicode sbcl-named-readtables))
(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.
+ (list sbcl-flexi-streams))
+ (synopsis "String interpolation for Common Lisp")
+ (description
+ "CL-INTERPOL is a library for Common Lisp which modifies the
+reader so that you can have interpolation within strings similar to
+Perl or Unix Shell scripts. It also provides various ways to insert
+arbitrary characters into literal strings even if your editor/IDE
+doesn't support them.")
+ (home-page "https://edicl.github.io/cl-interpol/")
+ (license license:bsd-3))))
-Quite a bit of information is available at the time a macro or compiler-macro
-runs; inlining info, type declarations, that sort of thing. This information
-is all standard - any Common Lisp program can @code{(declare (integer x))} and
-such.
+(define-public cl-interpol
+ (sbcl-package->cl-source-package sbcl-cl-interpol))
-This info ought to be accessible through the standard @code{&environment}
-parameters, but it is not. Several implementations keep the information for
-their own purposes but do not make it available to user programs, because
-there is no standard mechanism to do so.
+(define-public ecl-cl-interpol
+ (sbcl-package->ecl-package sbcl-cl-interpol))
-This library uses implementation-specific hooks to make information available
-to users. This is currently supported on SBCL, CCL, and CMUCL. Other
-implementations have implementations of the functions that do as much as they
-can and/or provide reasonable defaults.")
- (license license:wtfpl2))))
+(define-public sbcl-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-introspect-environment
- (sbcl-package->cl-source-package sbcl-introspect-environment))
+(define-public cl-ipfs-api2
+ (sbcl-package->cl-source-package sbcl-cl-ipfs-api2))
-(define-public ecl-introspect-environment
- (sbcl-package->ecl-package sbcl-introspect-environment))
+(define-public ecl-cl-ipfs-api2
+ (sbcl-package->ecl-package sbcl-cl-ipfs-api2))
-(define-public sbcl-compiler-macro
- (let ((commit "7796bda64aec5af3ca175170ad3565167868789c")
+(define-public sbcl-cl-irc
+ (let ((commit "963823537c7bfcda2edd4c44d172192da6722175")
(revision "0"))
(package
- (name "sbcl-compiler-macro")
- (version (git-version "0.1" 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/Bike/compiler-macro")
+ (url "https://salsa.debian.org/common-lisp-team/cl-irc.git")
(commit commit)))
- (file-name (git-file-name "cl-compiler-macro" version))
+ (file-name (git-file-name "cl-irc" version))
(sha256
- (base32 "13sswps7s0qy6939mvj8q57hkx0qkga6rl6xjhjr7pk7by0xdsjq"))))
+ (base32 "1b3nqbb4pj377lxl47rfgrs82pidadnrc65l48bk553c2f59b52w"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
+ (list sbcl-rt))
(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))))
+ `(("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-compiler-macro
- (sbcl-package->cl-source-package sbcl-compiler-macro))
+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-compiler-macro
- (sbcl-package->ecl-package sbcl-compiler-macro))
+(define-public cl-irc
+ (sbcl-package->cl-source-package sbcl-cl-irc))
-(define-public sbcl-type-i
- (let ((commit "d34440ab4ebf5a46a58deccb35950b15670e3667")
- (revision "2"))
+(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-type-i")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.1" revision commit))
- (home-page "https://github.com/guicho271828/type-i")
+ (name "sbcl-cl-isaac")
+ (version (git-version "1.0.7" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/thephoeron/cl-isaac")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-isaac" version))
(sha256
- (base32
- "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))))
+ (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-type-i
- (sbcl-package->cl-source-package sbcl-type-i))
+(define-public cl-isaac
+ (sbcl-package->cl-source-package sbcl-cl-isaac))
-(define-public ecl-type-i
- (package
- (inherit (sbcl-package->ecl-package sbcl-type-i))
- (arguments
- ;; The tests get stuck indefinitly
- '(#:tests? #f))))
+(define-public ecl-cl-isaac
+ (sbcl-package->ecl-package sbcl-cl-isaac))
-(define-public sbcl-simplified-types
- (let ((commit "8fd0727a70a9de76289ac62c1567b8d278e7434e")
- (revision "0"))
+(define-public sbcl-cl-jpeg
+ (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
+ (revision "1"))
(package
- (name "sbcl-simplified-types")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-jpeg")
+ (version (git-version "2.8" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/marcoheisig/simplified-types")
+ (url "https://github.com/sharplispers/cl-jpeg")
(commit commit)))
- (file-name (git-file-name "cl-simplified-types" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1hdwmn5lz717aj6qdqmfmr3cbjl8l3giwn0fb5ca9pj83cx7fg8y"))))
+ (base32 "1bkkiqz8fqldlj1wbmrccjsvxcwj98h6s4b6gslr3cg2wmdv5xmy"))))
(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")
+ (synopsis "JPEG image library for Common Lisp")
(description
- "Simplified-Types is a library that provides functions for simplifying
-Common Lisp type specifiers. The API consists of two functions:
+ "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))))
-@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-jpeg
+ (sbcl-package->cl-source-package sbcl-cl-jpeg))
-(define-public cl-simplified-types
- (sbcl-package->cl-source-package sbcl-simplified-types))
+(define-public ecl-cl-jpeg
+ (sbcl-package->ecl-package sbcl-cl-jpeg))
-(define-public ecl-simplified-types
- (sbcl-package->ecl-package sbcl-simplified-types))
+(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 sbcl-typo
- (let ((commit "0e883490f81edf2a1be4e5b101d1caec78d7853b")
+(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-typo")
+ (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/marcoheisig/Typo")
+ (url "https://github.com/y2q-actionman/cl-json-pointer")
(commit commit)))
- (file-name (git-file-name "cl-typo" version))
+ (file-name (git-file-name "cl-json-pointer" version))
(sha256
- (base32 "08cmkjl3f77rfhxbjyd6f3kinhzak30mdfphnpf73sh1vw4v0vym"))))
+ (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-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.")
+ 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-typo
- (sbcl-package->cl-source-package sbcl-typo))
+(define-public cl-json-pointer
+ (sbcl-package->cl-source-package sbcl-cl-json-pointer))
-(define-public ecl-typo
- (sbcl-package->ecl-package sbcl-typo))
+(define-public ecl-cl-json-pointer
+ (sbcl-package->ecl-package sbcl-cl-json-pointer))
-(define-public sbcl-optima
- (let ((commit "373b245b928c1a5cce91a6cb5bfe5dd77eb36195")
+(define-public sbcl-cl-ledger
+ (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
(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")
+ (name "sbcl-cl-ledger")
+ (version (git-version "4.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/ledger/cl-ledger")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "1yw4ymq7ms89342kkvb3aqxgv0w38m9kd8ikdqxxzyybnkjhndal"))))
+ "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("closer-mop" ,sbcl-closer-mop)))
- (native-inputs
- (list sbcl-eos))
+ `(("cambl" ,sbcl-cambl)
+ ("cl-ppcre" ,sbcl-cl-ppcre)
+ ("local-time" ,sbcl-local-time)
+ ("periods" ,sbcl-periods)))
(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))))
+ '(#: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-optima
- (sbcl-package->cl-source-package sbcl-optima))
+(define-public cl-ledger
+ (sbcl-package->cl-source-package sbcl-cl-ledger))
-(define-public ecl-optima
- (sbcl-package->ecl-package sbcl-optima))
+(define-public ecl-cl-ledger
+ (sbcl-package->ecl-package sbcl-cl-ledger))
-(define-public sbcl-fare-quasiquote
- (let ((commit "640d39a0451094071b3e093c97667b3947f43639")
+(define-public sbcl-cl-lex
+ (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
(revision "1"))
(package
- (name "sbcl-fare-quasiquote")
- (build-system asdf-build-system/sbcl)
- (version (git-version "1.0.1" revision commit))
- (home-page "https://gitlab.common-lisp.net/frideau/fare-quasiquote")
+ (name "sbcl-cl-lex")
+ (version (git-version "1.1.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url (string-append "https://gitlab.common-lisp.net/frideau/"
- "fare-quasiquote.git"))
+ (url "https://github.com/djr7C4/cl-lex")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1g6q11l50kgija9f55lzqpcwvaq0ljiw8v1j265hnyg6nahjwjvg"))))
+ (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
+ (build-system asdf-build-system/sbcl)
(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))))
+ (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-fare-quasiquote
- (sbcl-package->cl-source-package sbcl-fare-quasiquote))
+(define-public cl-lex
+ (sbcl-package->cl-source-package sbcl-cl-lex))
-(define-public ecl-fare-quasiquote
- (sbcl-package->ecl-package sbcl-fare-quasiquote))
+(define-public ecl-cl-lex
+ (sbcl-package->ecl-package sbcl-cl-lex))
-;;; Split the trivia package in two to work around the circular dependency
-;;; between guicho271828/trivia and guicho271828/type-i.
-(define-public sbcl-trivia.trivial
- (let ((commit "8b406c3f83521d290e97bb787d3f6c1eb3b716af")
- (revision "0"))
+(define-public sbcl-cl-liballegro
+ (let ((commit "49f632ce97fc4f835bf5d450588793234b980a64")
+ (revision "1"))
(package
- (name "sbcl-trivia.trivial")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-cl-liballegro")
+ (version (git-version "0.2.15" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/trivia")
+ (url "https://github.com/resttime/cl-liballegro")
(commit commit)))
- (file-name (git-file-name "cl-trivia" version))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "0fnnjnba07qrsf82jm4q6dini7z72xabcssy5y2bqy082r07l8l7"))))
+ (base32 "0brbr7i342s0gadlnzd3a61w2b9ihhx60l19ararnc2asvyhmz7x"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-alexandria
- sbcl-closer-mop
- sbcl-lisp-namespace
- sbcl-trivial-cltl2))
(arguments
- '(#:phases
+ `(#: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)))
+ (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 cl-str
- (sbcl-package->cl-source-package sbcl-cl-str))
+(define-public cl-liballegro
+ (sbcl-package->cl-source-package sbcl-cl-liballegro))
-(define-public ecl-cl-str
- (sbcl-package->ecl-package sbcl-cl-str))
+(define-public ecl-cl-liballegro
+ (sbcl-package->ecl-package sbcl-cl-liballegro))
-(define-public sbcl-cl-xmlspam
- (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
+(define-public sbcl-cl-libsvm-format
+ (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
+ (revision "0"))
(package
- (name "sbcl-cl-xmlspam")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.0.0" "1" commit))
- (home-page "https://github.com/rogpeppe/cl-xmlspam")
+ (name "sbcl-cl-libsvm-format")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/masatoi/cl-libsvm-format")
(commit commit)))
- (file-name (string-append name "-" version))
+ (file-name (git-file-name name version))
(sha256
(base32
- "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
+ "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-prove))
(inputs
- (list sbcl-cxml sbcl-cl-ppcre))
- (synopsis "Concise, regexp-like pattern matching on streaming XML for Common Lisp")
- (description "CXML does an excellent job at parsing XML elements, but what
-do you do when you have a XML file that's larger than you want to fit in
-memory, and you want to extract some information from it? Writing code to deal
-with SAX events, or even using Klacks, quickly becomes tedious.
-@code{cl-xmlspam} (for XML Stream PAttern Matcher) is designed to make it easy
-to write code that mirrors the structure of the XML that it's parsing. It
-also makes it easy to shift paradigms when necessary - the usual Lisp control
-constructs can be used interchangeably with pattern matching, and the full
-power of CXML is available when necessary.")
- (license license:bsd-3))))
+ (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-xmlspam
- (sbcl-package->cl-source-package sbcl-cl-xmlspam))
+(define-public cl-libsvm-format
+ (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
-(define-public ecl-cl-xmlspam
- (sbcl-package->ecl-package sbcl-cl-xmlspam))
+(define-public ecl-cl-libsvm-format
+ (sbcl-package->ecl-package sbcl-cl-libsvm-format))
-(define-public sbcl-dbus
- (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
+(define-public sbcl-cl-libuv
+ (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
(revision "1"))
(package
- (name "sbcl-dbus")
- (version (git-version "20190408" revision commit))
- (home-page "https://github.com/death/dbus")
+ (name "sbcl-cl-libuv")
+ (version (git-version "0.1.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/orthecreedence/cl-libuv")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
+ "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
(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))))
+ `(("alexandria" ,sbcl-alexandria)
+ ("cffi" ,sbcl-cffi)
+ ("libuv" ,libuv)))
+ (arguments
+ `(#:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "lib.lisp"
+ (("/usr/lib/libuv.so")
+ (search-input-file inputs "/lib/libuv.so")))))
+ (add-after 'fix-paths 'fix-system-definition
+ (lambda _
+ (substitute* "cl-libuv.asd"
+ (("#:cffi #:alexandria")
+ "#:cffi #:cffi-grovel #:alexandria"))
+ #t)))))
+ (synopsis "Common Lisp bindings to libuv")
+ (description
+ "This library provides low-level libuv bindings for Common Lisp.")
+ (home-page "https://github.com/orthecreedence/cl-libuv")
+ (license license:expat))))
-(define-public cl-dbus
- (sbcl-package->cl-source-package sbcl-dbus))
+(define-public cl-libuv
+ (sbcl-package->cl-source-package sbcl-cl-libuv))
-(define-public ecl-dbus
- (sbcl-package->ecl-package sbcl-dbus))
+(define-public ecl-cl-libuv
+ (sbcl-package->ecl-package sbcl-cl-libuv))
-(define-public sbcl-cl-hooks
- (let ((commit "5b638083f3b4f1221a52631d9c8a0a265565cac7")
- (revision "1"))
+(define-public sbcl-cl-libxml2
+ (let ((commit "8d03110c532c1a3fe15503fdfefe82f60669e4bd"))
(package
- (name "sbcl-cl-hooks")
- (build-system asdf-build-system/sbcl)
- (version (git-version "0.2.1" revision commit))
- (home-page "https://github.com/scymtym/architecture.hooks")
+ (name "sbcl-cl-libxml2")
+ (version (git-version "0.3.4" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/archimag/cl-libxml2")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-libxml2" version))
(sha256
- (base32
- "0bg3l0a28lw5gqqjp6p6b5nhwqk46sgkb7184w5qbfngw1hk8x9y"))))
+ (base32 "09049c13cfp5sc6x9lrw762jd7a9qkfq5jgngqgrzn4kn9qscarw"))))
+ (build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-let-plus sbcl-trivial-garbage
- sbcl-closer-mop))
+ `(("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-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:
+ (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 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.")
+@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-hooks
- (sbcl-package->cl-source-package sbcl-cl-hooks))
+(define-public cl-libxml2
+ (sbcl-package->cl-source-package sbcl-cl-libxml2))
-(define-public ecl-cl-hooks
- (sbcl-package->ecl-package sbcl-cl-hooks))
+(define-public ecl-cl-libxml2
+ (sbcl-package->ecl-package sbcl-cl-libxml2))
-(define-public sbcl-cl-autowrap
- (let ((revision "2")
- (commit "a5d71ebd7c21b87f449db1e16ab815750d7c0ea4"))
- ;; no taged branches
+(define-public sbcl-cl-libyaml
+ (let ((commit "a7fe9f68bddfd00b7ca467b65b3b41b276336843")
+ (revision "1"))
(package
- (name "sbcl-cl-autowrap")
- (version (git-version "1.0" revision commit))
+ (name "sbcl-cl-libyaml")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/cl-autowrap")
+ (url "https://github.com/eudoxia0/cl-libyaml")
(commit commit)))
- (file-name (git-file-name "cl-autowrap" version))
+ (file-name (git-file-name "cl-libyaml" version))
(sha256
- (base32 "0795c817m1c41cz3ywzzg83z4pgkxdg6si553pay9mdgjvmrwmaw"))))
+ (base32
+ "06pvmackyhq03rjmihpx6w63m6cy8wx78ll5xpwwvd85bgrqq817"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("cl-plus-c" "cl-autowrap")))
+ (native-inputs
+ (list sbcl-fiveam))
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("cl-json" ,sbcl-cl-json)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("defpackage-plus" ,sbcl-defpackage-plus)
- ("trivial-features" ,sbcl-trivial-features)))
- (home-page "https://github.com/rpav/cl-autowrap")
- (synopsis "FFI wrapper generator for Common Lisp")
- (description "This is a c2ffi-based wrapper generator for Common Lisp.")
- (license license:bsd-2))))
+ `(("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-autowrap
- (sbcl-package->cl-source-package sbcl-cl-autowrap))
+(define-public cl-libyaml
+ (sbcl-package->cl-source-package sbcl-cl-libyaml))
-(define-public ecl-cl-autowrap
- (sbcl-package->ecl-package sbcl-cl-autowrap))
+(define-public ecl-cl-libyaml
+ (sbcl-package->ecl-package sbcl-cl-libyaml))
-(define-public sbcl-s-sysdeps
- ;; No release since 2013.
- (let ((commit "7f8de283b7fbd8b038fdf08493063a736db36ce7")
- (revision "3"))
+(define-public sbcl-cl-locale
+ (let ((commit "0a36cc0dcf5e0a8c8bf97869cd6199980ca25eec")
+ (revision "1"))
(package
- (name "sbcl-s-sysdeps")
- (build-system asdf-build-system/sbcl)
- (version (git-version "1" revision commit))
- (home-page "https://github.com/svenvc/s-sysdeps")
+ (name "sbcl-cl-locale")
+ (version (git-version "0.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/fukamachi/cl-locale")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-locale" version))
(sha256
- (base32
- "0rp81iq0rgl48qdwbmfy89glga81hmry2lp8adjbr5h5ybr92b4n"))))
+ (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
- (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.
+ `(("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))))
-@code{s-sysdeps} abstracts:
+(define-public cl-locale
+ (sbcl-package->cl-source-package sbcl-cl-locale))
-@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 ecl-cl-locale
+ (sbcl-package->ecl-package sbcl-cl-locale))
-(define-public cl-s-sysdeps
- (sbcl-package->cl-source-package sbcl-s-sysdeps))
+(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 ecl-s-sysdeps
- (sbcl-package->ecl-package sbcl-s-sysdeps))
+(define-public cl-log
+ (sbcl-package->cl-source-package sbcl-cl-log))
-(define-public sbcl-cl-prevalence
- (let ((commit "e6b27640ce89ae5f8af38beb740e319bb6cd2368")
- (revision "6"))
+(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-prevalence")
- (build-system asdf-build-system/sbcl)
- (version (git-version "5" revision commit))
- (home-page "https://github.com/40ants/cl-prevalence")
+ (name "sbcl-cl-markdown")
+ (version (git-version "0.10.6" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/hraban/cl-markdown")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-markdown" version))
(sha256
- (base32
- "1lb957ivshgp56phqhvhsmnc4r55x5shvi3mpsan2xsm4hvqspp0"))))
- (inputs
- (list sbcl-moptilities sbcl-s-sysdeps sbcl-s-xml))
+ (base32 "1algqwmafipyf194cx9wfhg0pdx1ppx6s444p1pm8yaycbsyla1v"))))
+ (build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam sbcl-find-port))
- (synopsis "Implementation of object prevalence for Common Lisp")
- (description "This Common Lisp library implements object prevalence (see
-@url{https://en.wikipedia.org/wiki/System_prevalence}). It allows
-for (de)serializing to and from s-exps as well as XML. Serialization of arbitrary
-classes and cyclic data structures are supported.")
- (license license:llgpl))))
+ (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-prevalence
- (sbcl-package->cl-source-package sbcl-cl-prevalence))
+(define-public cl-markdown
+ (sbcl-package->cl-source-package sbcl-cl-markdown))
-(define-public ecl-cl-prevalence
- (sbcl-package->ecl-package sbcl-cl-prevalence))
+(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-series
- (let ((commit "da9061b336119d1e5214aff9117171d494d5a58a")
+(define-public sbcl-cl-markless
+ (let ((commit "a0e145c03103bd3bf7e275d5ac0e19e8381eb844")
(revision "1"))
(package
- (name "sbcl-series")
- (version (git-version "2.2.11" revision commit))
+ (name "sbcl-cl-markless")
+ (version (git-version "1.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "git://git.code.sf.net/p/series/series")
+ (url "https://github.com/Shirakumo/cl-markless")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-markless" version))
(sha256
- (base32
- "07hk2lhfx42zk018pxqvn4gs77vd4n4g8m4xxbqaxgca76mifwfw"))))
+ (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
- ;; 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))))
+ '(#: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-series
- (sbcl-package->cl-source-package sbcl-series))
+(define-public cl-markless
+ (sbcl-package->cl-source-package sbcl-cl-markless))
-(define-public ecl-series
- (sbcl-package->ecl-package sbcl-series))
+(define-public ecl-cl-markless
+ (sbcl-package->ecl-package sbcl-cl-markless))
-(define-public sbcl-periods
- (let ((commit "60383dcef88a1ac11f82804ae7a33c361dcd2949")
- (revision "2"))
+(define-public sbcl-cl-markup
+ (let ((commit "e0eb7debf4bdff98d1f49d0f811321a6a637b390"))
(package
- (name "sbcl-periods")
- (version (git-version "0.0.2" revision commit))
+ (name "sbcl-cl-markup")
+ (version (git-version "0.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jwiegley/periods")
+ (url "https://github.com/arielnetworks/cl-markup/")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-markup" version))
(sha256
(base32
- "1ym2j4an9ig2hl210jg91gpf7xfnp6mlhkw3n9kkdnwiji3ipqlk"))))
+ "10l6k45971dl13fkdmva7zc6i453lmq9j4xax2ci6pjzlc6xjhp7"))))
(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")
+ (home-page "https://github.com/arielnetworks/cl-markup/")
+ (synopsis "Markup generation library for Common Lisp")
(description
- "Periods is a Common Lisp library providing a set of utilities for
-manipulating times, distances between times, and both contiguous and
-discontiguous ranges of time.")
- (home-page "https://github.com/jwiegley/periods")
- (license license:bsd-3))))
+ "A modern markup generation library for Common Lisp that features:
-(define-public cl-periods
- (sbcl-package->cl-source-package sbcl-periods))
+@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 ecl-periods
- (sbcl-package->ecl-package sbcl-periods))
+(define-public cl-markup
+ (sbcl-package->cl-source-package sbcl-cl-markup))
-(define-public sbcl-metatilities-base
- (let ((commit "ef04337759972fd622c9b27b53149f3d594a841f")
- (revision "2"))
+(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-metatilities-base")
- (version (git-version "0.6.6" revision commit))
+ (name "sbcl-cl-mathstats")
+ (version (git-version "0.8.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/metatilities-base")
+ (url "https://github.com/hraban/cl-mathstats")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mathstats" version))
(sha256
- (base32
- "069rk5ncwvjnnzvvky6xiriynl72yzvjpnzl6jw9jf3b8na14zrk"))))
+ (base32 "0gsjvmkmnxc4hp5z9mkm5vsllywqyg7kx8jgz88vnx47yj3va1s8"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-lift))
- (synopsis "Core of the metatilities Common Lisp library")
+ (inputs
+ (list sbcl-cl-containers sbcl-metatilities-base))
+ (home-page "https://github.com/hraban/cl-mathstats")
+ (synopsis "Common Lisp collection of mathematical routines")
(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 Common Lisp math and statistics routines.")
(license license:expat))))
-(define-public cl-metatilities-base
- (sbcl-package->cl-source-package sbcl-metatilities-base))
+(define-public cl-mathstats
+ (sbcl-package->cl-source-package sbcl-cl-mathstats))
-(define-public ecl-metatilities-base
- (sbcl-package->ecl-package sbcl-metatilities-base))
+(define-public ecl-cl-mathstats
+ (sbcl-package->ecl-package sbcl-cl-mathstats))
-(define-public sbcl-cl-containers
- (let ((commit "781ebfe0888bae46f07c018f7d473898b1bd4f5f")
- (revision "4"))
+(define-public sbcl-cl-messagepack
+ (let ((commit "8ff2060ed20677feef8ac01558690df0aeac30b6")
+ (revision "0"))
(package
- (name "sbcl-cl-containers")
- (version (git-version "0.12.1" revision commit))
+ (name "sbcl-cl-messagepack")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hraban/cl-containers")
+ (url "https://github.com/mbrezu/cl-messagepack")
(commit commit)))
- (file-name (git-file-name "cl-containers" version))
+ (file-name (git-file-name "cl-messagepack" version))
(sha256
- (base32
- "1nrql8s1j123v5gscy99lxvhlzp0ijig9x94w30v3lwfa58hf90l"))))
+ (base32 "1hjd1q18lz46k46afz94ljflp76mfr30d6z4jrsgd26y2lc4gchc"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lift))
- (inputs
- (list sbcl-asdf-system-connections
- sbcl-metatilities-base
- sbcl-moptilities))
- (arguments
- '(#:asd-systems '("cl-containers"
- "cl-containers/with-moptilities"
- "cl-containers/with-utilities")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'relax-version-checks
- (lambda _
- (substitute* "cl-containers.asd"
- (("\\(:version \"metatilities-base\" \"0\\.6\\.6\"\\)")
- "\"metatilities-base\""))
- (substitute* "cl-containers-test.asd"
- (("\\(:version \"lift\" \"1\\.7\\.0\"\\)")
- "\"lift\""))
- #t)))))
- (synopsis "Container library for Common Lisp")
+ (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
- "Common Lisp ships with a set of powerful built in data structures
-including the venerable list, full featured arrays, and hash-tables.
-CL-containers enhances and builds on these structures by adding containers
-that are not available in native Lisp (for example: binary search trees,
-red-black trees, sparse arrays and so on), and by providing a standard
-interface so that they are simpler to use and so that changing design
-decisions becomes significantly easier.")
- (home-page "https://common-lisp.net/project/cl-containers/")
- (license license:expat))))
+ "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-containers
- (sbcl-package->cl-source-package sbcl-cl-containers))
+(define-public cl-messagepack
+ (sbcl-package->cl-source-package sbcl-cl-messagepack))
-(define-public ecl-cl-containers
- (sbcl-package->ecl-package sbcl-cl-containers))
+(define-public ecl-cl-messagepack
+ (sbcl-package->ecl-package sbcl-cl-messagepack))
-(define-public sbcl-cambl
- (let ((commit "7016d1a98215f82605d1c158e7a16504ca1f4636")
+(define-public sbcl-cl-mime
+ (let ((commit "d30a28e0a40393bd3af7d138daa05319ed2e9d07")
(revision "1"))
(package
- (name "sbcl-cambl")
- (version (git-version "4.0.0" revision commit))
+ (name "sbcl-cl-mime")
+ ;; One commit says "update to cl-mime-0.5.3", even though the .asd is at 0.5.1.
+ (version (git-version "0.5.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jwiegley/cambl")
+ ;; Maintained fork according to http://www.cliki.net/CL-MIME:
+ (url "https://github.com/40ants/cl-mime")
(commit commit)))
- (file-name (git-file-name "cambl" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "103mry04j2k9vznsxm7wcvccgxkil92cdrv52miwcmxl8daa4jiz"))))
+ (base32 "0qn8if0fj6vzc897pqqqs0m1y107gmzqngpqhqmwrcsp1ckj5k0v"))))
(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")
+ (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
- "CAMBL is a Common Lisp library providing a convenient facility for
-working with commoditized values. It does not allow compound units (and so is
-not suited for scientific operations) but does work rather nicely for the
-purpose of financial calculations.")
- (home-page "https://github.com/jwiegley/cambl")
- (license license:bsd-3))))
+ "This 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-cambl
- (sbcl-package->cl-source-package sbcl-cambl))
+(define-public cl-mime
+ (sbcl-package->cl-source-package sbcl-cl-mime))
-(define-public ecl-cambl
- (sbcl-package->ecl-package sbcl-cambl))
+(define-public ecl-cl-mime
+ (sbcl-package->ecl-package sbcl-cl-mime))
-(define-public sbcl-cl-ledger
- (let ((commit "08e0be41795e804cd36142e51756ad0b1caa377b")
- (revision "1"))
+(define-public sbcl-cl-mimeparse
+ (let ((commit "93cbdf6f6fe8a2eb5f652f8adec453eb98ea0547")
+ (revision "0"))
(package
- (name "sbcl-cl-ledger")
- (version (git-version "4.0.0" revision commit))
+ (name "sbcl-cl-mimeparse")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ledger/cl-ledger")
+ (url "https://github.com/mmontone/cl-mimeparse")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mimeparse" version))
(sha256
- (base32
- "1via0qf6wjcyxnfbmfxjvms0ik9j8rqbifgpmnhrzvkhrq9pv8h1"))))
+ (base32 "0gdkpi3620va0a3q56svcn1q9f5w0pqfhx30lnldg8fjnrdfiwkk"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("cambl" ,sbcl-cambl)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("local-time" ,sbcl-local-time)
- ("periods" ,sbcl-periods)))
(arguments
- '(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-system-definition
- (lambda _
- (substitute* "cl-ledger.asd"
- ((" :build-operation program-op") "")
- ((" :build-pathname \"cl-ledger\"") "")
- ((" :entry-point \"ledger::main\"") ""))
- #t)))))
- (synopsis "Common Lisp port of the Ledger accounting system")
+ '(#: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
- "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))))
+ "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-ledger
- (sbcl-package->cl-source-package sbcl-cl-ledger))
+(define-public cl-mimeparse
+ (sbcl-package->cl-source-package sbcl-cl-mimeparse))
-(define-public ecl-cl-ledger
- (sbcl-package->ecl-package sbcl-cl-ledger))
+(define-public ecl-cl-mimeparse
+ (sbcl-package->ecl-package sbcl-cl-mimeparse))
-(define-public sbcl-bst
- (let ((commit "8545aed0d504df2829ad139566feeabe22305388")
+(define-public sbcl-cl-mixed
+ (let ((commit "4aaff134d3902d93a2a8605c10de4bcfc62d7afa")
(revision "0"))
(package
- (name "sbcl-bst")
- (version (git-version "2.0" revision commit))
+ (name "sbcl-cl-mixed")
+ (version (git-version "2.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/bst")
+ (url "https://github.com/Shirakumo/cl-mixed")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-mixed" version))
(sha256
- (base32 "18ig7rvxcra69437g0i8sxyv7c5dg26jqnx1rc2f9pxmihdprgk8"))))
+ (base32 "1mrj95lxb1gbxxm89x8gy1ifw2ic1p5wwpapkxcd2jr8abw7zny0"))
+ (modules '((guix build utils)))
+ (snippet
+ ;; Delete bundled libraries.
+ `(begin
+ (delete-file-recursively "static")))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-alexandria sbcl-fiveam))
- (synopsis "Binary search tree for Common Lisp")
+ (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
- "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))))
+ "This package provides CFFI binding to @code{libmixed} audio library for
+Common Lisp with support of other audio formats available on GNU/Linux systems:
-(define-public cl-bst
- (sbcl-package->cl-source-package sbcl-bst))
+@itemize
-(define-public ecl-bst
- (sbcl-package->ecl-package sbcl-bst))
+@item @acronym{Alsa, Advanced Linux Sound Architecture}
+@item @acronym{Jack, JackAudio toolkit}
+@item @acronym{Openmpt, Libopenmpt playback drain for tracker files}
+@item @acronym{PulseAudio, PulseAudio based playback drain}
+@item Flac (via CL-FLAC)
+@item Mpg123 (via CL-MPG123)
+@item Ogg/vorbis (via CL-VORBIS)
+@item Out123 (via CL-OUT123)
+@item WAV
-(define-public sbcl-trivial-octet-streams
- (let ((commit "bc5d398b18549fd42e9c2a365df28ad865f1b85d")
- (revision "0"))
+@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-trivial-octet-streams")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-cl-modio")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/trivial-octet-streams")
+ (url "https://github.com/Shinmera/cl-modio/")
(commit commit)))
- (file-name (git-file-name "cl-trivial-octet-streams" version))
(sha256
- (base32 "0ysnsarlzynb7jf4b63b6kkxjancxc66jwmn0sb3vxyh87siiv6n"))))
+ (base32 "0hz87v81pi8kr2c7az30czpdf7v757lkzlsmdcc59p94pipca7m9"))
+ (file-name (git-file-name "cl-modio" version))))
(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))))
+ (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-trivial-octet-streams
- (sbcl-package->cl-source-package sbcl-trivial-octet-streams))
+(define-public cl-modio
+ (sbcl-package->cl-source-package sbcl-cl-modio))
-(define-public ecl-trivial-octet-streams
- (sbcl-package->ecl-package sbcl-trivial-octet-streams))
+(define-public ecl-cl-modio
+ (sbcl-package->ecl-package sbcl-cl-modio))
-(define-public sbcl-cl-octet-streams
+(define-public sbcl-cl-morse
(package
- (name "sbcl-cl-octet-streams")
- (version "1.2")
+ (name "sbcl-cl-morse")
+ (version "1.0.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/cl-octet-streams")
+ (url "https://github.com/em7/cl-morse")
(commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-morse" version))
(sha256
- (base32 "1hffh98bv4w5yrchagzwqrc43d2p473pvw7ka4kyyvhrr52dk2f8"))))
+ (base32 "01sh34nhbsx2dsrb2r1vkd4j8lzm9gjd5jfi8a4cs4m3djjwhh5i"))))
(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")
+ (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
- "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+)))
+ "@code{cl-morse} is a Morse code translation library for Common Lisp.")
+ (license license:bsd-3)))
-(define-public cl-octet-streams
- (sbcl-package->cl-source-package sbcl-cl-octet-streams))
+(define-public cl-morse
+ (sbcl-package->cl-source-package sbcl-cl-morse))
-(define-public ecl-cl-octet-streams
- (sbcl-package->ecl-package sbcl-cl-octet-streams))
+(define-public ecl-cl-morse
+ (sbcl-package->ecl-package sbcl-cl-morse))
-(define-public sbcl-in-memory-streams
- (let ((commit "bb4ce9c8c08479c9904f5d29f2b6187f264dc620")
+(define-public sbcl-cl-mount-info
+ (let ((commit "2024f5037a7f63db3e3587dc9972cd7b9318f06b")
(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+))))
+ (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-in-memory-streams
- (sbcl-package->cl-source-package sbcl-in-memory-streams))
+(define-public cl-mount-info
+ (sbcl-package->cl-source-package sbcl-cl-mount-info))
-(define-public ecl-in-memory-streams
- (sbcl-package->ecl-package sbcl-in-memory-streams))
+(define-public ecl-cl-mount-info
+ (sbcl-package->ecl-package sbcl-cl-mount-info))
-(define-public sbcl-lzlib
- (let ((commit "22767ca12d1c1bd59a7ae1f9c5ef7d2e937206bb")
- (revision "2"))
+(define-public sbcl-cl-mpg123
+ (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d")
+ (revision "1"))
(package
- (name "sbcl-lzlib")
- (version (git-version "2.0" revision commit))
+ (name "sbcl-cl-mpg123")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://codeberg.org/glv/cl-lzlib")
+ (url "https://github.com/Shirakumo/cl-mpg123")
(commit commit)))
- (file-name (git-file-name "cl-lzlib" version))
+ (file-name (git-file-name "cl-mpg123" version))
(sha256
- (base32 "1dxzlkay7aqcs65h2f7j7rl4sdjija60dshlahzyllfw174p9d3m"))))
+ (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; Remove bundled pre-compiled libraries.
+ (delete-file-recursively "static")
+ #t))))
(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")
+ `(#: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 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+))))
+ "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-lzlib
- (sbcl-package->cl-source-package sbcl-lzlib))
+(define-public cl-mpg123
+ (sbcl-package->cl-source-package sbcl-cl-mpg123))
-(define-public ecl-lzlib
- (sbcl-package->ecl-package sbcl-lzlib))
+(define-public ecl-cl-mpg123
+ (sbcl-package->ecl-package sbcl-cl-mpg123))
-(define-public sbcl-chanl
- (let ((commit "56e90a126c78b39bb621a01585e8d3b985238e8c")
+(define-public sbcl-cl-murmurhash
+ ;; No release.
+ (let ((commit "5433f5e95f1cce63a81259a471150834c6a59364")
(revision "1"))
(package
- (name "sbcl-chanl")
- (version (git-version "0.4.1" revision commit))
+ (name "sbcl-cl-murmurhash")
+ (version (git-version "0.0.0" revision commit))
+ (home-page "https://github.com/ruricolist/cl-murmurhash/")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/zkat/chanl")
+ (url home-page)
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32
- "0b1cf6c12qx5cy1fw2z42jgh566rp3l8nv5qf0qqc569s7bgmrh4"))))
+ "0251r0mpjm0y3qsm4lm7ncvrkxvgwc53spdm1p2mpayhvkkqqsws"))))
(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)))))
-
-(define-public cl-chanl
- (sbcl-package->cl-source-package sbcl-chanl))
-
-(define-public ecl-chanl
- (sbcl-package->ecl-package sbcl-chanl))
-
-(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)
+ (list sbcl-babel))
(native-inputs
- (list sbcl-rt))
- (synopsis "Common Lisp library to serialize data")
+ (list sbcl-fiveam))
+ (synopsis "32-bit version of Murmurhash3 for Common Lisp")
(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 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-store
- (sbcl-package->cl-source-package sbcl-cl-store))
-
-(define-public ecl-cl-store
- (sbcl-package->ecl-package sbcl-cl-store))
+(define-public cl-murmurhash
+ (sbcl-package->cl-source-package sbcl-cl-murmurhash))
-(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 ecl-cl-murmurhash
+ (sbcl-package->ecl-package sbcl-cl-murmurhash))
-(define-public ecl-specialization-store
+(define-public sbcl-cl-mustache
(package
- (inherit (sbcl-package->ecl-package sbcl-specialization-store))
- (arguments
- ;; TODO: Find why the tests get stuck forever; disable them for now.
- `(#:tests? #f))))
+ (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-specialization-store
- (sbcl-package->cl-source-package sbcl-specialization-store))
+(define-public cl-mustache
+ (sbcl-package->cl-source-package sbcl-cl-mustache))
-(define-public sbcl-cl-gobject-introspection
- (let ((commit "83beec4492948b52aae4d4152200de5d5c7ac3e9")
- (revision "3"))
+(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-gobject-introspection")
- (version (git-version "0.3" revision commit))
- (home-page "https://github.com/andy128k/cl-gobject-introspection")
+ (name "sbcl-cl-mysql")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/hackinghat/cl-mysql")
(commit commit)))
- (file-name (git-file-name "cl-gobject-introspection" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0xwmj4b3whz12i474g54krp1v6h0fpvsx8lgwpk6rkli9xc71wc3"))))
+ (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list glib
- gobject-introspection
- sbcl-alexandria
- sbcl-cffi
- sbcl-iterate
- sbcl-trivial-garbage))
(native-inputs
- (list sbcl-fiveam))
+ (list sbcl-stefil))
+ (inputs
+ `(("cffi" ,sbcl-cffi)
+ ("mariadb-lib" ,mariadb "lib")))
(arguments
- '(#:phases
+ `(#: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* "src/init.lisp"
- (("libgobject-2\\.0\\.so")
- (search-input-file inputs "/lib/libgobject-2.0.so"))
- (("libgirepository-1\\.0\\.so")
- (search-input-file inputs
- "/lib/libgirepository-1.0.so"))))))))
- (synopsis "Common Lisp bindings to GObject Introspection")
+ (substitute* "system.lisp"
+ (("libmysqlclient_r" all)
+ (string-append (assoc-ref inputs "mariadb-lib")
+ "/lib/"
+ all)))
+ #t)))))
+ (synopsis "Common Lisp wrapper for MySQL")
(description
- "This library is a bridge between Common Lisp and GObject
-Introspection, which enables Common Lisp programs to access the full interface
-of C+GObject libraries without the need of writing dedicated bindings.")
- (license (list license:bsd-3
- ;; Tests are under a different license.
- license:llgpl)))))
+ "@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-gobject-introspection
- (sbcl-package->cl-source-package sbcl-cl-gobject-introspection))
+(define-public cl-mysql
+ (sbcl-package->cl-source-package sbcl-cl-mysql))
-(define-public ecl-cl-gobject-introspection
- (sbcl-package->ecl-package sbcl-cl-gobject-introspection))
+(define-public ecl-cl-mysql
+ (sbcl-package->ecl-package sbcl-cl-mysql))
-(define-public sbcl-cl-gobject-introspection-wrapper
- (let ((commit "2d197cba7e7d734ac8a2e181e5e709e5b218bada")
+(define-public sbcl-cl-num-utils
+ (let ((commit "97a88cd34540acf52e872a82ebfef3da0a34fa12")
(revision "1"))
(package
- (name "sbcl-cl-gobject-introspection-wrapper")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-num-utils")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bohonghuang/cl-gobject-introspection-wrapper")
+ (url "https://github.com/tpapp/cl-num-utils")
(commit commit)))
- (file-name (git-file-name "cl-gobject-introspection-wrapper" version))
+ (file-name (git-file-name "cl-num-utils" version))
(sha256
- (base32 "05np2zs5806ib6qfz7d6knyaz6llxgwvjqavl1fsz5hcga40296s"))))
+ (base32 "15ihsxxs76xnldmqfsbxybckqjwrxwcpphgghiwzr2mnbqjpdqkh"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-cl-gobject-introspection
- sbcl-cl-ppcre))
- (home-page
- "https://github.com/bohonghuang/cl-gobject-introspection-wrapper")
- (synopsis
- "Wrap and call GObject Introspection FFI function in Common Lisp")
+ (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
- "This library converts the elements from GObject Introspection into
-Common Lisp-style definitions, based on cl-gobject-introspection.")
- (license license:lgpl3+))))
+ "@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-gobject-introspection-wrapper
- (sbcl-package->cl-source-package sbcl-cl-gobject-introspection-wrapper))
+(define-public cl-num-utils
+ (sbcl-package->cl-source-package sbcl-cl-num-utils))
-(define-public ecl-cl-gobject-introspection-wrapper
- (sbcl-package->ecl-package sbcl-cl-gobject-introspection-wrapper))
+(define-public ecl-cl-num-utils
+ (sbcl-package->ecl-package sbcl-cl-num-utils))
-(define-public sbcl-cl-glib
- (let ((commit "9e52827cce1cbb3962536b6a5e628febab593f57")
+(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-glib")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-online-learning")
+ (version (git-version "0.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bohonghuang/cl-glib")
+ (url "https://github.com/masatoi/cl-online-learning")
(commit commit)))
- (file-name (git-file-name "cl-glib" version))
+ (file-name (git-file-name "cl-online-learning" version))
(sha256
- (base32 "0dxa493zdp1p93cahhpp3yaggn3j3kkn90mdw99g4ld7scmiglp4" ))))
+ (base32
+ "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9"))))
(build-system asdf-build-system/sbcl)
- (arguments
- '(#:asd-systems '("cl-gio" "cl-glib" "cl-gobject")))
+ (native-inputs
+ (list sbcl-prove))
(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+))))
+ `(("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-glib
- (sbcl-package->cl-source-package sbcl-cl-glib))
+(define-public cl-online-learning
+ (sbcl-package->cl-source-package sbcl-cl-online-learning))
-(define-public ecl-cl-glib
- (sbcl-package->ecl-package sbcl-cl-glib))
+(define-public ecl-cl-online-learning
+ (sbcl-package->ecl-package sbcl-cl-online-learning))
-(define-public sbcl-cl-gtk4
- (let ((commit "d116905e7b68508d03681a50b3b24d63e7b111e4")
+(define-public sbcl-cl-opengl
+ (let ((commit "e2d83e0977b7e7ac3f3d348d8ccc7ccd04e74d59")
(revision "1"))
(package
- (name "sbcl-cl-gtk4")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-opengl")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/bohonghuang/cl-gtk4")
+ (url "https://github.com/3b/cl-opengl")
(commit commit)))
- (file-name (git-file-name "cl-gtk4" version))
+ (file-name (git-file-name "cl-opengl" version))
(sha256
- (base32 "0mprmmvbagnflvhynn51l42nbwr08rld99ls0c48m5lpjn0ja4zc"))))
+ (base32 "0mhqmll09f079pnd6mgswz9nvr6h5n27d4q7zpmm2igf1v460id7"))))
(build-system asdf-build-system/sbcl)
(arguments
- '(#:asd-systems '("cl-gtk4" "cl-gdk4")))
- ;; propagate because it at least requires the typelib files at runtime
- (propagated-inputs (list gtk))
+ `(#:asd-systems '("cl-opengl" "cl-glu" "cl-glut")
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'patch-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "gl/library.lisp"
+ (("libGL.so" all)
+ (search-input-file inputs "/lib/libGL.so")))
+ (substitute* "glu/library.lisp"
+ (("libGLU.so" all)
+ (search-input-file inputs "/lib/libGLU.so")))
+ (substitute* "glut/library.lisp"
+ (("libglut.so" all)
+ (search-input-file inputs "/lib/libglut.so"))))))))
(inputs
- (list gobject-introspection
- sbcl-cl-glib
- sbcl-cl-gobject-introspection-wrapper))
- (home-page "https://github.com/bohonghuang/cl-gtk4")
- (synopsis "GTK4 bindings for Common Lisp")
+ `(("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 library provides GTK4 bindings for Common Lisp via Gobject
-Introspection, in the cl-gtk4 ASDF system.")
- (license license:lgpl3))))
+ "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-gtk4
- (sbcl-package->cl-source-package sbcl-cl-gtk4))
+(define-public cl-opengl
+ (sbcl-package->cl-source-package sbcl-cl-opengl))
-(define-public ecl-cl-gtk4
- (sbcl-package->ecl-package sbcl-cl-gtk4))
+(define-public ecl-cl-opengl
+ (sbcl-package->ecl-package sbcl-cl-opengl))
-(define-public sbcl-cl-slug
- (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749")
- (revision "1"))
+(define-public sbcl-cl-out123
+ (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7")
+ (revision "2"))
(package
- (name "sbcl-cl-slug")
- (version (git-version "0.4.1" revision commit))
+ (name "sbcl-cl-out123")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/EuAndreh/cl-slug")
+ (url "https://github.com/Shirakumo/cl-out123")
(commit commit)))
- (file-name (git-file-name "cl-slug" version))
+ (file-name (git-file-name "cl-out123" version))
(sha256
- (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx"))))
+ (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w"))
+ (modules '((guix build utils)))
+ (snippet
+ '(begin
+ ;; Remove bundled pre-compiled libraries.
+ (delete-file-recursively "static")))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
+ (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
- `(("ppcre" ,sbcl-cl-ppcre)))
- (home-page "https://github.com/EuAndreh/cl-slug")
- (synopsis "Multi-language slug formatter")
+ (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 small Common Lisp library to make slugs, mainly for URIs,
-from English and beyond.")
- (license license:llgpl))))
+ "This is a bindings library to @code{libout123} which allows easy
+cross-platform audio playback.")
+ (license license:zlib))))
-(define-public ecl-cl-slug
- (sbcl-package->ecl-package sbcl-cl-slug))
+(define-public cl-out123
+ (sbcl-package->cl-source-package sbcl-cl-out123))
-(define-public cl-slug
- (sbcl-package->cl-source-package sbcl-cl-slug))
+(define-public ecl-cl-out123
+ (sbcl-package->ecl-package sbcl-cl-out123))
-(define-public sbcl-string-case
- (let ((commit "718c761e33749e297cd2809c7ba3ade1985c49f7")
- (revision "0"))
+(define-public sbcl-cl-package-locks
+ (let ((commit "96a358ede7cef416d61d2f699e724fe1d9de602c")
+ (revision "1"))
(package
- (name "sbcl-string-case")
+ (name "sbcl-cl-package-locks")
(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/elliottjohnson/cl-package-locks")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-package-locks" version))
(sha256
- (base32
- "1n5i3yh0h5s636rcnwn7jwqy3rjflikra04lymimhpcshhjsk0md"))))
+ (base32 "0g3gfljnvpgd66ccd2sqawlkwqx4a0wsdrg5180va61w869cgxqq"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Efficient string= case in Common Lisp")
+ (home-page "https://github.com/elliottjohnson/cl-package-locks")
+ (synopsis "Compatibility layer for dealing with package locks")
(description
- "@code{string-case} is a Common Lisp macro that generates specialised decision
-trees to dispatch on string equality.")
- (license license:bsd-3))))
+ "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-string-case
- (sbcl-package->cl-source-package sbcl-string-case))
+(define-public cl-package-locks
+ (sbcl-package->cl-source-package sbcl-cl-package-locks))
-(define-public ecl-string-case
- (sbcl-package->ecl-package sbcl-string-case))
+(define-public ecl-cl-package-locks
+ (sbcl-package->ecl-package sbcl-cl-package-locks))
-(define-public sbcl-garbage-pools
- (let ((commit "9a7cb7f48b04197c0495df3b6d2e8395ad13f790")
+(define-public sbcl-cl-pass
+ (let ((commit "e58e97c0c0588dc742c061208afb9bc31e4dbd34")
(revision "1"))
(package
- (name "sbcl-garbage-pools")
- (version (git-version "0.1.2" revision commit))
+ (name "sbcl-cl-pass")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/archimag/garbage-pools")
+ (url "https://github.com/eudoxia0/cl-pass")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-pass" version))
(sha256
- (base32 "04jqwr6j138him6wc4nrwjzm4lvyj5j31xqab02nkf8h9hmsf5v1"))))
+ (base32 "05qx4jrkxqbqi72cxgswbpnifbdvp9mh7apc7566v522899bh0hb"))))
(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.")
+ (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 ecl-garbage-pools
- (sbcl-package->ecl-package sbcl-garbage-pools))
+(define-public cl-pass
+ (sbcl-package->cl-source-package sbcl-cl-pass))
-(define-public cl-garbage-pools
- (sbcl-package->cl-source-package sbcl-garbage-pools))
+(define-public ecl-cl-pass
+ (sbcl-package->ecl-package sbcl-cl-pass))
-(define-public sbcl-global-vars
- (let ((commit "c749f32c9b606a1457daa47d59630708ac0c266e")
- (revision "0"))
+(define-public sbcl-cl-pcg
+ (let ((commit "8263d85ab0ca17fb05637a4430c2d564456bce8f")
+ (revision "1"))
(package
- (name "sbcl-global-vars")
+ (name "sbcl-cl-pcg")
(version (git-version "1.0.0" revision commit))
- (home-page "https://github.com/lmj/global-vars")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/sjl/cl-pcg")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-pcg" version))
(sha256
- (base32
- "06m3xc8l3pgsapl8fvsi9wf6y46zs75cp9zn7zh6dc65v4s5wz3d"))))
+ (base32 "0s57wvvlvshp1gcp9i9d3qcmqhswnxps3i0y7wbb0v8i1a3p46m4"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Efficient global variables in Common Lisp")
+ (native-inputs
+ (list sbcl-1am))
+ (home-page "https://github.com/sjl/cl-pcg")
+ (synopsis "Permuted congruential generators 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.")
+ "This is a bare-bones Permuted Congruential Generator implementation in
+pure Common Lisp.")
(license license:expat))))
-(define-public cl-global-vars
- (sbcl-package->cl-source-package sbcl-global-vars))
+(define-public cl-pcg
+ (sbcl-package->cl-source-package sbcl-cl-pcg))
-(define-public ecl-global-vars
- (sbcl-package->ecl-package sbcl-global-vars))
+(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-trivial-file-size
- (let ((commit "1c1d672a01a446ba0391dbb4ffc40be3b0476f23")
- (revision "0"))
+(define-public sbcl-cl-pdf
+ (let ((commit "ee904a118a0f060279ad9d253a3e8e3997609213")
+ (revision "3"))
(package
- (name "sbcl-trivial-file-size")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/trivial-file-size")
+ (name "sbcl-cl-pdf")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/mbattyani/cl-pdf")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-pdf" version))
(sha256
- (base32
- "17pp86c9zs4y7i1sh7q9gbfw9iqv6655k7fz8qbj9ly1ypgxp4qs"))))
+ (base32 "0j7hbqv6yzrgx0inqinpw8h22728l53ccciw6iymzz4g92j9fzlq"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "Size of a file in bytes in Common Lisp")
+ (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
- "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))))
+ "CL-PDF is a cross-platform Common Lisp library for generating PDF
+files.")
+ (license license:bsd-2))))
-(define-public cl-trivial-file-size
- (sbcl-package->cl-source-package sbcl-trivial-file-size))
+(define-public cl-pdf
+ (sbcl-package->cl-source-package sbcl-cl-pdf))
-(define-public ecl-trivial-file-size
- (sbcl-package->ecl-package sbcl-trivial-file-size))
+(define-public ecl-cl-pdf
+ (sbcl-package->ecl-package sbcl-cl-pdf))
-(define-public sbcl-trivial-macroexpand-all
- (let ((commit "933270ac7107477de1bc92c1fd641fe646a7a8a9")
+(define-public sbcl-cl-permutation
+ (let ((commit "20c10e9ca56452d2fafc3ec0984dcdf78b4f4b19")
(revision "0"))
(package
- (name "sbcl-trivial-macroexpand-all")
+ (name "sbcl-cl-permutation")
(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)
+ (url "https://github.com/stylewarning/cl-permutation")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-permutation" version))
(sha256
- (base32
- "191hnn4b5j4i3crydmlzbm231kj0h7l8zj6mzj69r1npbzkas4bd"))))
+ (base32 "0i932g0k50y24hxizni6zfya4kcw77yk3b0llivm9g50s7fxj9dk"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
- (synopsis "Portable macroexpand-all for Common Lisp")
+ (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 library provides a macroexpand-all function that calls the
-implementation specific equivalent.")
- (license license:unlicense))))
+ "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-trivial-macroexpand-all
- (sbcl-package->cl-source-package sbcl-trivial-macroexpand-all))
+(define-public cl-permutation
+ (sbcl-package->cl-source-package sbcl-cl-permutation))
-(define-public ecl-trivial-macroexpand-all
- (sbcl-package->ecl-package sbcl-trivial-macroexpand-all))
+(define-public ecl-cl-permutation
+ (sbcl-package->ecl-package sbcl-cl-permutation))
-(define-public sbcl-serapeum
- (let ((commit "c08442a9757b7fa30ac345cb040e1642f97f6b78")
- (revision "12"))
+(define-public sbcl-cl-portaudio
+ (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f")
+ (revision "1"))
(package
- (name "sbcl-serapeum")
- (version (git-version "0.0.0" revision commit))
- (home-page "https://github.com/ruricolist/serapeum")
+ (name "sbcl-cl-portaudio")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/filonenko-mikhail/cl-portaudio")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-portaudio" version))
(sha256
- (base32 "1sabd048agvgv7bhbw126rci9hf45fk08zhghcv6an2h6xwmc3qv"))))
+ (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb"))))
(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))
+ (list portaudio sbcl-cffi sbcl-ffa))
(arguments
- (list #:phases
+ (list #:tests? #f ; Tests need access to sound cards
+ #: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")
+ (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
- "Serapeum is a conservative library of Common Lisp utilities. It is a
-supplement, not a competitor, to Alexandria.")
+ "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-serapeum
- (sbcl-package->cl-source-package sbcl-serapeum))
+(define-public cl-portaudio
+ (sbcl-package->cl-source-package sbcl-cl-portaudio))
-(define-public ecl-serapeum
- (sbcl-package->ecl-package sbcl-serapeum))
+(define-public ecl-cl-portaudio
+ (sbcl-package->ecl-package sbcl-cl-portaudio))
-(define-public sbcl-rutils
- (let ((commit "db3c3f4ae897025b5f0cd81042ca147da60ca0c5")
- (revision "0"))
+(define-public sbcl-cl-posix-mqueue
+ (let ((commit "8977370c7206d1f62bd1be80f4254af40654b83f")
+ (revision "1"))
(package
- (name "sbcl-rutils")
- (version (git-version "5.2.1" revision commit))
+ (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/vseloved/rutils")
+ (url "https://github.com/xFA25E/cl-posix-mqueue")
(commit commit)))
- (file-name (git-file-name "rutils" version))
+ (file-name (git-file-name "cl-posix-mqueue" version))
(sha256
- (base32 "1d2whscknh1zga2vdqvfqri8wx0gnml3sfqz62igq0ppap6q07y3"))))
+ (base32 "04519rg8vc782z097dzlb8nx0skab2fy2zd0m60r6mz2nw8xdvh6"))))
(build-system asdf-build-system/sbcl)
(arguments
- `(#:asd-systems '("rutils" "rutilsx")
- ;; Tests disabled because of a circular dependency with should-test.
- #:tests? #f
- #:phases
+ `(#: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"))))))
+ (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
- `(("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))))
+ `(("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-rutils
- (sbcl-package->cl-source-package sbcl-rutils))
+(define-public cl-posix-mqueue
+ (sbcl-package->cl-source-package sbcl-cl-posix-mqueue))
-(define-public ecl-rutils
- (sbcl-package->ecl-package sbcl-rutils))
+(define-public ecl-cl-posix-mqueue
+ (sbcl-package->ecl-package sbcl-cl-posix-mqueue))
-(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"))
+(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-arrow-macros")
- (version (git-version "0.2.7" revision commit))
+ (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 "https://github.com/hipeta/arrow-macros")
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "arrow-macros" version))
+ (file-name (git-file-name name 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))))
+ (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-arrow-macros
- (sbcl-package->cl-source-package sbcl-arrow-macros))
+(define-public cl-prevalence
+ (sbcl-package->cl-source-package sbcl-cl-prevalence))
-(define-public ecl-arrow-macros
- (sbcl-package->ecl-package sbcl-arrow-macros))
+(define-public ecl-cl-prevalence
+ (sbcl-package->ecl-package sbcl-cl-prevalence))
-(define-public sbcl-arrows
- (let ((commit "df7cf0067e0132d9697ac8b1a4f1b9c88d4f5382")
- (revision "0"))
+(define-public sbcl-cl-progress-bar
+ (let ((commit "9374170858663c8fe829e9fb5a29bd2cb48d95ae"))
(package
- (name "sbcl-arrows")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-cl-progress-bar")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.com/Harleqin/arrows.git")
+ (url "https://github.com/sirherrbatka/cl-progress-bar/")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "042k9vkssrqx9nhp14wdzm942zgdxvp35mba0p2syz98i75im2yy"))))
+ (base32 "1ldb4qhmx431n3lsq71ynwb9ybazbfqd55icjbhi06mj52ngndir"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-hu.dwim.stefil))
- (synopsis "Clojure-like arrow macros for Common Lisp")
+ (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 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))))
+ "This library provides almost the same code as used inside Quicklisp
+for drawning progress bars")
+ (license license:expat))))
-(define-public cl-arrows
- (sbcl-package->cl-source-package sbcl-arrows))
+(define-public cl-progress-bar
+ (sbcl-package->cl-source-package sbcl-cl-progress-bar))
-(define-public ecl-arrows
- (sbcl-package->ecl-package sbcl-arrows))
+(define-public ecl-cl-progress-bar
+ (sbcl-package->ecl-package sbcl-cl-progress-bar))
-(define-public sbcl-simple-parallel-tasks
- (let ((commit "ce7b60f788d8f68dfb69b24aac54c0e3b63379a6")
+(define-public sbcl-cl-project
+ (let ((commit "151107014e534fc4666222d57fec2cc8549c8814")
(revision "1"))
(package
- (name "sbcl-simple-parallel-tasks")
- (version (git-version "1.0" revision commit))
+ (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 "https://codeberg.org/glv/simple-parallel-tasks")
+ (url home-page)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0gvbpyff4siifp3cp86cpr9ksmakn66fx21f3h0hpn647zl07nj7"))))
+ (base32 "1rmh6s1ncv8s2yrr14ja9wisgg745sq6xibqwb341ikdicxdp26y"))))
(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))))
+ `(("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-simple-parallel-tasks
- (sbcl-package->cl-source-package sbcl-simple-parallel-tasks))
+(define-public cl-project
+ (sbcl-package->cl-source-package sbcl-cl-project))
-(define-public ecl-simple-parallel-tasks
- (sbcl-package->ecl-package sbcl-simple-parallel-tasks))
+(define-public ecl-cl-project
+ (sbcl-package->ecl-package sbcl-cl-project))
-(define-public sbcl-cl-heap
+(define-public sbcl-cl-punch
(package
- (name "sbcl-cl-heap")
- (version "0.1.6")
+ (name "sbcl-cl-punch")
+ (version "0.2")
(source
(origin
- (method url-fetch)
- (uri (string-append "https://common-lisp.net/project/cl-heap/releases/"
- "cl-heap_" version ".tar.gz"))
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/windymelt/cl-punch")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-punch" version))
(sha256
- (base32
- "163hb07p2nxz126rpq3cj5dyala24n0by5i5786n2qcr1w0bak4i"))))
+ (base32 "1vmbaz9y9lq4wvi8mfbyif8vc9yfk2i0qd3ysbzl152wx32dbzs3"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-xlunit))
- (arguments
- '(#:asd-test-systems '("cl-heap-tests")))
- (synopsis "Heap and priority queue data structures for Common Lisp")
+ (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-HEAP provides various implementations of heap data structures (a
-binary heap and a Fibonacci heap) as well as an efficient priority queue.")
- (home-page "https://common-lisp.net/project/cl-heap/")
- (license license:gpl3+)))
+ "CL-PUNCH is a Scala-like anonymous lambda literal.")
+ (license license:expat )))
-(define-public cl-heap
- (sbcl-package->cl-source-package sbcl-cl-heap))
+(define-public cl-punch
+ (sbcl-package->cl-source-package sbcl-cl-punch))
-(define-public ecl-cl-heap
- (sbcl-package->ecl-package sbcl-cl-heap))
+(define-public ecl-cl-punch
+ (sbcl-package->ecl-package sbcl-cl-punch))
-(define-public sbcl-curry-compose-reader-macros
- (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
- (revision "0"))
+(define-public sbcl-cl-qprint
+ (let ((commit "bfe398551cbfb7ca84a9ba59a26a1116ac5c06eb")
+ (revision "1"))
(package
- (name "sbcl-curry-compose-reader-macros")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-qprint")
+ (version (git-version "0.9.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/eschulte/curry-compose-reader-macros")
- (commit commit)))
+ (uri (git-reference
+ (url "https://github.com/eugeneia/cl-qprint/")
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
+ (base32 "099h0rrdzxnlmn8avi72mg2dl0kccp7w01b2p9nwyy4b8yr32cir"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria sbcl-named-readtables))
- (synopsis "Reader macros for partial application and composition")
+ (list sbcl-flexi-streams))
+ (home-page "https://github.com/eugeneia/cl-qprint/")
+ (synopsis "Implementation of the quoted-printable encoding")
(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))))
+ "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-curry-compose-reader-macros
- (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
+(define-public cl-qprint
+ (sbcl-package->cl-source-package sbcl-cl-qprint))
-(define-public ecl-curry-compose-reader-macros
- (sbcl-package->ecl-package sbcl-curry-compose-reader-macros))
+(define-public ecl-cl-qprint
+ (sbcl-package->ecl-package sbcl-cl-qprint))
-(define-public sbcl-yason
+(define-public sbcl-cl-qrencode
(package
- (name "sbcl-yason")
- (version "0.8.4")
+ (name "sbcl-cl-qrencode")
+ (version "0.1.2")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/phmarek/yason")
+ (url "https://github.com/jnjcc/cl-qrencode")
(commit (string-append "v" version))))
- (file-name (git-file-name "cl-yason" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0d22sw7nf2ygqm56ilybg7bza63cv43pc4184r8rvsjz2in37n51"))))
+ (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-lisp-unit))
(inputs
- (list sbcl-alexandria sbcl-trivial-gray-streams))
- (synopsis "Common Lisp JSON parser/encoder")
+ (list sbcl-zpng))
+ (synopsis "QR code encoder for Common Lisp")
(description
- "YASON is a Common Lisp library for encoding and decoding data in the
-JSON interchange format.")
- (home-page "https://github.com/phmarek/yason")
- (license license:bsd-3)))
+ "This Common Lisp library 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-yason
- (sbcl-package->cl-source-package sbcl-yason))
+(define-public cl-qrencode
+ (sbcl-package->cl-source-package sbcl-cl-qrencode))
-(define-public ecl-yason
- (sbcl-package->ecl-package sbcl-yason))
+(define-public ecl-cl-qrencode
+ (sbcl-package->ecl-package sbcl-cl-qrencode))
-(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 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-graph
- (sbcl-package->cl-source-package sbcl-graph))
+(define-public cl-randist
+ (sbcl-package->cl-source-package sbcl-cl-randist))
-(define-public ecl-graph
- (sbcl-package->ecl-package sbcl-graph))
+(define-public ecl-cl-randist
+ (sbcl-package->ecl-package sbcl-cl-randist))
-(define-public sbcl-trivial-indent
- (let ((commit "f25275094b80df8aa158af46db980bbc3ce2f88b")
+(define-public sbcl-cl-random
+ (let ((commit "5bb65911037f95a4260bd29a594a09df3849f4ea")
(revision "1"))
(package
- (name "sbcl-trivial-indent")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-cl-random")
+ (version (git-version "0.0.1" 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))
+ (uri (git-reference
+ (url "https://github.com/tpapp/cl-random")
+ (commit commit)))
+ (file-name (git-file-name "cl-random" version))
(sha256
- (base32 "1zg8cyy1xqpcjrxxqz5zb5xixhwcszkv4p2vq305lb2rka6f3dyx"))))
+ (base32 "0jn80xphyvyp2v72acr6b8a2f6dw06myr5vrjfl14brsvks7wr89"))))
(build-system asdf-build-system/sbcl)
- (synopsis
- "Simple Common Lisp library to allow indentation hints for SWANK")
+ (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
- "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))))
+ "@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-trivial-indent
- (sbcl-package->cl-source-package sbcl-trivial-indent))
+(define-public cl-random
+ (sbcl-package->cl-source-package sbcl-cl-random))
-(define-public ecl-trivial-indent
- (sbcl-package->ecl-package sbcl-trivial-indent))
+(define-public ecl-cl-random
+ (sbcl-package->ecl-package sbcl-cl-random))
-(define-public sbcl-data-format-validation
- (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb")
+(define-public sbcl-cl-random-forest
+ (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
(revision "1"))
(package
- (name "sbcl-data-format-validation")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-cl-random-forest")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/willijar/cl-data-format-validation/")
- (commit commit)))
- (file-name (git-file-name "data-format-validation" version))
+ (uri (git-reference
+ (url "https://github.com/masatoi/cl-random-forest")
+ (commit commit)))
+ (file-name (git-file-name name version))
(sha256
(base32
- "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa"))))
+ "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ `(("prove" ,sbcl-prove)
+ ("trivial-garbage" ,sbcl-trivial-garbage)))
(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)
+ `(("alexandria" ,sbcl-alexandria)
+ ("cl-libsvm-format" ,sbcl-cl-libsvm-format)
+ ("cl-online-learning" ,sbcl-cl-online-learning)
+ ("lparallel" ,sbcl-lparallel)))
(arguments
- '(#:asd-systems '("docutils")))
- (inputs
- (list sbcl-cl-ppcre
- sbcl-data-format-validation
- sbcl-trivial-gray-streams))
- (synopsis "Document utilities and Restructured text parser")
+ `(#:tests? #f)) ; The tests download data from the Internet
+ (synopsis "Random Forest and Global Refinement for Common Lisp")
(description
- "@code{cl-docutils} is a Common Lisp implementation of the Docutils text
-processing system for processing plaintext into presentational formats such as
-HTML and LaTeX. It is based upon the Python Docutils reference implementation
-but uses Common Lisp idioms making it easier to extend and more flexible. As
-with the reference implementation it includes a parser for the reStructured
-text plaintext markup syntax which is suitable for marking up documentation
-and for use as user markup for collaborative web sites. It is successfully
-used to support a higher education peer-review assessment and online tutorial
-system.")
- (home-page "http://www.jarw.org.uk/lisp/cl-docutils.html")
- (license license:gpl3))))
+ "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-docutils
- (sbcl-package->cl-source-package sbcl-cl-docutils))
+(define-public cl-random-forest
+ (sbcl-package->cl-source-package sbcl-cl-random-forest))
-(define-public ecl-cl-docutils
- (sbcl-package->ecl-package sbcl-cl-docutils))
+(define-public ecl-cl-random-forest
+ (sbcl-package->ecl-package sbcl-cl-random-forest))
-(define-public sbcl-documentation-utils
- (let ((commit "98630dd5f7e36ae057fa09da3523f42ccb5d1f55")
+(define-public sbcl-cl-raylib
+ (let ((commit "985ceebef4cb56c651cddc23bd71812f2be38c2d")
(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))
+ (name "sbcl-cl-raylib")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/sirherrbatka/documentation-utils-extensions/")
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri (git-reference
+ (url "https://github.com/longlene/cl-raylib")
+ (commit commit)))
+ (file-name (git-file-name "cl-raylib" version))
(sha256
- (base32
- "0pn45c9rbxlnhn5nvhqz6kyv0nlirwxpg4j27niwdq80yxzsn51f"))))
+ (base32 "1kighj35g6dn426mhr2ppz3gm49v1q4n42ydn619pclrqwyrnc2z"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ `(#:tests? #f ; no tests https://github.com/longlene/cl-raylib/issues/40
+ #:phases
+ (modify-phases %standard-phases
+ (add-after 'unpack 'fix-paths
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "src/library.lisp"
+ (("libraylib\\.so")
+ (search-input-file inputs "/lib/libraylib.so"))))))))
(inputs
- (list sbcl-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.")
+ (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-documentation-utils-extensions
- (sbcl-package->cl-source-package sbcl-documentation-utils-extensions))
+(define-public cl-raylib
+ (sbcl-package->cl-source-package sbcl-cl-raylib))
-(define-public ecl-documentation-utils-extensions
- (sbcl-package->ecl-package sbcl-documentation-utils-extensions))
+(define-public ecl-cl-raylib
+ (sbcl-package->ecl-package sbcl-cl-raylib))
-(define-public sbcl-charje.documentation
+(define-public sbcl-cl-rdkafka
(package
- (name "sbcl-charje.documentation")
- (version "0.0.0")
+ (name "sbcl-cl-rdkafka")
+ (version "1.1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.sr.ht/~charje/documentation")
+ (url "https://github.com/SahilKang/cl-rdkafka")
(commit (string-append "v" version))))
+ (file-name (git-file-name name version))
(sha256
(base32
- "149r9qdz5dyxsamhf5miaa9njr7kn7nc0ic448k133rs3nnwagqc"))
- (file-name (git-file-name "cl-charje.documentation" version))))
+ "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
- (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+)))
+ `(("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-charje.documentation
- (sbcl-package->cl-source-package sbcl-charje.documentation))
+(define-public cl-rdkafka
+ (sbcl-package->cl-source-package sbcl-cl-rdkafka))
-(define-public ecl-charje.documentation
- (sbcl-package->ecl-package sbcl-charje.documentation))
+(define-public ecl-cl-rdkafka
+ (sbcl-package->ecl-package sbcl-cl-rdkafka))
-(define-public sbcl-staple
- (let ((commit "0ee8e25fe6fe8fa83b2a6c93d4febd468c3eaa4e")
+(define-public sbcl-cl-readline
+ (let ((commit "8438c9ebd92ccc95ebab9cc9cbe6c72d44fccc58")
(revision "1"))
(package
- (name "sbcl-staple")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-cl-readline")
+ (version (git-version "0.1.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/staple/")
+ (url "https://github.com/vindarel/cl-readline")
(commit commit)))
+ (file-name (git-file-name "cl-readline" version))
(sha256
- (base32 "0qf0if7py3n4rszg25lcavpsqikfz6k5dvcmh5q67y8x5r12i5m7"))
- (file-name (git-file-name "staple" version))))
+ (base32 "14iskvqfw71ssaav483vmqw62lrpznysjs800gjjppxs785p1fa0"))))
(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))))
+ `(("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-staple
- (sbcl-package->cl-source-package sbcl-staple))
+(define-public cl-readline
+ (sbcl-package->cl-source-package sbcl-cl-readline))
-(define-public ecl-staple
- (sbcl-package->ecl-package sbcl-staple))
+(define-public ecl-cl-readline
+ (sbcl-package->ecl-package sbcl-cl-readline))
-(define-public sbcl-helambdap
- (let ((commit "5bf65f57a36ee094cadb096caca6e90eb3ba46c4")
+(define-public sbcl-cl-redis
+ (let ((commit "7d592417421cf7cd1cffa96043b457af0490df7d")
(revision "0"))
(package
- (name "sbcl-helambdap")
- (version (git-version "20220103" revision commit))
+ (name "sbcl-cl-redis")
+ (version (git-version "2.3.8" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.code.sf.net/p/helambdap/code")
+ (url "https://github.com/vseloved/cl-redis")
(commit commit)))
- (file-name (git-file-name "cl-helambdap" version))
+ (file-name (git-file-name "cl-redis" version))
(sha256
- (base32 "1kzapbf9l2bw8i9m9sxv0dfnkksrxq81d5hbn34pm25abk0i937j"))))
+ (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
- (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")
+ `(("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-helambdap
- (sbcl-package->cl-source-package sbcl-helambdap))
+(define-public cl-redis
+ (sbcl-package->cl-source-package sbcl-cl-redis))
-(define-public sbcl-form-fiddle
- (let ((commit "e0c23599dbb8cff3e83e012f3d86d0764188ad18")
- (revision "0"))
+(define-public ecl-cl-redis
+ (let ((pkg (sbcl-package->ecl-package sbcl-cl-redis)))
(package
- (name "sbcl-form-fiddle")
- (version (git-version "1.1.0" revision commit))
+ (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/Shinmera/form-fiddle")
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri (git-reference
+ (url "https://github.com/takagi/cl-reexport")
+ (commit commit)))
+ (file-name (git-file-name "cl-reexport" version))
(sha256
(base32
- "041iznc9mpfyrl0sv5893ys9pbb2pvbn9g3clarqi7gsfj483jln"))))
- (build-system asdf-build-system/sbcl)
+ "02la6z3ickhmh2m87ymm2ijh9nkn7l6slskj99l8a1rhps394qqc"))))
(inputs
- (list sbcl-documentation-utils))
- (synopsis "Utilities to destructure Common Lisp lambda forms")
+ (list sbcl-alexandria))
+ (native-inputs
+ (list sbcl-prove))
+ (synopsis "Reexport external symbols in other Common Lisp packages")
(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))))
+ "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-form-fiddle
- (sbcl-package->cl-source-package sbcl-form-fiddle))
+(define-public cl-reexport
+ (sbcl-package->cl-source-package sbcl-cl-reexport))
-(define-public ecl-form-fiddle
- (sbcl-package->ecl-package sbcl-form-fiddle))
+(define-public ecl-cl-reexport
+ (sbcl-package->ecl-package sbcl-cl-reexport))
-(define-public sbcl-array-utils
- (let ((commit "29da8fccf6093fe8f8c7b2daef7de1a428ef1834")
- (revision "0"))
+(define-public sbcl-cl-rmath
+ (let ((commit "f6add1edda31547691d08e36ccf6c17305161aca")
+ (revision "1"))
(package
- (name "sbcl-array-utils")
- (version (git-version "1.2.0" revision commit))
+ (name "sbcl-cl-rmath")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/array-utils")
- (commit commit)))
- (file-name (git-file-name "cl-array-utils" version))
+ (uri (git-reference
+ (url "https://github.com/tpapp/cl-rmath")
+ (commit commit)))
+ (file-name (git-file-name "cl-rmath" version))
(sha256
- (base32 "1d66s2inb9hpw27hdb20x27dychmpn1mn35v0mlsib848qdz87az"))))
+ (base32 "1ld8vbpy10paymx2hn0mcgd21i7cjhdrayln1jx0kayqxm12mmk4"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
+ (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
- (list sbcl-documentation-utils))
- (synopsis "Tiny collection of array and vector utilities for Common Lisp")
+ `(("cffi" ,sbcl-cffi)
+ ("librmath" ,rmath-standalone)))
+ (home-page "https://github.com/tpapp/cl-rmath")
+ (synopsis "Common Lisp wrapper for libRmath")
(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))))
+ "@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-array-utils
- (sbcl-package->cl-source-package sbcl-array-utils))
+(define-public cl-rmath
+ (sbcl-package->cl-source-package sbcl-cl-rmath))
-(define-public ecl-array-utils
- (sbcl-package->ecl-package sbcl-array-utils))
+(define-public ecl-cl-rmath
+ (sbcl-package->ecl-package sbcl-cl-rmath))
-(define-public sbcl-lass
- (let ((commit "1f2418dbf2d8d6f5892171057616b2ca9d6e5008")
+(define-public sbcl-cl-slice
+ (let ((commit "c531683f287216aebbb0affbe090611fa1b5d697")
(revision "1"))
(package
- (name "sbcl-lass")
- (version (git-version "0.6.0" revision commit))
+ (name "sbcl-cl-slice")
+ (version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
- (uri
- (git-reference
- (url "https://github.com/Shinmera/LASS")
- (commit commit)))
- (file-name (git-file-name "cl-lass" version))
+ (uri (git-reference
+ (url "https://github.com/tpapp/cl-slice")
+ (commit commit)))
+ (file-name (git-file-name "cl-slice" version))
(sha256
- (base32 "1wax2kykc9ff0sk2linp9v8fcsm5ay6idpq365vivady9fh504r5"))))
+ (base32 "1ybznf4y5lda6bn163jcvj281qzhm24dfcwhbgxmm5n6f27gdccl"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-clunit))
(inputs
- (list sbcl-cl-base64 sbcl-trivial-indent sbcl-trivial-mimes))
- (synopsis "LASS (Lisp Augmented Style Sheets) compiles Lisp to CSS")
+ (list sbcl-alexandria sbcl-anaphora sbcl-let-plus))
+ (home-page "https://github.com/tpapp/cl-slice")
+ (synopsis "Array slices for Common Lisp")
(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))))
+ "This package provides a DSL for array slices in Common Lisp.")
+ (license license:expat))))
-(define-public cl-lass
- (sbcl-package->cl-source-package sbcl-lass))
+(define-public cl-slice
+ (sbcl-package->cl-source-package sbcl-cl-slice))
-(define-public ecl-lass
- (sbcl-package->ecl-package sbcl-lass))
+(define-public ecl-cl-slice
+ (sbcl-package->ecl-package sbcl-cl-slice))
-(define-public sbcl-xhtmlambda
- (let ((commit "c86376bccebf77ca428e8033df2ba7d8450ea1e8")
- (revision "0"))
+(define-public sbcl-cl-slug
+ (let ((commit "ffb229d10f0d3f7f54e706791725225e200bf749")
+ (revision "1"))
(package
- (name "sbcl-xhtmlambda")
- (version
- ;; The source repository doesn't provide any version nor revision, but
- ;; a timestamp
- (git-version "2022-01-21" revision commit))
+ (name "sbcl-cl-slug")
+ (version (git-version "0.4.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/xhtmlambda/XHTMLambda")
+ (url "https://github.com/EuAndreh/cl-slug")
(commit commit)))
- (file-name (git-file-name "cl-xhtmlambda" version))
+ (file-name (git-file-name "cl-slug" version))
(sha256
- (base32 "0narbzz06ry1wn048avm1fwihvnjvvc4wfcv5hmdazkilpvnqz2y"))))
+ (base32 "1asdq6xllmsvfw5fky9wblqcx9isac9jrrlkfl7vyxcq1wxrnflx"))))
(build-system asdf-build-system/sbcl)
- (inputs (list sbcl-cl-unicode))
- (synopsis "(X)HTML library for Common Lisp")
+ (native-inputs
+ (list sbcl-prove))
+ (inputs
+ `(("ppcre" ,sbcl-cl-ppcre)))
+ (home-page "https://github.com/EuAndreh/cl-slug")
+ (synopsis "Multi-language slug formatter")
(description
- "(X)HTMLambda is yet another (X)HTML library which
-emphasizes programmability and user-friendliness. Each (X)HTML element is a
-structured object and pretty-printing of (X)HTML trees is well defined to
-provide properly indented human-readable output even for complex recursive
-arrangements.")
- (home-page "https://xhtmlambda.common-lisp.dev/")
- (license license:expat))))
+ "This is a small Common Lisp library to make slugs, mainly for URIs,
+from English and beyond.")
+ (license license:llgpl))))
-(define-public cl-xhtmlambda
- (sbcl-package->cl-source-package sbcl-xhtmlambda))
+(define-public cl-slug
+ (sbcl-package->cl-source-package sbcl-cl-slug))
-(define-public sbcl-clad
- (let ((commit "1ff6f417d4ee3836d1edd96923d4b03f3cafa849")
+(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-clad")
- (version
- ;; There's no version, but there's a timestamp
- (git-version "2023-01-21" revision commit))
+ (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/mantoniotti/CLAD")
+ (url "https://gitlab.common-lisp.net/cl-smtp/cl-smtp")
(commit commit)))
- (file-name (git-file-name "cl-clad" version))
+ (file-name (git-file-name "cl-smtp" version))
(sha256
- (base32 "184mhdq7pxd6hd4rzv8z4lfbwnkyhgm5bdn3xsqaav2j0d1dqm6i"))
- (modules '((guix build utils)))
- (snippet
- ;; Delete compiled ABCL files.
- '(begin
- (delete-file "clad-package.abcl")
- (delete-file "clad.abcl")))))
+ (base32 "0vjjfapcrdc5671jz2d24h8zvpz7skq1x6pi9fvw6ls5sgms6fr0"))))
(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
+ (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-clad
- (sbcl-package->cl-source-package sbcl-clad))
+(define-public cl-smtp
+ (sbcl-package->cl-source-package sbcl-cl-smtp))
-(define-public sbcl-plump
- (let ((commit "0c3e0b57b43b6e0c5794b6a902f1cf5bee2a2927")
- (revision "3"))
+(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-plump")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-cl-spark")
+ (version (git-version "0.1.13" 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://github.com/tkych/cl-spark")
+ (commit commit)))
+ (file-name (git-file-name "cl-spark" version))
(sha256
- (base32 "1fyb66pqvr1iy31ah9638ihs8cax17zkxk0zq14jy7x5l9rq1qlf"))))
+ (base32 "0my1fsgi2rjaqkpk934f2bjy63pmnj7faza3fzvnk6k3l66y19nk"))))
(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))))
+ (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-plump
- (sbcl-package->cl-source-package sbcl-plump))
+(define-public cl-spark
+ (sbcl-package->cl-source-package sbcl-cl-spark))
-(define-public ecl-plump
- (sbcl-package->ecl-package sbcl-plump))
+(define-public ecl-cl-spark
+ (sbcl-package->ecl-package sbcl-cl-spark))
-(define-public sbcl-plump-sexp
- (let ((commit "bbcf75e9ecda8fe7603098ab8c15828407bb4f08")
- (revision "0"))
+(define-public sbcl-cl-speedy-queue
+ (let ((commit "0425c7c62ad3b898a5ec58cd1b3e74f7d91eec4b")
+ (revision "1"))
(package
- (name "sbcl-plump-sexp")
- (version (git-version "0.1.0" revision commit))
+ (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/Shinmera/plump-sexp")
- (commit commit)))
- (file-name (git-file-name "cl-plump-sexp" version))
+ (uri (git-reference
+ (url "https://github.com/zkat/cl-speedy-queue")
+ (commit commit)))
+ (file-name (git-file-name "cl-speedy-queue" version))
(sha256
- (base32
- "0zm9h0assjb8766z2v6l1k1s60y90y6f8smrl1dczwqlvc8xyln5"))))
+ (base32 "0czhnvxn9lvbjz9h1lb7y18nqrsq3drq5icd3lqdaa07362alriq"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-plump))
- (synopsis "Convert S-expressions into a Plump DOM and back")
+ (home-page "https://github.com/zkat/cl-speedy-queue")
+ (synopsis "Lightweight optimized queue 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))))
+ "This is a lightweight, non-consing, optimized queue implementation for
+Common Lisp.")
+ (license license:expat))))
-(define-public cl-plump-sexp
- (sbcl-package->cl-source-package sbcl-plump-sexp))
+(define-public cl-speedy-queue
+ (sbcl-package->cl-source-package sbcl-cl-speedy-queue))
-(define-public ecl-plump-sexp
- (sbcl-package->ecl-package sbcl-plump-sexp))
+(define-public ecl-cl-speedy-queue
+ (sbcl-package->ecl-package sbcl-cl-speedy-queue))
-;;; 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-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-antik-base")
+ (name "sbcl-cl+ssl")
(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/cl-plus-ssl/cl-plus-ssl")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl+ssl" version))
(sha256
- (base32
- "047ga2c38par2xbgg4qx6hwv06qhf1c1f67as8xvir6s80lip1km"))))
+ (base32 "0v0kx2m5355jkdshmj0z923c5rlvdl2n11rb3hjbv3kssdfsbs0s"))))
(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
+ '(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-build
+ (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 _
- (for-each delete-file
- '("antik.asd"
- "physical-dimension.asd"
- "science-data.asd"))
- #t)))))
- (synopsis "Scientific and engineering computation in Common Lisp")
+ ;; 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
- "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))))
+ "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-antik-base
- (sbcl-package->cl-source-package sbcl-antik-base))
+(define-public cl-cl+ssl
+ (sbcl-package->cl-source-package sbcl-cl+ssl))
-(define-public ecl-antik-base
- (let ((pkg (sbcl-package->ecl-package sbcl-antik-base)))
+(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)
- ((#:phases phases)
- `(modify-phases ,phases
- (add-after 'unpack 'fix-readtable
- (lambda _
- (substitute* "input-output/readtable.lisp"
- (("#-ccl")
- "#-(or ccl ecl)"))
- #t)))))))))
+ ((#:tests? _ #f) #f))))))
-(define-public sbcl-gsll
- (let ((commit "1a8ada22f9cf5ed7372d352b2317f4ccdb6ab308")
+(define-public sbcl-cl-steamworks
+ (let ((commit "9d6a4de653a8cc256ae35e0298912b518aa92ba3")
(revision "1"))
(package
- (name "sbcl-gsll")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-steamworks")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/antik/gsll.git")
+ (url "https://github.com/Shinmera/cl-steamworks/")
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32
- "0z5nypfk26hxihb08p085644afawicrgb4xvadh3lmrn46qbjfn4"))))
+ (base32 "1fzj3rlqw1kwdlmh0ga0y71p2n1adflcamzx4yp9kga552c1db5j"))
+ (file-name (git-file-name "cl-steamworks" version))))
(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))
+ (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 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-steamworks
+ (sbcl-package->cl-source-package sbcl-cl-steamworks))
-(define-public cl-antik
- (sbcl-package->cl-source-package sbcl-antik))
+(define-public ecl-cl-steamworks
+ (sbcl-package->ecl-package sbcl-cl-steamworks))
-(define-public sbcl-cl-interpol
- (let ((commit "70a1137f41dd8889004dbab9536b1adeac2497aa")
+(define-public sbcl-cl-store
+ (let ((commit "c787337a16ea8cf8a06227f35933a4ec774746b3")
(revision "1"))
(package
- (name "sbcl-cl-interpol")
- (version (git-version "0.2.7" revision commit))
+ (name "sbcl-cl-store")
+ (version (git-version "0.8.11" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/edicl/cl-interpol")
+ (url "https://github.com/skypher/cl-store")
(commit commit)))
- (file-name (git-file-name "cl-interpol" version))
+ (file-name (git-file-name name version))
(sha256
(base32
- "1kr00zf62m7la7rxa2m5w49r9cyzamc106hvjcc8ffmi7a4jw490"))))
+ "194srkg8nrym19c6i7zbnkzshc1qhqa82m53qnkirz9fw928bqxr"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-cl-unicode sbcl-named-readtables))
(native-inputs
- (list sbcl-flexi-streams))
- (synopsis "String interpolation for Common Lisp")
+ (list sbcl-rt))
+ (synopsis "Common Lisp library to serialize data")
(description
- "CL-INTERPOL is a library for Common Lisp which modifies the
-reader so that you can have interpolation within strings similar to
-Perl or Unix Shell scripts. It also provides various ways to insert
-arbitrary characters into literal strings even if your editor/IDE
-doesn't support them.")
- (home-page "https://edicl.github.io/cl-interpol/")
- (license license:bsd-3))))
+ "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-interpol
- (sbcl-package->cl-source-package sbcl-cl-interpol))
+(define-public cl-store
+ (sbcl-package->cl-source-package sbcl-cl-store))
-(define-public ecl-cl-interpol
- (sbcl-package->ecl-package sbcl-cl-interpol))
+(define-public ecl-cl-store
+ (sbcl-package->ecl-package sbcl-cl-store))
-(define-public sbcl-symbol-munger
- (let ((commit "e96558e8315b8eef3822be713354787b2348b25e")
- (revision "2"))
+(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-symbol-munger")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-cl-strftime")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/symbol-munger")
+ (url "https://github.com/ruricolist/cl-strftime/")
(commit commit)))
- (file-name (git-file-name "cl-symbol-munger" version))
+ (file-name (git-file-name name version))
(sha256
- (base32
- "16fshnxp9212503z1vjlmx5pafv14bzpihn486x1ljakqjigfnfz"))))
+ (base32 "00c8hq7vzgb89ab3q7mrp60x743kiqmsk1g51ynhxlqhph2bnslf"))))
(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")
+ (list sbcl-alexandria sbcl-local-time sbcl-cl-ppcre sbcl-serapeum))
+ (native-inputs
+ (list sbcl-fiveam sbcl-cffi))
+ (home-page "https://github.com/ruricolist/cl-strftime")
+ (synopsis "Common Lisp compiler for the strftime language")
(description
- "This 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
+ "CL-STRFTIME is a Common Lisp compiler for the strftime “language.”")
(license license:expat))))
-(define-public cl-symbol-munger
- (sbcl-package->cl-source-package sbcl-symbol-munger))
+(define-public cl-strftime
+ (sbcl-package->cl-source-package sbcl-cl-strftime))
-(define-public ecl-symbol-munger
- (sbcl-package->ecl-package sbcl-symbol-munger))
+(define-public ecl-cl-strftime
+ (sbcl-package->ecl-package sbcl-cl-strftime))
-(define-public sbcl-cl-csv
- (let ((commit "68ecb5d816545677513d7f6308d9e5e8d2265651")
- (revision "2"))
+(define-public sbcl-cl-string-match
+ (let ((revision "1")
+ (changeset "5048480a61243e6f1b02884012c8f25cdbee6d97"))
(package
- (name "sbcl-cl-csv")
- (version (git-version "1.0.6" revision commit))
+ (name "sbcl-cl-string-match")
+ (version (git-version "0" revision changeset))
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/AccelerationNet/cl-csv")
- (commit commit)))
- (file-name (git-file-name name version))
+ (method hg-fetch)
+ (uri (hg-reference
+ (url "https://github.com/vityok/cl-string-match")
+ (changeset changeset)))
(sha256
(base32
- "0gcmlbwx5m3kwgk12qi80w08ak8fgdnvyia429fz6gnxmhg0k54x"))))
+ "01wn5qx562w43ssy92xlfgv79w7p0nv0wbl76mpmba131n9ziq2y"))
+ (file-name (git-file-name "cl-string-match" version))))
(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)))
+ ("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
- (list sbcl-lisp-unit2))
- (synopsis "Common lisp library for comma-separated values")
+ ;; 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
- "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")
+ "@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-csv
- (sbcl-package->cl-source-package sbcl-cl-csv))
+(define-public cl-string-match
+ (sbcl-package->cl-source-package sbcl-cl-string-match))
-(define-public ecl-cl-csv
- (sbcl-package->ecl-package sbcl-cl-csv))
+(define-public ecl-cl-string-match
+ (sbcl-package->ecl-package sbcl-cl-string-match))
-(define-public sbcl-external-program
- (let ((commit "5888b8f1fd3953feeeacecbba4384ddda584a749")
- (revision "1"))
+(define-public sbcl-cl-strings
+ (let ((revision "1")
+ (commit "93ec4177fc51f403a9f1ef0a8933f36d917f2140"))
(package
- (name "sbcl-external-program")
- (version (git-version "0.0.6" revision commit))
+ (name "sbcl-cl-strings")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sellout/external-program")
+ (url "https://github.com/diogoalexandrefranco/cl-strings")
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32
- "0vww1x3yilb3bjwg6k184vaj4vxyxw4vralhnlm6lk4xac67kc9z"))))
+ (base32 "1j8hs54fn0wsf5zfzhhgiva47n9hsmfa74iinahz6nmcs8iy75aj"))
+ (file-name (git-file-name "cl-strings" version))))
(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 "Set of utilities to manipulate strings in 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))))
+ "@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-external-program
- (sbcl-package->cl-source-package sbcl-external-program))
+(define-public cl-strings
+ (sbcl-package->cl-source-package sbcl-cl-strings))
-(define-public ecl-external-program
- (sbcl-package->ecl-package sbcl-external-program))
+(define-public ecl-cl-strings
+ (sbcl-package->ecl-package sbcl-cl-strings))
-(define-public sbcl-cl-ana
- (let ((commit "848185eed1ed65bab3a124870c122f761ce0d87e")
- (revision "2"))
+(define-public sbcl-cl-svg
+ (let ((commit "1e988ebd2d6e2ee7be4744208828ef1b59e5dcdc")
+ (revision "1"))
(package
- (name "sbcl-cl-ana")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-svg")
+ (version (git-version "0.0.3" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/ghollisjr/cl-ana")
+ (url "https://github.com/wmannis/cl-svg")
(commit commit)))
- (file-name (git-file-name "cl-ana" version))
+ (file-name (git-file-name "cl-svg" version))
(sha256
- (base32 "026agqsxq3pg2k9jmy2wysil2z0yn5rykzzhr8rqxsspdwz51z1y"))))
+ (base32 "11rmzimy6j7ln7q5y1h2kw1225rsfb6fpn89qjcq7h5lc8fay0wz"))))
(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")
+ (home-page "https://github.com/wmannis/cl-svg")
+ (synopsis "Write SVG file format")
(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))))
+ "This package provides the @code{CL-SVG} Common Lisp system to produce
+Scalable Vector Graphics files.")
+ (license license:expat))))
-(define-public cl-ana
- (sbcl-package->cl-source-package sbcl-cl-ana))
+(define-public cl-svg
+ (sbcl-package->cl-source-package sbcl-cl-svg))
-(define-public sbcl-eazy-gnuplot
- (let ((commit "2eb900fe2557e6c066a9851c166e572c25bc0996")
- (revision "0"))
+(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-eazy-gnuplot")
- (version (git-version "0.2.0" revision commit))
+ (name "sbcl-cl-sxml")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/eazy-gnuplot")
+ (url "https://github.com/eadmund/cl-sxml")
(commit commit)))
- (file-name (git-file-name "cl-eazy-gnuplot" version))
+ (file-name (git-file-name "cl-sxml" version))
(sha256
- (base32 "0mpkx1z52riahydzvqv7kk15p0pv2k7k5a7j65fg571kcxmssx8s"))
- (patches (search-patches "sbcl-eazy-gnuplot-skip-path-check.patch"))))
+ (base32 "1105s9whidq1lf0lli2wdhcfcs5gwzxa0h1x3izx4mp2p7psvciz"))))
(build-system asdf-build-system/sbcl)
+ (inputs (list sbcl-cxml))
(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")
+ (list sbcl-fiveam
+ sbcl-flexi-streams))
+ (home-page "https://github.com/eadmund/cl-sxml")
+ (synopsis "SXML parsing for Common Lisp")
(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))))
+ "@code{CL-SXML} implements Oleg Kiselyov’s SXML, an S-expression-based
+rendering of the XML Infoset.")
+ (license license:gpl3+))))
-(define-public cl-eazy-gnuplot
- (sbcl-package->cl-source-package sbcl-eazy-gnuplot))
+(define-public cl-sxml
+ (sbcl-package->cl-source-package sbcl-cl-sxml))
-(define-public ecl-eazy-gnuplot
- (sbcl-package->ecl-package sbcl-eazy-gnuplot))
+(define-public ecl-cl-sxml
+ (sbcl-package->ecl-package sbcl-cl-sxml))
-(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 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-archive
- (sbcl-package->cl-source-package sbcl-archive))
+(define-public cl-syntax
+ (sbcl-package->cl-source-package sbcl-cl-syntax))
-(define-public ecl-archive
- (sbcl-package->ecl-package sbcl-archive))
+(define-public ecl-cl-syntax
+ (sbcl-package->ecl-package sbcl-cl-syntax))
-(define-public sbcl-tar-file
- (let ((commit "0c10bc82f14702c97a26dc25ce075b5d3a2347d1")
+(define-public sbcl-cl-syslog
+ (let ((commit "d5d46f777f0735938e6f650cf17d814b88b70305")
(revision "0"))
(package
- (name "sbcl-tar-file")
- (version (git-version "0.2.1" revision commit))
+ (name "sbcl-cl-syslog")
+ (version (git-version "0.2.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-tar/cl-tar-file")
+ (url "https://github.com/mmaul/cl-syslog")
(commit commit)))
- (file-name (git-file-name "cl-tar-file" version))
+ (file-name (git-file-name "cl-syslog" version))
(sha256
- (base32 "0i8j05fkgdqy4c4pqj0c68sh4s3klpx9kc5wp73qwzrl3xqd2svy"))))
+ (base32 "1qcz55jiqwk91b01hsahxnha884f6zf2883j2m51sqph0mvj69mh"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
(inputs
- (list sbcl-40ants-doc
- sbcl-alexandria
+ (list 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}.")
+ 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-tar-file
- (sbcl-package->cl-source-package sbcl-tar-file))
+(define-public cl-syslog
+ (sbcl-package->cl-source-package sbcl-cl-syslog))
-(define-public ecl-tar-file
- (sbcl-package->ecl-package sbcl-tar-file))
+(define-public ecl-cl-syslog
+ (sbcl-package->ecl-package sbcl-cl-syslog))
-(define-public sbcl-tar
- (let ((commit "7c6e07a10c93d9e311f087b5f6328cddd481669a")
+(define-public sbcl-cl-template
+ (let ((commit "46193a9a389bb950530e579eae7e6e5a18184832")
(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))))
+ (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-tar
- (sbcl-package->cl-source-package sbcl-tar))
+(define-public cl-template
+ (sbcl-package->cl-source-package sbcl-cl-template))
-(define-public ecl-tar
- (sbcl-package->ecl-package sbcl-tar))
+(define-public ecl-cl-template
+ (sbcl-package->ecl-package sbcl-cl-template))
-(define-public sbcl-misc-extensions
- (let ((commit "101c05112bf2f1e1bbf527396822d2f50ca6327a")
- (revision "1"))
+(define-public sbcl-cl-tga
+ (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
+ (revision "0"))
(package
- (name "sbcl-misc-extensions")
- (version (git-version "3.3" revision commit))
+ (name "sbcl-cl-tga")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/misc-extensions/devel.git")
+ (url "https://github.com/fisxoj/cl-tga")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0gz5f4p70qzilnxsnf5lih2n9m4wjcw8hlw4w8mpn9jyhyppyyv0"))))
+ (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Collection of small macros and extensions for Common Lisp")
+ (home-page "https://github.com/fisxoj/cl-tga")
+ (synopsis "TGA file loader 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)))
+ "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-mt19937
- (sbcl-package->cl-source-package sbcl-mt19937))
+(define-public cl-tga
+ (sbcl-package->cl-source-package sbcl-cl-tga))
-(define-public ecl-mt19937
- (sbcl-package->ecl-package sbcl-mt19937))
+(define-public ecl-cl-tga
+ (sbcl-package->ecl-package sbcl-cl-tga))
-(define-public sbcl-fset
- (let ((commit "6d2f9ded8934d2b42f2571a0ba5bda091037d852")
- (revision "1"))
+(define-public sbcl-cl-tld
+ ;; No release.
+ (let ((commit "f5014da8d831fa9481d4181d4450f10a52850c75"))
(package
- (name "sbcl-fset")
- (version (git-version "1.3.2" revision commit))
+ (name "sbcl-cl-tld")
+ (version (git-version "0.1" "2" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slburson/fset")
+ (url "https://github.com/lu4nx/cl-tld")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "127acblwrbqicx47h6sgvknz1cqyfn8p4xkhkn1m7hxh8w5gk1zy"))
- (snippet '(begin
- ;; Remove obsolete copy of system definition.
- (delete-file "Code/fset.asd")
- #t))))
+ (base32 "0sxnn35gzdby1ixil6zbjg72vli9fcspwzsqimqk455310syx9iv"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-misc-extensions sbcl-mt19937 sbcl-named-readtables))
- (synopsis "Functional set-theoretic collections library")
+ (home-page "https://github.com/lu4nx/cl-tld/")
+ (synopsis "Extract the Top Level Domain from domains, in Common Lisp")
(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))))
+ "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-fset
- (sbcl-package->cl-source-package sbcl-fset))
+(define-public cl-tld
+ (sbcl-package->cl-source-package sbcl-cl-tld))
-(define-public ecl-fset
- (package
- (inherit (sbcl-package->ecl-package sbcl-fset))
- (arguments
- ;; Tests fails on ECL with "The function FSET::MAKE-CHAR is undefined".
- '(#:tests? #f))))
+(define-public ecl-cl-tld
+ (sbcl-package->ecl-package sbcl-cl-tld))
-(define-public sbcl-modf
- (let ((commit "dea93fe62c6bf7f66f32f52ac0c555aedbf7abad")
+(define-public sbcl-cl-tls
+ (let ((commit "2ab4fc3ae7e79e451126a9bb6bc38ca2cd2cb4ba")
(revision "0"))
(package
- (name "sbcl-modf")
- (version (git-version "0" revision commit))
+ (name "sbcl-cl-tls")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/smithzvk/modf")
+ (url "https://github.com/shrdlu68/cl-tls")
(commit commit)))
- (file-name (git-file-name "cl-modf" version))
+ (file-name (git-file-name "cl-tls" version))
(sha256
- (base32
- "1aap7ldy7lv942khp026pgndgdzfkkqa9xcq1ykinrmflrgdazay"))))
+ (base32 "1j6gwv21ibkk6xd1xxm54wgwp09dzqg60b8z72hivpnq8gwm0ba7"))))
(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.")
+ 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-modf
- (sbcl-package->cl-source-package sbcl-modf))
+(define-public cl-tls
+ (sbcl-package->cl-source-package sbcl-cl-tls))
-(define-public ecl-modf
- (sbcl-package->ecl-package sbcl-modf))
+(define-public ecl-cl-tls
+ (sbcl-package->ecl-package sbcl-cl-tls))
-(define-public sbcl-cl-cont
- (let ((commit "fc1fa7e6eb64894fdca13e688e6015fad5290d2a")
+(define-public sbcl-cl-typesetting
+ (let ((commit "86eba981fc4254addebecf765578ec350d6e3b75")
(revision "1"))
(package
- (name "sbcl-cl-cont")
- (version (git-version "0.3.8" revision commit))
+ (name "sbcl-cl-typesetting")
+ (version (git-version "0.8.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-cont/cl-cont.git")
+ (url "https://github.com/mbattyani/cl-typesetting")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-typesetting" version))
(sha256
- (base32
- "1zf8zvb0i6jm3hhfks4w74hibm6avgc6f9s1qwgjrn2bcik8lrvz"))))
+ (base32 "0fcs5mq0gxfczbrg7ay8r4bf5r4g6blvpdbjkhcl8dapcikyn35h"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ ;; NOTE: (Sharlatan-20210515T213014+0100): Circular dependencies with
+ ;; cl-typegraph
+ `(#:tests? #f))
(inputs
- (list sbcl-alexandria sbcl-closer-mop))
- (native-inputs
- (list sbcl-rt))
- (synopsis "Delimited continuations for Common Lisp")
+ `(("cl-pdf" ,sbcl-cl-pdf)
+ ("xmls" ,sbcl-xmls)))
+ (home-page "https://github.com/mbattyani/cl-typesetting")
+ (synopsis "Stand-alone Common Lisp typesetting system")
(description
- "This 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))))
+ "CL-TYPESETTING is a cross-platform Common Lisp typesetting library for
+all kind of typesetting applications.")
+ (license license:bsd-2))))
-(define-public cl-cont
- (sbcl-package->cl-source-package sbcl-cl-cont))
+(define-public cl-typesetting
+ (sbcl-package->cl-source-package sbcl-cl-typesetting))
-(define-public ecl-cl-cont
- (sbcl-package->ecl-package sbcl-cl-cont))
+(define-public ecl-cl-typesetting
+ (sbcl-package->ecl-package sbcl-cl-typesetting))
-(define-public sbcl-cl-coroutine
- (let ((commit "de098f8d5debd8b14ef6864b5bdcbbf5ddbcfd72")
+(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-coroutine")
+ (name "sbcl-cl-uglify-js")
(version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/takagi/cl-coroutine")
+ (url "https://github.com/mishoo/cl-uglify-js")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-uglify-js" version))
(sha256
(base32
- "1cqdhdjxffgfs116l1swjlsmcbly0xgcgrckvaajd566idj9yj4l"))))
+ "0k39y3c93jgxpr7gwz7w0d8yknn1fdnxrjhd03057lvk5w8js27a"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-cont" ,sbcl-cl-cont)))
- (native-inputs
- (list sbcl-prove))
- (arguments
- `(;; TODO: Fix the tests. They fail with:
- ;; "Component CL-COROUTINE-ASD::CL-COROUTINE-TEST not found"
- #:tests? #f
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "cl-coroutine-test.asd"
- (("cl-test-more")
- "prove"))
- #t)))))
- (synopsis "Coroutine library for Common Lisp")
- (description
- "This is a coroutine library for Common Lisp implemented using the
-continuations of the @code{cl-cont} library.")
- (home-page "https://github.com/takagi/cl-coroutine")
- (license license:llgpl))))
+ (list sbcl-parse-js sbcl-cl-ppcre sbcl-cl-ppcre-unicode
+ sbcl-parse-number sbcl-iterate))
+ (home-page "https://github.com/mishoo/cl-uglify-js")
+ (synopsis "JavaScript compressor library for Common Lisp")
+ (description "This is a Common Lisp version of UglifyJS, a JavaScript
+compressor. It works on data produced by @code{parse-js} to generate a
+@dfn{minified} version of the code. Currently it can:
-(define-public cl-coroutine
- (sbcl-package->cl-source-package sbcl-cl-coroutine))
+@itemize
+@item reduce variable names (usually to single letters)
+@item join consecutive @code{var} statements
+@item resolve simple binary expressions
+@item group most consecutive statements using the @code{sequence} operator (comma)
+@item remove unnecessary blocks
+@item convert @code{IF} expressions in various ways that result in smaller code
+@item remove some unreachable code
+@end itemize\n")
+ (license license:zlib))))
-(define-public ecl-cl-coroutine
- (sbcl-package->ecl-package sbcl-cl-coroutine))
+(define-public cl-uglify-js
+ (sbcl-package->cl-source-package sbcl-cl-uglify-js))
-(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-cl-uglify-js
+ (sbcl-package->ecl-package sbcl-cl-uglify-js))
-(define-public ecl-vas-string-metrics
- (sbcl-package->ecl-package sbcl-vas-string-metrics))
+(define-public uglify-js
+ (package
+ (inherit sbcl-cl-uglify-js)
+ (name "uglify-js")
+ (build-system trivial-build-system)
+ (arguments
+ `(#:modules ((guix build utils))
+ #:builder
+ (let* ((bin (string-append (assoc-ref %outputs "out") "/bin/"))
+ (script (string-append bin "uglify-js")))
+ (use-modules (guix build utils))
+ (mkdir-p bin)
+ (with-output-to-file script
+ (lambda _
+ (format #t "#!~a/bin/sbcl --script
-(define-public cl-vas-string-metrics
- (sbcl-package->cl-source-package sbcl-vas-string-metrics))
+ (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-vom
- (let ((commit "1aeafeb5b74c53741b79497e0ef4acf85c92ff24")
+(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-vom")
- (version (git-version "0.1.4" revision commit))
+ (name "sbcl-cl-unification")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/vom")
+ (url "https://gitlab.common-lisp.net/cl-unification/cl-unification")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-unification" version))
(sha256
- (base32
- "0536kppj76ax4lrxhv42npkfjsmx45km2g439vf9jmw3apinz9cy"))))
+ (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Tiny logging utility for Common Lisp")
+ (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
- "Vom is a logging library for Common Lisp. It's goal is to be useful
-and small. It does not provide a lot of features as other loggers do, but
-has a small codebase that's easy to understand and use.")
- (home-page "https://github.com/orthecreedence/vom")
- (license license:expat))))
+ "This 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-vom
- (sbcl-package->cl-source-package sbcl-vom))
+(define-public cl-unification
+ (sbcl-package->cl-source-package sbcl-cl-unification))
-(define-public ecl-vom
- (sbcl-package->ecl-package sbcl-vom))
+(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-libuv
- (let ((commit "32100c023c518038d0670a103eaa4d50dd785d29")
+(define-public sbcl-cl-utilities
+ (let ((commit "dce2d2f6387091ea90357a130fa6d13a6776884b")
(revision "1"))
(package
- (name "sbcl-cl-libuv")
- (version (git-version "0.1.6" revision commit))
+ (name "sbcl-cl-utilities")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/orthecreedence/cl-libuv")
- (commit commit)))
- (file-name (git-file-name name version))
+ (method url-fetch)
+ (uri
+ (string-append
+ "https://gitlab.common-lisp.net/cl-utilities/cl-utilities/-/"
+ "archive/" commit "/cl-utilities-" commit ".tar.gz"))
(sha256
- (base32
- "1kwix4si8a8hza34ab2k7whrh7z0yrmx39v2wc3qblv9m244jkh1"))))
+ (base32 "1r46v730yf96nk2vb24qmagv9x96xvd08abqwhf02ghgydv1a7z2"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cffi" ,sbcl-cffi)
- ("libuv" ,libuv)))
(arguments
- `(#:phases
+ '(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-paths
(lambda* (#:key inputs #:allow-other-keys)
- (substitute* "lib.lisp"
- (("/usr/lib/libuv.so")
- (search-input-file inputs "/lib/libuv.so")))))
- (add-after 'fix-paths 'fix-system-definition
- (lambda _
- (substitute* "cl-libuv.asd"
- (("#:cffi #:alexandria")
- "#:cffi #:cffi-grovel #:alexandria"))
- #t)))))
- (synopsis "Common Lisp bindings to libuv")
+ (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
- "This library provides low-level libuv bindings for Common Lisp.")
- (home-page "https://github.com/orthecreedence/cl-libuv")
- (license license:expat))))
+ "On Cliki.net <http://www.cliki.net/Common%20Lisp%20Utilities>, there
+is a collection of Common Lisp Utilities, things that everybody writes since
+they're not part of the official standard. There are some very useful things
+there; the only problems are that they aren't implemented as well as you'd
+like (some aren't implemented at all) and they aren't conveniently packaged
+and maintained. It takes quite a bit of work to carefully implement utilities
+for common use, commented and documented, with error checking placed
+everywhere some dumb user might make a mistake.")
+ (license license:public-domain))))
-(define-public cl-libuv
- (sbcl-package->cl-source-package sbcl-cl-libuv))
+(define-public cl-utilities
+ (sbcl-package->cl-source-package sbcl-cl-utilities))
-(define-public ecl-cl-libuv
- (sbcl-package->ecl-package sbcl-cl-libuv))
+(define-public ecl-cl-utilities
+ (sbcl-package->ecl-package sbcl-cl-utilities))
-(define-public sbcl-cl-async
- (let ((commit "f6423e44404a44434d803605e0d2e17199158e28")
- (revision "1"))
+(define-public sbcl-cl-variates
+ (let ((commit "4e7548754d8a8731a42487fae31174db4bf36d47")
+ (revision "0"))
(package
- (name "sbcl-cl-async")
- (version (git-version "0.6.1" revision commit))
+ (name "sbcl-cl-variates")
+ (version "0.9.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/cl-async")
+ (url "https://gitlab.common-lisp.net/cl-variates/cl-variates")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-variates" version))
(sha256
- (base32
- "11xi9dxb8mjgwzrkj88i0xkgk26z9w9ddxzbv6xsvfc1d4x5cf4x"))))
+ (base32 "03wnvfi3yfflpvi0mr732r834msij4vrwdbgf6csh0b8kqxl47zn"))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("babel" ,sbcl-babel)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("cl-libuv" ,sbcl-cl-libuv)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("fast-io" ,sbcl-fast-io)
- ("openssl" ,openssl)
- ("static-vectors" ,sbcl-static-vectors)
- ("trivial-features" ,sbcl-trivial-features)
- ("trivial-gray-streams" ,sbcl-trivial-gray-streams)
- ("vom" ,sbcl-vom)))
- (arguments
- `(#:asd-systems '("cl-async"
- "cl-async-repl"
- "cl-async-ssl")
- #:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "src/ssl/package.lisp"
- (("libcrypto\\.so")
- (search-input-file inputs "/lib/libcrypto.so"))
- (("libssl\\.so")
- (search-input-file inputs "/lib/libssl.so"))))))))
- (synopsis "Asynchronous operations for Common Lisp")
- (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/")
+ ;; USE-PACKAGE #<PACKAGE "CL-VARIATES"> causes name-conflicts in
+ ;; #<PACKAGE "CL-VARIATES-TEST"> between the following symbols:
+ ;; CL-VARIATES:RANDOM-ELEMENT, LIFT:RANDOM-ELEMENT
+ (arguments (list #:tests? #f))
+ (native-inputs (list sbcl-lift))
+ (home-page "https://gitlab.common-lisp.net/cl-variates/cl-variates")
+ (synopsis "Portable Common Lisp Random Number Generation")
+ (description "The variates package provides portable random number
+generation as well as numerous distributions.")
(license license:expat))))
-(define-public cl-async
- (sbcl-package->cl-source-package sbcl-cl-async))
+(define-public cl-variates
+ (sbcl-package->cl-source-package sbcl-cl-variates))
-(define-public ecl-cl-async
- (sbcl-package->ecl-package sbcl-cl-async))
+(define-public ecl-cl-variates
+ (sbcl-package->ecl-package sbcl-cl-variates))
-(define-public sbcl-classimp
- (let ((commit "d82a14c59bc733f89a1ea0b3447ebedddce5756e")
+(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-classimp")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-cl-vorbis")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/classimp")
+ (url "https://github.com/Shirakumo/cl-vorbis")
(commit commit)))
- (file-name (git-file-name "cl-classimp" version))
+ (file-name (git-file-name "cl-vorbis" version))
(sha256
- (base32 "0pbnz6cf1zb2ayk4kbw0gphjb8nflnjns2rwhv86jz0kf0z1hqha"))))
+ (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
- (list
- #:phases
- #~(modify-phases %standard-phases
- (add-after 'unpack 'patch-assimp-lib-path
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "library.lisp"
- (("libassimp.so.5" _)
- (search-input-file inputs "/lib/libassimp.so.5.0.0"))))))))
+ `(#: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 assimp-5.0
+ (list libvorbis
sbcl-cffi
- sbcl-split-sequence))
- (home-page "https://github.com/3b/classimp")
- (synopsis "Common Lisp CFFI bindings for Open Asset Import Library")
- (description
- "This package provides CFFI bindings to the @acronym{ASSIMP, Asset
-Import} library for Common Lisp.")
- (license license:expat))))
+ 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))))
-;; FIXME: The cl and ecl packages get the latest version of assimp as
-;; dependency instead of the one specified in the sbcl package. Specifying
-;; the dependencies explicitly works around the issue.
-(define-public cl-classimp
- (let ((pkg (sbcl-package->cl-source-package sbcl-classimp)))
- (package
- (inherit pkg)
- (inputs
- (list assimp-5.0
- cl-cffi
- cl-split-sequence)))))
+(define-public cl-vorbis
+ (sbcl-package->cl-source-package sbcl-cl-vorbis))
-(define-public ecl-classimp
- (let ((pkg (sbcl-package->ecl-package sbcl-classimp)))
- (package
- (inherit pkg)
- (inputs
- (list assimp-5.0
- ecl-cffi
- ecl-split-sequence)))))
+(define-public ecl-cl-vorbis
+ (sbcl-package->ecl-package sbcl-cl-vorbis))
-(define-public sbcl-blackbird
- (let ((commit "d361f81c1411dec07f6c2dcb11c78f7aea9aaca8")
- (revision "1"))
+(define-public sbcl-cl-wayland
+ (let ((commit "a92a5084b64102f538ab90212e99c7863e5338ae")
+ (revision "0"))
(package
- (name "sbcl-blackbird")
- (version (git-version "0.5.2" revision commit))
+ (name "sbcl-cl-wayland")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/blackbird")
+ (url "https://github.com/sdilts/cl-wayland")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-wayland" version))
(sha256
- (base32
- "0xfds5yaya64arzr7w1x38karyz11swzbhxx1afldpradj9dh19c"))))
+ (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-vom))
- (native-inputs
- (list sbcl-cl-async sbcl-fiveam))
- (synopsis "Promise implementation for Common Lisp")
+ (list sbcl-cffi
+ sbcl-closer-mop
+ wayland))
+ (home-page "https://github.com/sdilts/cl-wayland")
+ (synopsis "Common Lisp FFI bindings for libwayland")
(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))))
+ "This package provides Common Lisp FFI bindings for libwayland,
+primarily for the mahogany window manager.")
+ (license license:bsd-3))))
-(define-public cl-blackbird
- (sbcl-package->cl-source-package sbcl-blackbird))
+(define-public cl-wayland
+ (sbcl-package->cl-source-package sbcl-cl-wayland))
-(define-public ecl-blackbird
- (sbcl-package->ecl-package sbcl-blackbird))
+(define-public ecl-cl-wayland
+ (sbcl-package->ecl-package sbcl-cl-wayland))
-(define-public sbcl-cl-async-future
- (let ((commit "ee36c22a69a9516407458d2ed8b475f1fc473959")
- (revision "1"))
+(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-async-future")
- (version (git-version "0.4.4.1" revision commit))
+ (name "sbcl-cl-who")
+ (version (git-version version revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orthecreedence/cl-async-future")
+ (url "https://github.com/edicl/cl-who")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-who" version))
(sha256
(base32
- "0z0sc7qlzzxk99f4l26zp6rai9kv0kj0f599sxai5s44p17zbbvh"))))
+ "1rdvs113q6d46cblwhsv1vmm31p952wyzkyibqix0ypadpczlgp5"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-blackbird))
(native-inputs
- (list sbcl-cl-async sbcl-eos))
- (synopsis "Futures implementation for Common Lisp")
+ (list sbcl-flexi-streams))
+ (home-page "https://edicl.github.io/cl-who/")
+ (synopsis "Yet another Lisp markup language")
(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))))
+ "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-async-future
- (sbcl-package->cl-source-package sbcl-cl-async-future))
+(define-public cl-who
+ (sbcl-package->cl-source-package sbcl-cl-who))
-(define-public ecl-cl-async-future
- (sbcl-package->ecl-package sbcl-cl-async-future))
+(define-public ecl-cl-who
+ (sbcl-package->ecl-package sbcl-cl-who))
-(define-public sbcl-green-threads
- (let ((commit "fff5ebecb441a37e5c511773716aafd84a3c5840")
- (revision "1"))
+(define-public sbcl-cl-xmlspam
+ (let ((commit "ea06abcca2a73a9779bcfb09081e56665f94e22a"))
(package
- (name "sbcl-green-threads")
- (version (git-version "0.3" revision commit))
+ (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 "https://github.com/thezerobit/green-threads")
+ (url home-page)
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (string-append name "-" version))
(sha256
(base32
- "1czw7nr0dwfps76h8hjvglk1wdh53yqbfbvv30whwbgqx33iippz"))))
- (build-system asdf-build-system/sbcl)
+ "0w4rqvrgdgk3fwfq3kx4r7wwdr2bv3b6n3bdqwsiriw9psqzpz2s"))))
(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")
+ (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-green-threads
- (sbcl-package->cl-source-package sbcl-green-threads))
+(define-public cl-xmlspam
+ (sbcl-package->cl-source-package sbcl-cl-xmlspam))
-(define-public ecl-green-threads
- (sbcl-package->ecl-package sbcl-green-threads))
+(define-public ecl-cl-xmlspam
+ (sbcl-package->ecl-package sbcl-cl-xmlspam))
-(define-public sbcl-cl-base32
- (let ((commit "8cdee06fab397f7b0a19583b57e7f0c98405be85")
+(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-base32")
+ (name "sbcl-cl-yaml")
(version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hargettp/cl-base32")
+ (url "https://github.com/eudoxia0/cl-yaml")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-yaml" version))
(sha256
- (base32 "17jrng8jb05d64ggyd11hp308c2fl5drvf9g175blgrkkl8l4mf8"))))
+ (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-lisp-unit))
- (synopsis "Common Lisp library for base32 encoding and decoding")
+ (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 package provides functions for base32 encoding and decoding as
-defined in RFC4648.")
- (home-page "https://github.com/hargettp/cl-base32")
+ "This is a YAML parser and emitter for Common Lisp built on top of
+libyaml.")
(license license:expat))))
-(define-public cl-base32
- (sbcl-package->cl-source-package sbcl-cl-base32))
+(define-public cl-yaml
+ (sbcl-package->cl-source-package sbcl-cl-yaml))
-(define-public ecl-cl-base32
- (sbcl-package->ecl-package sbcl-cl-base32))
+(define-public ecl-cl-yaml
+ (sbcl-package->ecl-package sbcl-cl-yaml))
(define-public sbcl-cl-z85
(let ((commit "85b3951a9cfa2603acb6aee15567684f9a108098")
@@ -12626,1557 +10087,875 @@ ZeroMQ.")
(define-public ecl-cl-z85
(sbcl-package->ecl-package sbcl-cl-z85))
-(define-public sbcl-ltk
- (let ((commit "ff14a781d211c19c35e65a7ecaece67dda0b3ebb")
- (revision "0"))
+(define-public sbcl-clache
+ (let ((commit "112976729565e1035532389ca25090ae99badd07"))
(package
- (name "sbcl-ltk")
- (version (git-version "0.992" revision commit))
+ (name "sbcl-clache")
+ (version (git-version "0.2.1" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/herth/ltk")
+ (url "https://github.com/html/clache/")
(commit commit)))
- (file-name (git-file-name "cl-ltk" version))
+ (file-name (git-file-name "cl-clache" version))
(sha256
- (base32 "0f1xgsj2j7bq21cq2pa9rw3ybxd9vyknisl6z307lxx7lvhm3xac"))))
+ (base32 "0wxg004bsay58vr6xr6mlk7wj415qmvisqxvpnjsg6glfwca86ys"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list imagemagick tk))
+ (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
- `(#:asd-systems '("ltk"
- "ltk-mw"
- "ltk-remote")
- #:tests? #f
- #:phases
+ `(#: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
+ (add-after 'unpack 'fix-tests
(lambda _
- (substitute* "ltk/ltk-remote.lisp"
- (("\\(:export")
- "(:shadow #:raise) (:export"))
+ (substitute* "clache-test.asd"
+ (("cl-test-more") "prove"))
#t)))))
- (synopsis "Common Lisp bindings for the Tk GUI toolkit")
+ (home-page "https://github.com/html/clache/")
+ (synopsis "General caching facility 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/")
+ "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-ltk
- (sbcl-package->cl-source-package sbcl-ltk))
+(define-public cl-clache
+ (sbcl-package->cl-source-package sbcl-clache))
-(define-public ecl-ltk
- (sbcl-package->ecl-package sbcl-ltk))
+(define-public ecl-clache
+ (sbcl-package->ecl-package sbcl-clache))
-(define-public sbcl-cl-lex
- (let ((commit "f2dbbe25ef553005fb402d9a6203180c3fa1093b")
- (revision "1"))
+(define-public sbcl-clack
+ (let ((commit "6fd0279424f7ba5fd4f92d69a1970846b0b11222")
+ (revision "2"))
(package
- (name "sbcl-cl-lex")
- (version (git-version "1.1.3" revision commit))
+ (name "sbcl-clack")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/djr7C4/cl-lex")
+ (url "https://github.com/fukamachi/clack")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clack" version))
(sha256
- (base32 "1kg50f76bfpfxcv4dfivq1n9a0xlsra2ajb0vd68lxwgbidgyc2y"))))
+ (base32 "0sfmvqmsg9z13x0v77448rpdqgyprdq739nsbrjw9a28hv9jmkg9"))))
(build-system asdf-build-system/sbcl)
+ (arguments
+ '(#:asd-systems '("clack"
+ "clack-handler-fcgi"
+ "clack-socket"
+ "clack-handler-hunchentoot")))
(inputs
- (list sbcl-cl-ppcre))
- (synopsis "Common Lisp macros for generating lexical analyzers")
+ (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
- "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)))
+ "Clack is a web application environment for Common Lisp inspired by
+Python's WSGI and Ruby's Rack.")
+ (license license:llgpl))))
-(define-public cl-colors2
- (sbcl-package->cl-source-package sbcl-cl-colors2))
+(define-public cl-clack
+ (sbcl-package->cl-source-package sbcl-clack))
-(define-public ecl-cl-colors2
- (sbcl-package->ecl-package sbcl-cl-colors2))
+(define-public ecl-clack
+ (sbcl-package->ecl-package sbcl-clack))
-(define-public sbcl-colored
- (let ((commit "bee87efb0b047da0f071f5cf1457997ab5f93feb")
- (revision "1"))
+(define-public sbcl-clad
+ (let ((commit "1ff6f417d4ee3836d1edd96923d4b03f3cafa849")
+ (revision "0"))
(package
- (name "sbcl-colored")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-clad")
+ (version
+ ;; There's no version, but there's a timestamp
+ (git-version "2023-01-21" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/colored/")
+ (url "https://gitlab.common-lisp.net/mantoniotti/CLAD")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clad" version))
(sha256
- (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k"))))
+ (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)
- (native-inputs
- (list sbcl-parachute))
- (inputs
- (list sbcl-documentation-utils))
- (synopsis "Colour representation, conversion, and operation for Common Lisp")
+ (synopsis "Library providing standard locations on the file system")
(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))
+ "The Common Lisp Application Directories (CLAD) library is
+a simple API collection that provides access to a set of @emph{standard}
+Common Lisp folders on a per-application or per-library basis.")
+ (home-page "https://gitlab.common-lisp.net/mantoniotti/CLAD")
+ (license license:expat)))) ;the mit-modern-variant is used
-(define-public ecl-colored
- (sbcl-package->ecl-package sbcl-colored))
+(define-public cl-clad
+ (sbcl-package->cl-source-package sbcl-clad))
-(define-public sbcl-cl-jpeg
- (let ((commit "ec557038128df6895fbfb743bfe8faf8ec2534af")
- (revision "1"))
+(define-public sbcl-clamp
+ (let ((commit "02b8f3953e5753cc61a719807c82f3795cd28fe1"))
(package
- (name "sbcl-cl-jpeg")
- (version (git-version "2.8" revision commit))
+ (name "sbcl-clamp")
+ (version (git-version "0.3" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/cl-jpeg")
+ (url "https://github.com/arclanguage/Clamp")
(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"))))
+ (base32 "0fdr9nqfmmpxm6hvjdxi1jkclya9xlnrw1yc3cn1m4ww3f50p31m"))))
(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-cl-jpeg-turbo
- (sbcl-package->ecl-package sbcl-jpeg-turbo))
-
-(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)
+ `(("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-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")
+ (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
- "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))
+ "Clamp is an attempt to bring the powerful, but verbose, language of
+Common Lisp up to the terseness of Arc.
-(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))))
+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-nodgui
- (sbcl-package->cl-source-package sbcl-nodgui))
+(define-public cl-clamp
+ (sbcl-package->cl-source-package sbcl-clamp))
-(define-public ecl-nodgui
- (sbcl-package->ecl-package sbcl-nodgui))
+(define-public ecl-clamp
+ (sbcl-package->ecl-package sbcl-clamp))
-(define-public sbcl-salza2
+(define-public sbcl-class-options
(package
- (name "sbcl-salza2")
- (version "2.1")
+ (name "sbcl-class-options")
+ (version "1.0.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))
+ (url "https://github.com/Hexstream/class-options")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-class-options" version))
(sha256
- (base32 "1p48lxdibnps5rpyh5cmnk0vc77bmmxb32qdzfz93zadr8wwas10"))))
+ (base32 "1dkgr1vbrsra44jznzz2bvdf8nlpdrrkjcqrfs8aa7axksda3bqk"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-chipz sbcl-flexi-streams sbcl-parachute))
+ (list sbcl-enhanced-boolean sbcl-parachute))
(inputs
- (list sbcl-trivial-gray-streams))
- (synopsis "Common Lisp library for zlib, deflate and gzip compression")
+ (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
- "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 easy access to the defining class and its options
+during initialization or reinitialization of its subcomponents.")
+ (license license:unlicense)))
-(define-public cl-salza2
- (sbcl-package->cl-source-package sbcl-salza2))
+(define-public cl-class-options
+ (sbcl-package->cl-source-package sbcl-class-options))
-(define-public ecl-salza2
- (sbcl-package->ecl-package sbcl-salza2))
+(define-public ecl-class-options
+ (sbcl-package->ecl-package sbcl-class-options))
-(define-public sbcl-origin
- (let ((commit "d646134302456408d6d43580bb05299f1695ab8e")
- (revision "1"))
+(define-public sbcl-classimp
+ (let ((commit "d82a14c59bc733f89a1ea0b3447ebedddce5756e")
+ (revision "0"))
(package
- (name "sbcl-origin")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-classimp")
+ (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/3b/classimp")
(commit commit)))
- (file-name (git-file-name "origin" version))
+ (file-name (git-file-name "cl-classimp" version))
(sha256
- (base32 "1n9aszaif3yh8prs5r8v51fbj4r5jd1a048mivd5yij3hplkm82b"))))
+ (base32 "0pbnz6cf1zb2ayk4kbw0gphjb8nflnjns2rwhv86jz0kf0z1hqha"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-parachute))
+ (arguments
+ (list
+ #:phases
+ #~(modify-phases %standard-phases
+ (add-after 'unpack 'patch-assimp-lib-path
+ (lambda* (#:key inputs #:allow-other-keys)
+ (substitute* "library.lisp"
+ (("libassimp.so.5" _)
+ (search-input-file inputs "/lib/libassimp.so.5.0.0"))))))))
(inputs
- (list sbcl-golden-utils sbcl-specialization-store))
- (home-page "https://git.mfiano.net/mfiano/origin")
- (synopsis "Common Lisp graphics math library")
+ (list assimp-5.0
+ sbcl-cffi
+ sbcl-split-sequence))
+ (home-page "https://github.com/3b/classimp")
+ (synopsis "Common Lisp CFFI bindings for Open Asset Import Library")
(description
- "This is a native Common Lisp graphics math library with an emphasis on
-performance and correctness.")
+ "This package provides CFFI bindings to the @acronym{ASSIMP, Asset
+Import} library for Common Lisp.")
(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-png-read
- (let ((commit "ec29f38a689972b9f1373f13bbbcd6b05deada88")
- (revision "1"))
+;; FIXME: The cl and ecl packages get the latest version of assimp as
+;; dependency instead of the one specified in the sbcl package. Specifying
+;; the dependencies explicitly works around the issue.
+(define-public cl-classimp
+ (let ((pkg (sbcl-package->cl-source-package sbcl-classimp)))
(package
- (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)
+ (inherit pkg)
(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))
+ (list assimp-5.0
+ cl-cffi
+ cl-split-sequence)))))
-(define-public ecl-png-read
- (sbcl-package->ecl-package sbcl-png-read))
+(define-public ecl-classimp
+ (let ((pkg (sbcl-package->ecl-package sbcl-classimp)))
+ (package
+ (inherit pkg)
+ (inputs
+ (list assimp-5.0
+ ecl-cffi
+ ecl-split-sequence)))))
-(define-public sbcl-3b-bmfont
- (let ((commit "332c2262705f161627fc18add0310451a42799af")
- (revision "3"))
+(define-public sbcl-clavier
+ (let ((commit "9b1424eaad131e114a45b400784079124b5e2321")
+ (revision "1"))
(package
- (name "sbcl-3b-bmfont")
- (version (git-version "0.0.1" 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/3b/3b-bmfont/")
+ (url "https://github.com/mmontone/clavier")
(commit commit)))
- (file-name (git-file-name "cl-3b-bmfont" version))
+ (file-name (git-file-name "cl-clavier" version))
(sha256
- (base32 "11wnqa1wx9vji6cmxl5m5qnf12mqc6n7d5g8038r1wayq88bxia6"))))
+ (base32 "1gjd0rhxs2x7gn3fw1hnxivmm4ca4f1wxlg0fqv8fdfabgzsvl5y"))))
(build-system asdf-build-system/sbcl)
- (arguments
- `(#:asd-systems '("3b-bmfont"
- "3b-bmfont/common"
- "3b-bmfont/json"
- "3b-bmfont/text"
- "3b-bmfont/xml")))
+ (native-inputs (list sbcl-stefil))
(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.")
+ 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 ecl-3b-bmfont
- (sbcl-package->ecl-package sbcl-3b-bmfont))
-
-(define-public cl-3b-bmfont
- (sbcl-package->cl-source-package sbcl-3b-bmfont))
+(define-public cl-clavier
+ (sbcl-package->cl-source-package sbcl-clavier))
-(define sbcl-3b-bmfont/shinmera
- (let ((commit "58e529d24b7799d56b4b3f9c8a953b585d42c7d2")
- (revision "1"))
- (package (inherit sbcl-3b-bmfont)
- (version (git-version "0.0.1" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/3b-bmfont/")
- (commit commit)))
- (file-name (git-file-name "3b-bmfont2" version))
- (sha256
- (base32 "17zby669b64rhxhk2szamzdgvispimh6ici05xa6x2vz4rvk71jq")))))))
+(define-public ecl-clavier
+ (sbcl-package->ecl-package sbcl-clavier))
-(define-public sbcl-sdf
- ;; Shinmera's fork required for Alloy.
- (let ((commit "e1ab3ac4ea52c0e0119b832f428c71f580b4d83b")
- (revision "1"))
+(define-public sbcl-claw
+ (let ((revision "0")
+ (commit "3cd4a96fca95eb9e8d5d069426694669f81b2250"))
(package
- (name "sbcl-sdf")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-claw")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/sdf")
+ (url "https://github.com/borodust/claw")
(commit commit)))
- (file-name (git-file-name "sdf" version))
+ (file-name (git-file-name "claw" version))
(sha256
- (base32 "1cyq4hkgiw9mnb87ah6xw19cybfs9hfbjvg1ch2mf4cr0ism0nvn"))))
+ (base32 "146yv0hc4hmk72562ssj2d41143pp84dcbd1h7f4nx1c7hf2bb0d"))))
(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")
+ (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 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 ecl-sdf
- (sbcl-package->ecl-package sbcl-sdf))
-
-(define-public cl-sdf
- (sbcl-package->cl-source-package sbcl-sdf))
-
-(define-public sbcl-zpng
- (package
- (name "sbcl-zpng")
- (version "1.2.2")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/xach/zpng")
- (commit (string-append "release-" version))))
- (file-name (git-file-name name version))
- (sha256
- (base32 "0b3ag3jhl3z7kdls3ahdsdxsfhhw5qrizk769984f4wkxhb69rcm"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-salza2))
- (synopsis "PNG encoder for Common Lisp")
- (description "This is a Common Lisp library for creating PNG images.")
- (home-page "https://www.xach.com/lisp/zpng/")
- (license license:bsd-2)))
+ "This is a Common Lisp autowrapping facility for quickly creating clean
+and lean bindings to C libraries.")
+ (license license:bsd-2))))
-(define-public cl-zpng
- (sbcl-package->cl-source-package sbcl-zpng))
+(define-public cl-claw
+ (sbcl-package->cl-source-package sbcl-claw))
-(define-public ecl-zpng
- (sbcl-package->ecl-package sbcl-zpng))
+(define-public ecl-claw
+ (sbcl-package->ecl-package sbcl-claw))
-(define-public sbcl-cl-qrencode
+(define-public sbcl-claw-support
(package
- (name "sbcl-cl-qrencode")
- (version "0.1.2")
+ (name "sbcl-claw-support")
+ (version "1.0.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/jnjcc/cl-qrencode")
- (commit (string-append "v" version))))
+ (url "https://github.com/borodust/claw-support")
+ (commit "9a15c8bed04585f45e6a461bcda1b475144dbd0b")))
(file-name (git-file-name name version))
(sha256
- (base32 "1l5k131dchbf6cj8a8xqa731790p01p3qa1kdy2wa9dawy3ymkxr"))))
+ (base32 "1my2ka7h72ipx5n3b465g6kjkasrhsvhqlijwcg6dhlzs5yygl23"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-lisp-unit))
- (inputs
- (list sbcl-zpng))
- (synopsis "QR code encoder for Common Lisp")
+ (home-page "https://github.com/borodust/claw-support")
+ (synopsis "Support routines for claw")
(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+)))
+ "This package provides support routines for the @code{claw} Common Lisp
+package.")
+ (license license:expat)))
-(define-public cl-qrencode
- (sbcl-package->cl-source-package sbcl-cl-qrencode))
+(define-public cl-claw-support
+ (sbcl-package->cl-source-package sbcl-claw-support))
-(define-public ecl-cl-qrencode
- (sbcl-package->ecl-package sbcl-cl-qrencode))
+(define-public ecl-claw-support
+ (sbcl-package->ecl-package sbcl-claw-support))
-(define-public sbcl-hdf5-cffi
- (let ((commit "5b5c88f191e470e4fe96b462334e3ce0806eed5c")
- (revision "1"))
+(define-public sbcl-claw-utils
+ (let ((revision "0")
+ (commit "efe25016501973dc369f067a64c7d225802bc56f"))
(package
- (name "sbcl-hdf5-cffi")
- (version (git-version "1.8.18" revision commit))
+ (name "sbcl-claw-utils")
+ ;; version is not specified
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hdfgroup/hdf5-cffi")
+ (url "https://github.com/borodust/claw-utils")
(commit commit)))
- (file-name (git-file-name "cl-hdf5-cffi" version))
+ (file-name (git-file-name "claw-utils" version))
(sha256
- (base32 "0vda3075423xz83qky998lpac5b04dwfv7bwgh9jq8cs5v0zrxjf"))))
+ (base32 "01df3kyf2qs3czi332dnz2s35x2j0fq46vgmsw7wjrrvnqc22mk5"))))
(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"))))
- (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-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))))
+ (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-randist
- (sbcl-package->cl-source-package sbcl-cl-randist))
+(define-public cl-claw-utils
+ (sbcl-package->cl-source-package sbcl-claw-utils))
-(define-public ecl-cl-randist
- (sbcl-package->ecl-package sbcl-cl-randist))
+(define-public ecl-claw-utils
+ (sbcl-package->ecl-package sbcl-claw-utils))
-(define-public sbcl-float-features
- (let ((commit "c1f86aea91cfaa3aa59799162be23ef8a12b199d")
- (revision "2"))
+(define-public sbcl-clawk
+ (let ((commit "3a91634df686417114044a98c063cbe76bfac7b6"))
(package
- (name "sbcl-float-features")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-clawk")
+ (version (git-version "4" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/float-features")
+ (url "https://github.com/sharplispers/clawk")
(commit commit)))
- (file-name (git-file-name "float-features" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "0vqm9xhn2i4vbjrxnp4hr1l3lydjflhjykdz6cmqg2j48c5kh3g3"))))
+ (base32 "1ph3xjqilvinvgr9q3w47zxqyz1sqnq030nlx7kgkkv8j3bnqk7a"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Common Lisp IEEE float portability library")
- (description
- "Portability library for IEEE float features that are not
-covered by the Common Lisp standard.")
- (home-page "https://github.com/Shinmera/float-features")
- (license license:zlib)
(inputs
- `(("documentation-utils" ,sbcl-documentation-utils)))
- (arguments
- `(#:tests? #f)))))
-
-(define-public cl-float-features
- (sbcl-package->cl-source-package sbcl-float-features))
-
-(define-public ecl-float-features
- (sbcl-package->ecl-package sbcl-float-features))
-
-(define-public sbcl-function-cache
- (package
- (name "sbcl-function-cache")
- (version "1.0.3")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/AccelerationNet/function-cache")
- (commit "6a5ada401e57da2c8abf046f582029926e61fce8")))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "000vmd3f5rx5hs9nvphfric0gkzaadns31c6mxaslpv0k7pkrmc6"))))
- (build-system asdf-build-system/sbcl)
- (synopsis "Function caching / memoization library for Common Lisp")
- (description
- "A common lisp library that provides extensible function result
-caching based on arguments (an expanded form of memoization).")
- (home-page "https://github.com/AccelerationNet/function-cache")
- (license
- (license:non-copyleft
- "https://github.com/AccelerationNet/function-cache/blob/master/README.md"))
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("cl-interpol" ,sbcl-cl-interpol)
- ("iterate" ,sbcl-iterate)
- ("symbol-munger" ,sbcl-symbol-munger)
- ("closer-mop" ,sbcl-closer-mop)))
- (arguments
- `(#:tests? #f))))
+ (list sbcl-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-function-cache
- (sbcl-package->cl-source-package sbcl-function-cache))
+(define-public cl-clawk
+ (sbcl-package->cl-source-package sbcl-clawk))
-(define-public ecl-function-cache
- (sbcl-package->ecl-package sbcl-function-cache))
+(define-public ecl-clawk
+ (sbcl-package->ecl-package sbcl-clawk))
-(define-public sbcl-cache-while
- (let ((commit "38e9ffbdb2c894670c366c1e5802ffcc8cfd43a7")
- (revision "1"))
+(define-public sbcl-clesh
+ (let ((commit "44e96e04a72e5bc006dc4eb02ce8962348dd4a11"))
(package
- (name "sbcl-cache-while")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-clesh")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/charje/cache-while")
+ (url "https://github.com/Neronus/Clesh")
(commit commit)))
- (file-name (git-file-name "cache-while" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1qil68rfn5irmkb0jk1f6g1zy80wgc3skl8cr4rfgh7ywgm5izx3"))))
+ (base32 "012ry02djnqyvvs61wbbqj3saz621w2l9gczrywdxhi5p4ycx318"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/charje/cache-while")
- (synopsis "Temporary / one-time caching macro for Common Lisp")
+ (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 Common Lisp macro for defining temporary caches that
-invalidate based on expressions evaluating to different values.")
- (license license:llgpl))))
+ "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-cache-while
- (sbcl-package->cl-source-package sbcl-cache-while))
+(define-public cl-clesh
+ (sbcl-package->cl-source-package sbcl-clesh))
-(define-public ecl-cache-while
- (sbcl-package->ecl-package sbcl-cache-while))
+(define-public ecl-clesh
+ (sbcl-package->ecl-package sbcl-clesh))
-(define-public sbcl-type-r
- (let ((commit "83c89e38f2f7a7b16f1012777ecaf878cfa6a267")
+(define-public sbcl-clinenoise
+ (let ((commit "46e21f99d06a55d93eaa382cf652d55d457032ef")
(revision "1"))
(package
- (name "sbcl-type-r")
+ (name "sbcl-clinenoise")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/type-r")
+ (url "https://github.com/jasom/clinenoise")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "clinenoise" version))
(sha256
- (base32
- "1arsxc2539rg8vbrdirz4xxj1b06mc6g6rqndz7a02g127qvk2sm"))))
+ (base32 "0ydlirfk4dbpqqjwwph99v5swcrhd8v9g8q24fvs35wn2vm08lh1"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Parser interface for Common Lisp built-in compound types")
- (description
- "Collections of accessor functions and patterns to access
-the elements in compound type specifier, e.g. @code{dimensions} in
-@code{(array element-type dimensions)}")
- (home-page "https://github.com/guicho271828/type-r")
- (license license:lgpl3+)
(inputs
- `(("trivia" ,sbcl-trivia)
- ("alexandria" ,sbcl-alexandria)))
- (native-inputs
- (list sbcl-fiveam)))))
+ (list sbcl-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-type-r
- (sbcl-package->cl-source-package sbcl-type-r))
+(define-public cl-clinenoise
+ (sbcl-package->cl-source-package sbcl-clinenoise))
-(define-public ecl-type-r
- (sbcl-package->ecl-package sbcl-type-r))
+(define-public ecl-clinenoise
+ (sbcl-package->ecl-package sbcl-clinenoise))
-(define-public sbcl-trivialib-type-unify
- (let ((commit "62492ebf04db567dcf435ae84c50b7b8202ecf99")
- (revision "1"))
+(define-public sbcl-clingon
+ (let ((commit "379fc41e7b3977661f1454cf35acdbfae046d40d")
+ (revision "0"))
(package
- (name "sbcl-trivialib-type-unify")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-clingon")
+ (version (git-version "0.5.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/guicho271828/trivialib.type-unify")
+ (url "https://github.com/dnaeon/clingon")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clingon" version))
(sha256
- (base32
- "1bkyfzbwv75p50zp8n1n9rh2r29pw3vgz91gmn2gzzkyq3khj1vh"))))
+ (base32 "11p9lplx0fc5ghx601i150vrd46zdbvw0hfrbrrrdqplxaqpywq5"))))
(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"))))))
+ (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-trivialib-type-unify
- (sbcl-package->cl-source-package sbcl-trivialib-type-unify))
+(define-public cl-clingon
+ (sbcl-package->cl-source-package sbcl-clingon))
-(define-public ecl-trivialib-type-unify
- (sbcl-package->ecl-package sbcl-trivialib-type-unify))
+(define-public ecl-clingon
+ (sbcl-package->ecl-package sbcl-clingon))
-(define-public sbcl-cl-unification
- (let ((commit "01079f34d197495880aa49ab727d63774d83035c")
+(define-public sbcl-clip
+ (let ((commit "7afa68702fbb99c47ed115ea0faccd97a29d9b2e")
(revision "1"))
(package
- (name "sbcl-cl-unification")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-clip")
+ (version (git-version "0.7.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://gitlab.common-lisp.net/cl-unification/cl-unification")
+ (url "https://github.com/shinmera/clip")
(commit commit)))
- (file-name (git-file-name "cl-unification" version))
+ (file-name (git-file-name "clip" version))
(sha256
- (base32 "0nhqamn3qgg38i6aw2pshffdwr2hzslycg8ficmn333gw0h9rf4g"))))
+ (base32 "13kkajkva2shm19fvn4yashsw18l6imv2rmy3hmpcky7g5ay7bv3"))))
(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")
+ (list sbcl-array-utils sbcl-lquery))
+ (home-page "https://shinmera.github.io/clip/")
+ (synopsis "Common Lisp HTML templating engine")
(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))))
+ "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-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-clip
+ (sbcl-package->cl-source-package sbcl-clip))
-(define-public cl-unification
- (sbcl-package->cl-source-package sbcl-cl-unification))
+(define-public ecl-clip
+ (sbcl-package->ecl-package sbcl-clip))
-(define-public sbcl-specialized-function
- (let ((commit "5e2b04432bdf728496e6ff7227f210f845af7247")
- (revision "3"))
+(define-public sbcl-clml
+ (let ((commit "95505b54c8c7b4b27f500c3be97fa5732f4b51a8")
+ (revision "0"))
(package
- (name "sbcl-specialized-function")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-clml")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/numcl/specialized-function")
+ (url "https://github.com/mmaul/clml")
(commit commit)))
- (file-name (git-file-name "specialized-function" version))
+ (file-name (git-file-name "clml" version))
(sha256
- (base32 "19hfgc83b7as630r1w9r8yl0v6xq3dn01vcrl0bd4pza5hgjn4la"))))
+ (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)
- (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))
+ (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 ecl-conduit-packages
- (sbcl-package->ecl-package sbcl-conduit-packages))
+(define-public cl-clml
+ (sbcl-package->cl-source-package sbcl-clml))
-(define-public sbcl-constantfold
- (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
- (revision "1"))
+(define-public sbcl-clobber
+ (let ((commit "212721c24a8bb792714314ba52dfe818641f2e98")
+ (revision "0"))
(package
- (name "sbcl-constantfold")
- (version (git-version "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/numcl/constantfold")
+ (url "https://github.com/robert-strandh/Clobber")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clobber" version))
(sha256
- (base32
- "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
+ (base32 "0pqzfn2wqbzzwlwc3l84iv3i3wa9zfgnh14mq67h9qkib8wjzx3n"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Support library for numcl")
+ (home-page "https://github.com/robert-strandh/Clobber")
+ (synopsis "Common Lisp Library for transaction-oriented databases")
(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)))))
+ "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-constantfold
- (sbcl-package->cl-source-package sbcl-constantfold))
+(define-public cl-clobber
+ (sbcl-package->cl-source-package sbcl-clobber))
-(define-public ecl-constantfold
- (sbcl-package->ecl-package sbcl-constantfold))
+(define-public ecl-clobber
+ (sbcl-package->ecl-package sbcl-clobber))
-(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 sbcl-clog
+ (package
+ (name "sbcl-clog")
+ (version "1.2")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/rabbibotton/clog")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-clog" version))
+ (sha256
+ (base32 "0f4i6571nm0j704zgnh60sc9slifs11byb2gs8gamqjcfh931dap"))))
+ (build-system asdf-build-system/sbcl)
+ (inputs
+ (list sbcl-3bmd
+ sbcl-alexandria
+ sbcl-bordeaux-threads
+ sbcl-cl-ppcre
+ sbcl-cl-sqlite
+ sbcl-cl-template
+ sbcl-clack
+ sbcl-closer-mop
+ sbcl-colorize
+ sbcl-dbi
+ sbcl-hunchentoot
+ sbcl-lack
+ sbcl-mgl-pax
+ sbcl-parse-float
+ sbcl-quri
+ sbcl-trivial-open-browser
+ sbcl-websocket-driver))
+ (arguments
+ '(#:asd-systems '("clog" "clog/docs" "clog/tools")
+ #:phases (modify-phases %standard-phases
+ (add-after 'unpack 'fix-symbol-name
+ (lambda _
+ (substitute* "source/clog-docs.lisp"
+ (("clog:@CLOG-MANUAL")
+ "clog::@CLOG_MANUAL")))))))
+ (home-page "https://github.com/rabbibotton/clog")
+ (synopsis "Common Lisp Omnificent GUI")
+ (description
+ "This package provides a Common Lisp web framework for building GUI
+applications. CLOG can take the place, or work along side, most cross platform
+GUI frameworks and website frameworks. The CLOG package starts up the
+connectivity to the browser or other websocket client (often a browser embedded
+in a native template application).")
+ (license license:bsd-3)))
-(define-public cl-gtype
- (sbcl-package->cl-source-package sbcl-gtype))
+(define-public cl-clog
+ (sbcl-package->cl-source-package sbcl-clog))
-(define-public ecl-gtype
- (let ((pkg (sbcl-package->ecl-package sbcl-gtype)))
- (package
- (inherit pkg)
- (arguments
- (substitute-keyword-arguments (package-arguments pkg)
- ;; The tests fail on ECL with a COMPILE-FILE-ERROR for t/package.lisp.
- ((#:tests? _ #f) #f))))))
+(define-public ecl-clog
+ (sbcl-package->ecl-package sbcl-clog))
-(define-public sbcl-numcl
- (let ((commit "a28f612d072e5f93137584de5155a42243b3bd6b")
- (revision "3"))
+(define-public sbcl-clop
+ (let ((commit "c0c3fe7efa5ac95ba1644febfb2c2acab757fcda")
+ (revision "0"))
(package
- (name "sbcl-numcl")
- (version (git-version "0.2.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/numcl/numcl")
+ (url "https://github.com/sheepduke/clop")
(commit commit)))
- (file-name (git-file-name "numcl" version))
+ (file-name (git-file-name "cl-clop" version))
(sha256
- (base32 "15m4spbgayawnw5jjz04zfp0jnk9g6hgq5fmr648hzjzj50j1d78"))))
+ (base32 "1q7rlizr8gcbfz4a9660gdbw7d2zbld18akjpibg54j7jh5kb8gc"))))
(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+))))
+ "Clop is a Common Lisp library for parsing strings in the TOML
+configuration file format.")
+ (license license:expat))))
-(define-public cl-numcl
- (sbcl-package->cl-source-package sbcl-numcl))
+(define-public cl-clop
+ (sbcl-package->cl-source-package sbcl-clop))
-(define-public ecl-numcl
- (sbcl-package->ecl-package sbcl-numcl))
+(define-public ecl-clop
+ (sbcl-package->ecl-package sbcl-clop))
-(define-public sbcl-pzmq
- (let ((commit "6f7b2ca02c23ea53510a9b0e0f181d5364ce9d32")
- (revision "2"))
+(define-public sbcl-closer-mop
+ (let ((commit "7b86f2add029208ebc74ec6a41c2ccfd3c382dbc")
+ (revision "3"))
(package
- (name "sbcl-pzmq")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-closer-mop")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/orivej/pzmq")
+ (url "https://github.com/pcostanza/closer-mop")
(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))
+ (base32 "1fzxdpq873rpagmj3h9bgv7n95h4p03pnxrklbxp06sxb26xyi16"))
+ (file-name (git-file-name "cl-closer-mop" version ))))
(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))))
+ (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-lquery
- (sbcl-package->cl-source-package sbcl-lquery))
+(define-public cl-closer-mop
+ (sbcl-package->cl-source-package sbcl-closer-mop))
-(define-public ecl-lquery
- (sbcl-package->ecl-package sbcl-lquery))
+(define-public ecl-closer-mop
+ (sbcl-package->ecl-package sbcl-closer-mop))
-(define-public sbcl-cl-mysql
- (let ((commit "ab56c279c1815aec6ca0bfe85164ff7e85cfb6f9")
- (revision "1"))
+(define-public sbcl-clostrum
+ (let ((commit "c85d38bde9d093f1f132574e9b98b8d64683cd51")
+ (revision "0"))
(package
- (name "sbcl-cl-mysql")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-clostrum")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hackinghat/cl-mysql")
+ (url "https://github.com/s-expressionists/Clostrum")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-clostrum" commit))
(sha256
- (base32 "0dg5ynx2ww94d0qfwrdrm7plkn43h64hs4iiq9mj2s1s4ixnp3lr"))))
+ (base32 "10alsdnpzbgic75xghwjp414sqwg4npvp69zn0r4l8ms0ki9zr1x"))))
(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")
+ (native-inputs (list sbcl-fiveam))
+ (home-page "https://github.com/s-expressionists/Clostrum")
+ (synopsis "First Class Global Environments")
(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-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)))
+ "This package provides first-class global environments for
+Common Lisp.")
+ (license license:bsd-2))))
-(define-public cl-postmodern
- (sbcl-package->cl-source-package sbcl-postmodern))
+(define-public cl-clostrum
+ (sbcl-package->cl-source-package sbcl-clostrum))
-(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 ecl-clostrum
+ (sbcl-package->ecl-package sbcl-clostrum))
-(define-public sbcl-db3
- (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d")
+(define sbcl-closure-common
+ (let ((commit "e3c5f5f454b72b01b89115e581c3c52a7e201e5c")
(revision "1"))
(package
- (name "sbcl-db3")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-closure-common")
+ (build-system asdf-build-system/sbcl)
+ (version (git-version "20101006" revision commit))
+ (home-page "https://common-lisp.net/project/cxml/")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dimitri/cl-db3")
+ (url "https://github.com/sharplispers/closure-common")
(commit commit)))
- (file-name (git-file-name "cl-db3" version))
+ (file-name (git-file-name name 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 ecl-db3
- (sbcl-package->ecl-package sbcl-db3))
-
-(define-public cl-db3
- (sbcl-package->cl-source-package sbcl-db3))
+ (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-dbi
- (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227")
- (revision "2"))
+(define-public sbcl-closure-template
+ ;; There are no releases since 2015.
+ (let ((commit "f1983aa525045691e128027d2a2d74831c873d6e")
+ (revision "0"))
(package
- (name "sbcl-dbi")
- (version (git-version "0.9.5" revision commit))
+ (name "sbcl-closure-template")
+ (version (git-version "0.2.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fukamachi/cl-dbi")
+ (url "https://github.com/archimag/cl-closure-template")
(commit commit)))
- (file-name (git-file-name "cl-dbi" version))
+ (file-name (git-file-name "cl-closure-template" version))
(sha256
- (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg"))))
+ (base32 "16h0fs6bjjd4n9pbkwcprpgyj26vsw2akk3q08m7xmsmqi05dppv"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- `(("alexandria" ,sbcl-alexandria)
- ("rove" ,sbcl-rove)
- ("trivial-types" ,sbcl-trivial-types)))
+ (native-inputs (list sbcl-lift))
(inputs
- `(("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cl-mysql" ,sbcl-cl-mysql)
- ("cl-sqlite" ,sbcl-cl-sqlite)
- ("closer-mop" ,sbcl-closer-mop)
- ("postmodern" ,sbcl-postmodern)
- ("split-sequence" ,sbcl-split-sequence)
- ("trivial-garbage" ,sbcl-trivial-garbage)))
- (arguments
- `(#:asd-systems '("dbi"
- "dbd-mysql"
- "dbd-postgres"
- "dbd-sqlite3")))
- (synopsis "Database independent interface for Common Lisp")
+ (list sbcl-alexandria
+ 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 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-closure-template
+ (sbcl-package->cl-source-package sbcl-closure-template))
-(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,375 +11116,238 @@ 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/ndantam/sycamore/")
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri
+ (git-reference
+ (url "https://github.com/Shinmera/clss")
+ (commit commit)))
(sha256
- (base32 "00bv1aj89q5vldmq92zp2364jq312zjq2mbd3iyz1s2b4widzhl7"))))
- (build-system asdf-build-system/sbcl)
+ (base32 "1033dchpanhcgxl5qfhr80aw9adbp9bvllhzvvy5p9mrfnidd1fv"))
+ (file-name (git-file-name name version))))
(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-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"))))
+ (list sbcl-array-utils sbcl-plump))
(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-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)))
+ (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-trivial-package-local-nicknames
- (sbcl-package->cl-source-package sbcl-trivial-package-local-nicknames))
+(define-public cl-clss
+ (sbcl-package->cl-source-package sbcl-clss))
-(define-public ecl-trivial-package-local-nicknames
- (sbcl-package->ecl-package sbcl-trivial-package-local-nicknames))
+(define-public ecl-clss
+ (sbcl-package->ecl-package sbcl-clss))
-(define-public sbcl-enchant
- (let ((commit "6af162a7bf10541cbcfcfa6513894900329713fa"))
+(define-public sbcl-cluffer
+ (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
(package
- (name "sbcl-enchant")
+ (name "sbcl-cluffer")
(version (git-version "0.0.0" "1" commit))
- (home-page "https://github.com/tlikonen/cl-enchant")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url home-page)
+ (url "https://github.com/robert-strandh/cluffer")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "19yh5ihirzi1d8xqy1cjqipzd6ly3245cfxa5s9xx496rryz0s01"))))
+ (base32
+ "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
(build-system asdf-build-system/sbcl)
(inputs
- `(("enchant" ,enchant)
- ("cffi" ,sbcl-cffi)))
+ (list sbcl-acclimation sbcl-clump))
(arguments
`(#:phases
(modify-phases %standard-phases
- (add-after 'unpack 'fix-paths
- (lambda* (#:key inputs #:allow-other-keys)
- (substitute* "load-enchant.lisp"
- (("libenchant")
- (string-append
- (assoc-ref inputs "enchant") "/lib/libenchant-2"))))))))
- (synopsis "Common Lisp interface for the Enchant spell-checker library")
- (description
- "Enchant is a Common Lisp interface for the Enchant spell-checker
-library. The Enchant library is a generic spell-checker library which uses
-other spell-checkers transparently as back-end. The library supports the
-multiple checkers, including Aspell and Hunspell.")
- (license license:public-domain))))
-
-(define-public cl-enchant
- (sbcl-package->cl-source-package sbcl-enchant))
-
-(define-public ecl-enchant
- (sbcl-package->ecl-package sbcl-enchant))
-
-(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))))
+ (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-change-case
- (sbcl-package->cl-source-package sbcl-cl-change-case))
+(define-public cl-cluffer
+ (sbcl-package->cl-source-package sbcl-cluffer))
-(define-public ecl-cl-change-case
- (sbcl-package->ecl-package sbcl-cl-change-case))
+(define-public ecl-cluffer
+ (sbcl-package->ecl-package sbcl-cluffer))
-(define-public sbcl-modularize
- (let ((commit "86c5d9a11fbd2df9f0f03ac10b5d71837c8934ba")
- (revision "1"))
+(define-public sbcl-clump
+ (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
(package
- (name "sbcl-modularize")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-clump")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/modularize")
+ (url "https://github.com/robert-strandh/Clump")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1zys29rfkb649rkgl3snxhajk8d5yf7ryxkrwy020kwdh7zdsg7d"))))
- (build-system asdf-build-system/sbcl)
+ (base32
+ "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
(inputs
- `(("documentation-utils" ,sbcl-documentation-utils)
- ("trivial-package-local-nicknames" ,sbcl-trivial-package-local-nicknames)))
- (home-page "https://shinmera.github.io/modularize/")
- (synopsis "Common Lisp modularization framework")
- (description
- "@code{MODULARIZE} is an attempt at providing a common interface to
-segregate major application components. This is achieved by adding special
-treatment to packages. Each module is a package that is specially registered,
-which allows it to interact and co-exist with other modules in better ways. For
-instance, by adding module definition options you can introduce mechanisms to
-tie modules together in functionality, hook into each other and so on.")
- (license license:zlib))))
-
-(define-public ecl-modularize
- (sbcl-package->ecl-package sbcl-modularize))
+ (list sbcl-acclimation))
+ (build-system asdf-build-system/sbcl)
+ (home-page "https://github.com/robert-strandh/Clump")
+ (synopsis "Collection of tree implementations for Common Lisp")
+ (description "The purpose of this library is to provide a collection of
+implementations of trees.
-(define-public cl-modularize
- (sbcl-package->cl-source-package sbcl-modularize))
+In contrast to existing libraries such as cl-containers, it does not impose a
+particular use for the trees. Instead, it aims for a stratified design,
+allowing client code to choose between different levels of abstraction.
-(define-public sbcl-modularize-hooks
- (let ((commit "e0348ed3ffd59a9ec31ca4ab28289e748bfbf96a")
- (revision "1"))
- (package
- (name "sbcl-modularize-hooks")
- (version (git-version "1.0.2" revision commit))
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/Shinmera/modularize-hooks")
- (commit commit)))
- (file-name (git-file-name "modularize-hooks" version))
- (sha256
- (base32 "12kjvin8hxidwkzfb7inqv5b6g5qzcssnj9wc497v2ixc56fqdz7"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-closer-mop sbcl-lambda-fiddle sbcl-modularize
- sbcl-trivial-arguments))
- (home-page "https://shinmera.github.io/modularize-hooks/")
- (synopsis "Generic hooks and triggers extension for Modularize")
- (description
- "This is a simple extension to @code{MODULARIZE} that allows modules to
-define and trigger hooks, which other modules can hook on to.")
- (license license:zlib))))
+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 ecl-modularize-hooks
- (sbcl-package->ecl-package sbcl-modularize-hooks))
+(define-public cl-clump
+ (sbcl-package->cl-source-package sbcl-clump))
-(define-public cl-modularize-hooks
- (sbcl-package->cl-source-package sbcl-modularize-hooks))
+(define-public ecl-clump
+ (sbcl-package->ecl-package sbcl-clump))
-(define-public sbcl-modularize-interfaces
- (let ((commit "96353657afb8c7aeba7ef5b51eb04c5ed3bcb6ef")
- (revision "1"))
+(define-public sbcl-cluster
+ (let ((commit "b040e97578f3027d7d8c7652c74917726574c43e")
+ (revision "0"))
(package
- (name "sbcl-modularize-interfaces")
- (version (git-version "0.9.3" revision commit))
+ (name "sbcl-cluster")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/modularize-interfaces")
+ (url "https://github.com/robert-strandh/Cluster")
(commit commit)))
- (file-name (git-file-name "modularize-interfaces" version))
+ (file-name (git-file-name "cl-cluster" commit))
(sha256
- (base32 "0bjf4wy39cwf75m7vh0r7mmcchs09yz2lrbyap98hnq8blq70fhc"))))
+ (base32 "0ixbr3wm7d3m8mgzasd95rxvs9kip6ngr5s1zk7j3604mcfssqyi"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-lambda-fiddle sbcl-modularize sbcl-trivial-arguments
- sbcl-trivial-indent))
- (home-page "https://shinmera.github.io/modularize-interfaces/")
- (synopsis "Programmatical interfaces extension for Modularize")
+ (list sbcl-acclimation
+ sbcl-split-sequence))
+ (home-page "https://github.com/robert-strandh/Cluster")
+ (synopsis "Assembler with input in the form of standard instances")
(description
- "This is an extension to @code{MODULARIZE} that allows your application
-to define interfaces in-code that serve both as a primary documentation and as
-compliance control.")
- (license license:zlib))))
+ "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-modularize-interfaces
- (sbcl-package->ecl-package sbcl-modularize-interfaces))
+(define-public cl-cluster
+ (sbcl-package->cl-source-package sbcl-cluster))
-(define-public cl-modularize-interfaces
- (sbcl-package->cl-source-package sbcl-modularize-interfaces))
+(define-public ecl-cluster
+ (sbcl-package->ecl-package sbcl-cluster))
-(define-public sbcl-moptilities
- (let ((commit "a436f16b357c96b82397ec018ea469574c10dd41"))
+(define-public sbcl-clx
+ (let ((commit "38400456d66823e417d1d27d339b09885e25eb59")
+ (revision "1"))
(package
- (name "sbcl-moptilities")
- (version (git-version "0.3.13" "1" commit))
- (home-page "https://github.com/gwkkwg/moptilities/")
+ (name "sbcl-clx")
+ (version (git-version "0.7.5" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url home-page)
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri
+ (git-reference
+ (url "https://github.com/sharplispers/clx")
+ (commit commit)))
(sha256
- (base32 "1q12bqjbj47lx98yim1kfnnhgfhkl80102fkgp9pdqxg0fp6g5fc"))))
+ (base32 "1c05gjqh5lil2sgma0yap4mxd9y1cjkp933hyx1iaj14950nhfnl"))
+ (file-name (git-file-name "cl-clx" version))))
(build-system asdf-build-system/sbcl)
- (inputs
- `(("closer-mop" ,sbcl-closer-mop)))
(native-inputs
- (list sbcl-lift))
+ (list sbcl-fiasco xorg-server-for-tests))
(arguments
- `(#:phases
- (modify-phases %standard-phases
- (add-after 'unpack 'fix-tests
- (lambda _
- (substitute* "lift-standard.config"
- ((":relative-to lift-test")
- ":relative-to moptilities-test"))
- #t))
- (add-after 'install 'remove-test-results
- ;; Otherwise the drag the SBCL package into the closure of the CL
- ;; package.
- (lambda* (#:key outputs #:allow-other-keys)
- (let* ((out (assoc-ref outputs "out"))
- (source-path (string-append out "/share/common-lisp/"
- (%lisp-type) "/moptilities/")))
- (delete-file-recursively
- (string-append source-path "/test-results")))
- #t)))))
- (synopsis "Compatibility layer for Common Lisp MOP implementation differences")
- (description
- "MOP utilities provide a common interface between Lisps and make the
-MOP easier to use.")
- (license license:expat))))
+ (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-moptilities
- (sbcl-package->cl-source-package sbcl-moptilities))
+(define-public cl-clx
+ (sbcl-package->cl-source-package sbcl-clx))
-(define-public ecl-moptilities
- (let ((pkg (sbcl-package->ecl-package sbcl-moptilities)))
- (package
- (inherit pkg)
- (arguments
- ;; Tests fail with "The function LIFT::GET-BACKTRACE-AS-STRING is
- ;; undefined" on ECL.
- '(#:tests? #f)))))
+(define-public ecl-clx
+ (sbcl-package->ecl-package sbcl-clx))
-(define-public sbcl-osicat
- (let ((commit "982327905b8980ff3173344ca87282e046565732")
- (revision "4"))
+(define-public sbcl-clx-truetype
+ (let ((commit "c6e10a918d46632324d5863a8ed067a83fc26de8")
+ (revision "1"))
(package
- (name "sbcl-osicat")
- (version (git-version "0.7.0" revision commit))
- (home-page "https://www.common-lisp.net/project/osicat/")
+ (name "sbcl-clx-truetype")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/osicat/osicat")
+ (url "https://github.com/l04m33/clx-truetype")
(commit commit)))
- (file-name (git-file-name "cl-osicat" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "10q1dfkhrvp5ia860q10y4wdm11fmxf7xv8zl4viz2np9xzf5v22"))
+ (base32
+ "079hyp92cjkdfn6bhkxsrwnibiqbz4y4af6nl31lzw6nm91j5j37"))
+ (modules '((guix build utils)))
(snippet
'(begin
- ;; The useless release.sh drags `bash' into the closure.
- (delete-file "scripts/release.sh")
+ (substitute* "package.lisp"
+ ((":export") ":export\n :+font-cache-filename+"))
#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.")
+ (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-osicat
- (sbcl-package->cl-source-package sbcl-osicat))
+(define-public cl-clx-truetype
+ (sbcl-package->cl-source-package sbcl-clx-truetype))
-(define-public ecl-osicat
- (sbcl-package->ecl-package sbcl-osicat))
+(define-public ecl-clx-truetype
+ (sbcl-package->ecl-package sbcl-clx-truetype))
(define-public sbcl-clx-xembed
(let ((commit "a5c4b844d31ee68ffa58c933cc1cdddde6990743")
@@ -14739,1889 +11381,2022 @@ accompaniment to the standard ANSI facilities.")
(define-public ecl-clx-xembed
(sbcl-package->ecl-package sbcl-clx-xembed))
-(define-public sbcl-mw-equiv
- (let ((commit "3ae871458685b1ef7cd6a996ee22c8c5e738a03d")
- (revision "1"))
+(define-public sbcl-cmd
+ (let ((commit "0164d574ba236e2001ee1d9dba3f4774c7512a8c")
+ (revision "8"))
(package
- (name "sbcl-mw-equiv")
- (version (git-version "0.1.2" revision commit))
- (home-page "https://github.com/sharplispers/mw-equiv/")
+ (name "sbcl-cmd")
+ (version (git-version "0.0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/sharplispers/mw-equiv/")
+ (url "https://github.com/ruricolist/cmd/")
(commit commit)))
- (file-name (git-file-name "cl-mw-equiv" version))
+ (file-name (git-file-name "cl-cmd" version))
(sha256
- (base32 "1fl90wp0jp7l90mps53fq0kzb28f10qfr739527h03xwqccyylad"))))
+ (base32 "03wbckzmz6pqdlz7pyar6nfg4vs4bl0b2np7n3kk3qhjbrdakc4m"))))
(build-system asdf-build-system/sbcl)
- (synopsis "Extensible object equivalence protocol for Common Lisp")
- (description "Common Lisp comes with quite some functions to compare
-objects for equality, yet none is applicable in every situation and in general
-this is hard, as equality of objects depends on the semantics of operations on
-them. As consequence, users find themselves regularly in a situation where
-they have to roll their own specialized equality test.
-
-This module provides one of many possible equivalence relations between
-standard Common Lisp objects. However, it can be extended for new objects
-through a simple CLOS protocol. The rules when two objects are considered
-equivalent distinguish between @emph{mutating} and @emph{frozen objects}. A
-frozen object is promised not to be mutated in the future in a way that
-operations on it can notice the difference.
-
-We have chosen to compare mutating objects only for identity (pointer
-equality), to avoid various problems. Equivalence for frozen objects on the
-other hand is established by recursing on the objects' constituent parts and
-checking their equivalence. Hence, two objects are equivalent under the
-@code{OBJECT=} relation, if they are either identical, or if they are frozen
-and structurally equivalent, i.e. their constituents are point-wise
-equivalent.
-
-Since many objects are potentially mutable, but are not necessarily mutated
-from a certain point in their life time on, it is possible to promise to the
-equivalence relation that they remain frozen for the rest of their life time,
-thus enabling coarser equivalence than the often too fine-grained pointer
-equality.")
- (license license:bsd-2))))
+ (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-mw-equiv
- (sbcl-package->cl-source-package sbcl-mw-equiv))
+(define-public cl-cmd
+ (sbcl-package->cl-source-package sbcl-cmd))
-(define-public ecl-mw-equiv
- (sbcl-package->ecl-package sbcl-mw-equiv))
+(define-public ecl-cmd
+ (sbcl-package->ecl-package sbcl-cmd))
-(define-public sbcl-quantile-estimator
+(define-public sbcl-cmn
(package
- (name "sbcl-quantile-estimator")
- (version "0.0.1")
+ (name "sbcl-cmn")
+ (version "2021.11.22")
(source
(origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/deadtrickster/quantile-estimator.cl")
- (commit "84d0ea405d793f5e808c68c4ddaf25417b0ff8e5")))
- (file-name (git-file-name name version))
+ (method url-fetch)
+ (uri "https://ccrma.stanford.edu/software/cmn/cmn.tar.gz")
+ (file-name (string-append "cmn-" version ".tar.gz"))
(sha256
- (base32
- "0rlswkf0siaabsvvch3dgxmg45fw5w8pd9b7ri2w7a298aya52z9"))))
+ (base32 "04j1l57cdyfi2zzxqwmvmf1hl899ffgs3bl4r42ba47zsw45kq14"))))
(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://ccrma.stanford.edu/software/cmn/")
+ (synopsis "Western music notation package written in Common Lisp")
(description
- "Common Lisp implementation of Graham Cormode and S.
-Muthukrishnan's Effective Computation of Biased Quantiles over Data
-Streams in ICDE’05.")
+ "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-quantile-estimator
- (sbcl-package->cl-source-package sbcl-quantile-estimator))
+(define-public cl-cmn
+ (sbcl-package->cl-source-package sbcl-cmn))
-(define-public ecl-quantile-estimator
- (sbcl-package->ecl-package sbcl-quantile-estimator))
+(define-public ecl-cmn
+ (sbcl-package->ecl-package sbcl-cmn))
-(define-public sbcl-prometheus
- (package
- (name "sbcl-prometheus")
- (version "0.4.1")
- (source
- (origin
- (method git-fetch)
- (uri (git-reference
- (url "https://github.com/deadtrickster/prometheus.cl")
- (commit "7352b92296996ff383503e19bdd3bcea30409a15")))
- (file-name (git-file-name name version))
- (sha256
- (base32
- "0fzczls2kfgdx18pja4lqxjrz72i583185d8nq0pb3s331hhzh0z"))))
- (build-system asdf-build-system/sbcl)
- (inputs
- `(("alexandria" ,sbcl-alexandria)
- ("bordeaux-threads" ,sbcl-bordeaux-threads)
- ("cffi" ,sbcl-cffi)
- ("cl-fad" ,sbcl-cl-fad)
- ("cl-ppcre" ,sbcl-cl-ppcre)
- ("drakma" ,sbcl-drakma)
- ("hunchentoot" ,sbcl-hunchentoot)
- ("local-time" ,sbcl-local-time)
- ("quantile-estimator" ,sbcl-quantile-estimator)
- ("salza2" ,sbcl-salza2)
- ("split-sequence" ,sbcl-split-sequence)
- ("trivial-utf-8" ,sbcl-trivial-utf-8)))
- (arguments
- '(#:asd-systems '("prometheus"
- "prometheus.collectors.sbcl"
- "prometheus.collectors.process"
- "prometheus.formats.text"
- "prometheus.exposers.hunchentoot"
- "prometheus.pushgateway")))
- (home-page "https://github.com/deadtrickster/prometheus.cl")
- (synopsis "Prometheus.io Common Lisp client")
- (description "Prometheus.io Common Lisp client.")
- (license license:expat)))
+(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-prometheus
- (sbcl-package->cl-source-package sbcl-prometheus))
+(define-public cl-coalton
+ (sbcl-package->cl-source-package sbcl-coalton))
-(define-public ecl-prometheus
- (sbcl-package->ecl-package sbcl-prometheus))
+(define-public ecl-coalton
+ (sbcl-package->ecl-package sbcl-coalton))
-(define-public sbcl-promise
- (let ((commit "801db8f853da7935ae2e487fd7f8763acbc5ad2a")
+(define-public sbcl-coleslaw
+ (let ((commit "e7e68ce6020d13b14bf212890a7d8973d7af3b40")
(revision "0"))
(package
- (name "sbcl-promise")
+ (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/promise")
+ (url "https://github.com/Shinmera/colored/")
(commit commit)))
- (file-name (git-file-name "cl-promise" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "07cvz6vb5y1d9vndcwq7q1cp54aqvyqzv6wk8vmymbz3lawq2wsn"))))
+ (base32 "0mpg91r6yfb9xqccd4r8z3hl2qzjhdj6daswb1cinrm8ffxrvy5k"))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-documentation-utils))
- (home-page "https://shinmera.github.io/promise/")
- (synopsis "Promise mechanism for asynchronous operations")
+ (synopsis "Colour representation, conversion, and operation for Common Lisp")
(description
- "This library implements a basic promise datastructure, which is useful
-for dealing with asynchronous behaviours. Importantly, this library does not
-use any other libraries or frameworks, and instead leaves the execution and
-state transition of promise objects in your control, making it easy to
-integrate.")
+ "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 ecl-promise
- (sbcl-package->ecl-package sbcl-promise))
+(define-public cl-colored
+ (sbcl-package->cl-source-package sbcl-colored))
-(define-public cl-promise
- (sbcl-package->cl-source-package sbcl-promise))
+(define-public ecl-colored
+ (sbcl-package->ecl-package sbcl-colored))
-(define-public sbcl-uuid
- (let ((commit "e7d6680c3138385c0708f7aaf0c96622eeb140e8"))
+(define-public sbcl-colorize
+ (let ((commit "ea676b584e0899cec82f21a9e6871172fe3c0eb5"))
(package
- (name "sbcl-uuid")
- (version (git-version "2012.12.26" "1" commit))
+ (name "sbcl-colorize")
+ (version (git-version "0.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dardoria/uuid")
+ (url "https://github.com/kingcons/colorize")
(commit commit)))
- (file-name (git-file-name name version))
(sha256
(base32
- "0jnyp2kibcf5cwi60l6grjrj8wws9chasjvsw7xzwyym2lyid46f"))))
+ "1pdg4kiaczmr3ivffhirp7m3lbr1q27rn7dhaay0vwghmi31zcw9"))
+ (file-name (git-file-name "colorize" version))))
(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-split-sequence sbcl-html-encode))
+ (synopsis "Common Lisp for syntax highlighting")
(description
- "Common Lisp implementation of UUIDs according to RFC4122.")
- (license license:llgpl))))
+ "@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-uuid
- (sbcl-package->cl-source-package sbcl-uuid))
+(define-public cl-colorize
+ (sbcl-package->cl-source-package sbcl-colorize))
-(define-public ecl-uuid
- (sbcl-package->ecl-package sbcl-uuid))
+(define-public ecl-colorize
+ (sbcl-package->ecl-package sbcl-colorize))
-(define-public sbcl-dissect
- (let ((commit "cffd38479f0e64e805f167bbdb240b783ecc8d45"))
+(define-public sbcl-com.gigamonkeys.binary-data
+ (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
+ (revision "0"))
(package
- (name "sbcl-dissect")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-com.gigamonkeys.binary-data")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/dissect")
+ (url "https://github.com/gigamonkey/monkeylib-binary-data")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "0rmsjkgjl90gl6ssvgd60hb0d5diyhsiyypvw9hbc0ripvbmk5r5"))))
+ (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
(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")
+ (list sbcl-alexandria))
+ (home-page "https://github.com/gigamonkey/monkeylib-binary-data")
+ (synopsis "Common Lisp library for reading and writing binary data")
(description
- "Dissect is a small Common Lisp library for introspecting the call stack
-and active restarts.")
- (license license:zlib))))
+ "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-dissect
- (sbcl-package->cl-source-package sbcl-dissect))
+(define-public cl-com.gigamonkeys.binary-data
+ (sbcl-package->cl-source-package sbcl-com.gigamonkeys.binary-data))
-(define-public ecl-dissect
- (sbcl-package->ecl-package sbcl-dissect))
+(define-public ecl-com.gigamonkeys.binary-data
+ (sbcl-package->ecl-package sbcl-com.gigamonkeys.binary-data))
-(define-public sbcl-exponential-backoff
- (let ((commit "8d9e8444d8b3184a524c12ce3449f91613ab714f"))
+(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-command-line-arguments
+ (let ((commit "fbac862fb01c0e368141204f3f639920462c23fe")
+ (revision "1"))
(package
- (name "sbcl-exponential-backoff")
- (version (git-version "0" "1" commit))
+ (name "sbcl-command-line-arguments")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/death/exponential-backoff")
+ (url "https://github.com/fare/command-line-arguments")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1389hm9hxv85s0125ja4js1bvh8ay4dsy9q1gaynjv27ynik6gmv"))))
+ (base32 "054m1ikndzqf72mb9ajaa64136cwr3bgag4yfbi1574a9vq75mjq"))))
(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.")
+ (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-exponential-backoff
- (sbcl-package->cl-source-package sbcl-exponential-backoff))
+(define-public cl-command-line-arguments
+ (sbcl-package->cl-source-package sbcl-command-line-arguments))
-(define-public ecl-exponential-backoff
- (sbcl-package->ecl-package sbcl-exponential-backoff))
+(define-public ecl-command-line-arguments
+ (sbcl-package->ecl-package sbcl-command-line-arguments))
-(define-public sbcl-sxql
- (let ((commit "cc3478cacb0557475a59cf619dad66c5dc8080ba")
+(define-public sbcl-common-lisp-jupyter
+ (let ((commit "ba9f0e746b9200d6fd6db647d7274448119ed01b")
(revision "3"))
(package
- (name "sbcl-sxql")
+ (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/fukamachi/sxql")
+ (url "https://github.com/yitzchak/common-lisp-jupyter")
(commit commit)))
- (file-name (git-file-name "cl-sqxl" version))
+ (file-name (git-file-name "common-lisp-jupyter" commit))
(sha256
- (base32 "011an993amy8q3gl4hyqrgnc93cgny3cv9gbp679rrmyyp8zmywr"))))
+ (base32 "0si69xfzi769dprwfy7gp1x3bl7lxz6d4n98sa26w9r41wvay5ja"))))
(build-system asdf-build-system/sbcl)
(inputs
(list sbcl-alexandria
- sbcl-cl-package-locks
- sbcl-cl-syntax
+ sbcl-babel
+ sbcl-bordeaux-threads
+ sbcl-cl-base64
+ sbcl-cl-indentify
+ sbcl-closer-mop
+ sbcl-dissect
+ sbcl-eclector
+ sbcl-ironclad
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-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-sxql
- (sbcl-package->cl-source-package sbcl-sxql))
+(define-public cl-common-lisp-jupyter
+ (sbcl-package->cl-source-package sbcl-common-lisp-jupyter))
-(define-public ecl-sxql
- (sbcl-package->ecl-package sbcl-sxql))
+(define-public ecl-common-lisp-jupyter
+ (sbcl-package->ecl-package sbcl-common-lisp-jupyter))
-(define-public sbcl-cl-ascii-table
- (let ((commit "d9f5e774a56fad1b416e4dadb8f8a5b0e84094e2")
- (revision "1"))
+(define-public sbcl-compatible-metaclasses
+ (package
+ (name "sbcl-compatible-metaclasses")
+ (version "1.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/Hexstream/compatible-metaclasses")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-compatible-metaclasses" version))
+ (sha256
+ (base32 "17cf74j400cl6sjslfhkv13lir85k705v63mx3dd4y6dl5hvsdh6"))))
+ (build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-parachute))
+ (inputs
+ (list sbcl-class-options
+ sbcl-closer-mop
+ sbcl-enhanced-find-class))
+ (home-page "https://www.hexstreamsoft.com/libraries/compatible-metaclasses/")
+ (synopsis "Simplifies class mixins by validating superclasses")
+ (description
+ "This library validates superclasses according to a simple substitution
+model, thereby greatly simplifying the definition of class mixins.")
+ (license license:unlicense)))
+
+(define-public cl-compatible-metaclasses
+ (sbcl-package->cl-source-package sbcl-compatible-metaclasses))
+
+(define-public ecl-compatible-metaclasses
+ (sbcl-package->ecl-package sbcl-compatible-metaclasses))
+
+(define-public sbcl-compiler-macro
+ (let ((commit "7796bda64aec5af3ca175170ad3565167868789c")
+ (revision "0"))
(package
- (name "sbcl-cl-ascii-table")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-compiler-macro")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/telephil/cl-ascii-table")
+ (url "https://github.com/Bike/compiler-macro")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-compiler-macro" version))
(sha256
- (base32 "125fdif9sgl7k0ngjhxv0wjas2q27d075025hvj2rx1b1x948z4s"))))
+ (base32 "13sswps7s0qy6939mvj8q57hkx0qkga6rl6xjhjr7pk7by0xdsjq"))))
(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))))
+ (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-ascii-table
- (sbcl-package->cl-source-package sbcl-cl-ascii-table))
+(define-public cl-compiler-macro
+ (sbcl-package->cl-source-package sbcl-compiler-macro))
-(define-public ecl-cl-ascii-table
- (sbcl-package->ecl-package sbcl-cl-ascii-table))
+(define-public ecl-compiler-macro
+ (sbcl-package->ecl-package sbcl-compiler-macro))
-(define-public sbcl-cl-rdkafka
+(define-public sbcl-compiler-macro-notes
(package
- (name "sbcl-cl-rdkafka")
- (version "1.1.0")
+ (name "sbcl-compiler-macro-notes")
+ (version "0.2.0")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/SahilKang/cl-rdkafka")
+ (url "https://github.com/digikar99/compiler-macro-notes")
(commit (string-append "v" version))))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-compiler-macro-notes" version))
(sha256
- (base32
- "0z2g0k0xy8k1p9g93h8dy9wbygaq7ziwagm4yz93zk67mhc0b84v"))))
+ (base32 "1jv8snj2wvim3k9qhl1vsx82n56nzdmwa3ms9c4ml2d58fwpfjzs"))))
(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)))
+ (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:
-(define-public cl-rdkafka
- (sbcl-package->cl-source-package sbcl-cl-rdkafka))
+@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 ecl-cl-rdkafka
- (sbcl-package->ecl-package sbcl-cl-rdkafka))
+(define-public cl-compiler-macro-notes
+ (sbcl-package->cl-source-package sbcl-compiler-macro-notes))
-(define-public sbcl-acclimation
- (let ((commit "4d51150902568fcd59335f4cc4cfa022df6116a5"))
+(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-acclimation")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-computable-reals")
+ (version (git-version "1.1.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Acclimation")
+ (url "https://github.com/stylewarning/computable-reals")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32
- "1aw7rarjl8ai57h0jxnp9hr3dka7qrs55mmbl1p6rhd6xj8mp9wq"))))
+ (base32 "0f12axi53x14l12dgf4a1lfq3p1fx7fh7sjfc0db3lk88ph9qfwl"))))
(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))))
+ (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-acclimation
- (sbcl-package->cl-source-package sbcl-acclimation))
+(define-public cl-computable-reals
+ (sbcl-package->cl-source-package sbcl-computable-reals))
-(define-public ecl-acclimation
- (sbcl-package->ecl-package sbcl-acclimation))
+(define-public ecl-computable-reals
+ (sbcl-package->ecl-package sbcl-computable-reals))
-(define-public sbcl-clump
- (let ((commit "1ea4dbac1cb86713acff9ae58727dd187d21048a"))
+(define-public sbcl-concrete-syntax-tree
+ (let ((commit "37291727196a3bc88a7be67c1427c52078d4b82c")
+ (revision "0"))
(package
- (name "sbcl-clump")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-concrete-syntax-tree")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/Clump")
+ (url "https://github.com/s-expressionists/Concrete-Syntax-Tree")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-concrete-syntax-tree" commit))
(sha256
- (base32
- "1639msyagsswj85gc0wd90jgh8588j3qg5q70by9s2brf2q6w4lh"))))
+ (base32 "15q9jyqsh2z921li9my8c840cj2ci7k217x5frfiyk0kymkx4rgv"))))
+ (build-system asdf-build-system/sbcl)
(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.
+ (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.
-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.
+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.
-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.")
+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-clump
- (sbcl-package->cl-source-package sbcl-clump))
+(define-public cl-concrete-syntax-tree
+ (sbcl-package->cl-source-package sbcl-concrete-syntax-tree))
-(define-public ecl-clump
- (sbcl-package->ecl-package sbcl-clump))
+(define-public ecl-concrete-syntax-tree
+ (sbcl-package->ecl-package sbcl-concrete-syntax-tree))
-(define-public sbcl-cluffer
- (let ((commit "4aad29c276a58a593064e79972ee4d77cae0af4a"))
+(define-public sbcl-concurrent-hash-tables
+ (let ((commit "6ad539b8970ff94b1e1369b59065ed7d0660904c")
+ (revision "1"))
(package
- (name "sbcl-cluffer")
- (version (git-version "0.0.0" "1" commit))
+ (name "sbcl-concurrent-hash-tables")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/robert-strandh/cluffer")
+ (url "https://github.com/no-defun-allowed/concurrent-hash-tables")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-concurrent-hash-tables" version))
(sha256
- (base32
- "1bcg13g7qb3dr8z50aihdjqa6miz5ivlc9wsj2csgv1km1mak2kj"))))
+ (base32 "0wgbv3wl33rlfbywmjag0gk7igzfksmib30r8cbnd5n47ic09iip"))))
(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.")
+ (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-cluffer
- (sbcl-package->cl-source-package sbcl-cluffer))
+(define-public cl-concurrent-hash-tables
+ (sbcl-package->cl-source-package sbcl-concurrent-hash-tables))
-(define-public ecl-cluffer
- (sbcl-package->ecl-package sbcl-cluffer))
+(define-public ecl-concurrent-hash-tables
+ (sbcl-package->ecl-package sbcl-concurrent-hash-tables))
-(define-public sbcl-cl-libsvm-format
- (let ((commit "3300f84fd8d9f5beafc114f543f9d83417c742fb")
- (revision "0"))
+(define-public sbcl-conduit-packages
+ (package
+ (name "sbcl-conduit-packages")
+ (version "2.0.0")
+ (source
+ (origin
+ (method git-fetch)
+ (uri (git-reference
+ (url "https://github.com/tfeb/conduit-packages")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-conduit-packages" version))
+ (sha256
+ (base32 "1n783in84mrk9lnc3nshwsgxhb8y0dk6ys9z6jlxkv0jpjxhpjjc"))))
+ (build-system asdf-build-system/sbcl)
+ (arguments '(#:asd-systems '("org.tfeb.conduit-packages")))
+ (synopsis "Conduit packages for Common Lisp")
+ (description "This library defines a way of treating Common Lisp
+packages as conduits which can sit between one or more implementation
+packages and users of those packages.")
+ (home-page "https://github.com/tfeb/conduit-packages/")
+ (license license:expat)))
+
+(define-public cl-conduit-packages
+ (sbcl-package->cl-source-package sbcl-conduit-packages))
+
+(define-public ecl-conduit-packages
+ (sbcl-package->ecl-package sbcl-conduit-packages))
+
+(define-public sbcl-conium
+ (let ((commit "089adfd8759ec7973bb6f67b98d7a246e67aeb05")
+ (revision "1"))
(package
- (name "sbcl-cl-libsvm-format")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-conium")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/masatoi/cl-libsvm-format")
+ (url "https://github.com/sharplispers/conium")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "conium" version))
(sha256
- (base32
- "0284aj84xszhkhlivaigf9qj855fxad3mzmv3zfr0qzb5k0nzwrg"))))
+ (base32 "0y31za8xr8734p2pf8mrw1jd1fksh2d4y1p12wwjyn8hxxsvsx1w"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-prove))
(inputs
- (list sbcl-alexandria))
- (synopsis "LibSVM data format reader for Common Lisp")
+ (list sbcl-closer-mop))
+ (home-page "https://github.com/sharplispers/conium")
+ (synopsis "Portability library for debugger- and compiler-related tasks")
(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))))
+ "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-libsvm-format
- (sbcl-package->cl-source-package sbcl-cl-libsvm-format))
+(define-public cl-conium
+ (sbcl-package->cl-source-package sbcl-conium))
-(define-public ecl-cl-libsvm-format
- (sbcl-package->ecl-package sbcl-cl-libsvm-format))
+(define-public ecl-conium
+ (sbcl-package->ecl-package sbcl-conium))
-(define-public sbcl-cl-online-learning
- (let ((commit "87fbef8a340219e853adb3a5bf44a0470da76964")
+(define-public sbcl-constantfold
+ (let ((commit "0ff1d97a3fbcb89264f6a2af6ce62b73e7b421f4")
(revision "1"))
(package
- (name "sbcl-cl-online-learning")
- (version (git-version "0.5" revision commit))
+ (name "sbcl-constantfold")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/masatoi/cl-online-learning")
+ (url "https://github.com/numcl/constantfold")
(commit commit)))
- (file-name (git-file-name "cl-online-learning" version))
+ (file-name (git-file-name name version))
(sha256
(base32
- "1lfq04lnxivx59nq5dd02glyqsqzf3vdn4s9b8wnaln5fs8g2ph9"))))
+ "153h0569z6bff1qbad0bdssplwwny75l7ilqwcfqfdvzsxf9jh06"))))
(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")
+ (synopsis "Support library for numcl")
(description
- "This library contains a collection of machine learning algorithms for
-online linear classification written in Common Lisp.")
- (license license:expat))))
+ "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-online-learning
- (sbcl-package->cl-source-package sbcl-cl-online-learning))
+(define-public cl-constantfold
+ (sbcl-package->cl-source-package sbcl-constantfold))
-(define-public ecl-cl-online-learning
- (sbcl-package->ecl-package sbcl-cl-online-learning))
+(define-public ecl-constantfold
+ (sbcl-package->ecl-package sbcl-constantfold))
-(define-public sbcl-cl-mpg123
- (let ((commit "5f042c839d2ea4a2ff2a7b60c839d8633d64161d")
- (revision "1"))
+(define-public sbcl-contextl
+ ;; No release since 2013.
+ (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb")
+ (revision "2"))
(package
- (name "sbcl-cl-mpg123")
+ (name "sbcl-contextl")
(version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-mpg123")
+ (url "https://github.com/pcostanza/contextl/")
(commit commit)))
- (file-name (git-file-name "cl-mpg123" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1hl721xaczxck008ax2y3jpkm509ry1sg3lklh2k76764m3ndrjf"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; Remove bundled pre-compiled libraries.
- (delete-file-recursively "static")
- #t))))
+ (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0"))))
(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))))
+ (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).
-(define-public ecl-cl-mpg123
- (sbcl-package->ecl-package sbcl-cl-mpg123))
+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-mpg123
- (sbcl-package->cl-source-package sbcl-cl-mpg123))
+(define-public cl-contextl
+ (sbcl-package->cl-source-package sbcl-contextl))
-(define-public sbcl-cl-out123
- (let ((commit "41771bfd419e7349ad569f8e6fcd8a26d6f9e5b7")
- (revision "2"))
+(define-public ecl-contextl
+ (sbcl-package->ecl-package sbcl-contextl))
+
+(define-public sbcl-core-gp
+ (let ((commit "90ec1c4599a19c5a911be1f703f78d5108aee160")
+ (revision "1"))
(package
- (name "sbcl-cl-out123")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-core-gp")
+ (version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shirakumo/cl-out123")
+ (url "https://github.com/jorgetavares/core-gp")
(commit commit)))
- (file-name (git-file-name "cl-out123" version))
+ (file-name (git-file-name "cl-core-gp" version))
(sha256
- (base32 "0ahgc5l5lbpl3ini4pn5crh8b7dlr386pxczl0d4h6djhccxzs4w"))
- (modules '((guix build utils)))
- (snippet
- '(begin
- ;; Remove bundled pre-compiled libraries.
- (delete-file-recursively "static")))))
+ (base32 "0nzlb2gwqisa1amlpl4zc5xxph2g3qwhfyaxchci67d31rzws6l3"))))
(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")
+ (home-page "https://github.com/jorgetavares/core-gp")
+ (synopsis "Common Lisp library for genetic programming")
(description
- "This is a bindings library to @code{libout123} which allows easy
-cross-platform audio playback.")
- (license license:zlib))))
+ "@code{core-gp} is a Common Lisp library for genetic programming (GP)
+algorithms. It allows standard GP, strongly-typed GP, grammatical evolution as
+well as standard genetic algorithms.")
+ (license license:expat))))
-(define-public ecl-cl-out123
- (sbcl-package->ecl-package sbcl-cl-out123))
+(define-public cl-core-gp
+ (sbcl-package->cl-source-package sbcl-core-gp))
-(define-public cl-out123
- (sbcl-package->cl-source-package sbcl-cl-out123))
+(define-public ecl-core-gp
+ (sbcl-package->ecl-package sbcl-core-gp))
-(define-public sbcl-cl-portaudio
- (let ((commit "c50cd061c25216a736f684e45101f5c0188a384f")
+(define-public sbcl-croatoan
+ (let ((commit "282145ff9e9005fddc4241bc6827b3ab09c5bd25")
(revision "1"))
(package
- (name "sbcl-cl-portaudio")
- (version (git-version "1.0.0" revision commit))
+ (name "sbcl-croatoan")
+ (version (git-version "2.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/filonenko-mikhail/cl-portaudio")
+ (url "https://github.com/McParen/croatoan")
(commit commit)))
- (file-name (git-file-name "cl-portaudio" version))
+ (file-name (git-file-name "cl-croatoan" version))
(sha256
- (base32 "177c6bgf30caj5qpzfnzhbamax7c5zm2p4911mw7fay94vjs7zyb"))))
+ (base32 "021h2f2yj4j9gynr3k7qi36x94jm5b95p3vaddbaih96wyzgbmq5"))))
(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")
+ '(#: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-portaudio
- (sbcl-package->cl-source-package sbcl-cl-portaudio))
+(define-public cl-croatoan
+ (sbcl-package->cl-source-package sbcl-croatoan))
-(define-public ecl-cl-portaudio
- (sbcl-package->ecl-package sbcl-cl-portaudio))
+(define-public ecl-croatoan
+ (sbcl-package->ecl-package sbcl-croatoan))
-(define-public sbcl-cl-random-forest
- (let ((commit "fedb36ce99bb6f4d7e3a7dd6d8b058f331308f91")
+(define-public sbcl-crypto-shortcuts
+ (let ((commit "7efd22d80e867cd8c9f8f363d4fe7b51ee2dadc0")
(revision "1"))
(package
- (name "sbcl-cl-random-forest")
- (version (git-version "0.1" revision commit))
+ (name "sbcl-crypto-shortcuts")
+ (version (git-version "2.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/masatoi/cl-random-forest")
+ (url "https://github.com/Shinmera/crypto-shortcuts")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "crypto-shortcuts" version))
(sha256
- (base32
- "0wqh4dxy5hrvm14jgyfypwhdw35f24rsksid4blz5a6l2z16rlmq"))))
+ (base32 "0c0m0ar04jn7qf2v8c4sivamlzki03r13rnxy8b3n27rh9r6hgin"))))
(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-cl-base64 sbcl-flexi-streams sbcl-ironclad))
+ (synopsis "Collection of common cryptography functions")
(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 collection of common cryptography functions for Common
+Lisp.")
+ (home-page "https://shinmera.github.io/crypto-shortcuts/")
+ (license license:zlib))))
-(define-public cl-random-forest
- (sbcl-package->cl-source-package sbcl-cl-random-forest))
+(define-public cl-crypto-shortcuts
+ (sbcl-package->cl-source-package sbcl-crypto-shortcuts))
-(define-public ecl-cl-random-forest
- (sbcl-package->ecl-package sbcl-cl-random-forest))
+(define-public ecl-crypto-shortcuts
+ (sbcl-package->ecl-package sbcl-crypto-shortcuts))
-(define-public sbcl-bordeaux-fft
- (let ((commit "4a1f5600cae59bdabcb32de4ee2d7d73a9450d6e")
+(define-public sbcl-css-lite
+ (let ((commit "6ee4e6212ed56943d665df163d2a834b122e6273")
(revision "0"))
(package
- (name "sbcl-bordeaux-fft")
- (version (git-version "1.0.1" revision commit))
+ (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/ahefner/bordeaux-fft")
+ (url "https://github.com/s-expressionists/ctype")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-ctype" version))
(sha256
- (base32 "0j584w6kq2k6r8lp2i14f9605rxhp3r15s33xs08iz1pndn6iwqf"))))
+ (base32 "05smc81ml9rbcbzdhqg2mi9drnjsipq62r5q7f7qql8hbx01vl9i"))))
(build-system asdf-build-system/sbcl)
- (home-page "http://vintage-digital.com/hefner/software/bordeaux-fft/")
- (synopsis "Fast Fourier Transform for Common Lisp")
+ (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
- "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+))))
+ "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-bordeaux-fft
- (sbcl-package->cl-source-package sbcl-bordeaux-fft))
+(define-public cl-ctype
+ (sbcl-package->cl-source-package sbcl-ctype))
-(define-public ecl-bordeaux-fft
- (sbcl-package->ecl-package sbcl-bordeaux-fft))
+(define-public ecl-ctype
+ (sbcl-package->ecl-package sbcl-ctype))
-(define-public sbcl-napa-fft3
- (let ((commit "f2d9614c7167da327c9ceebefb04ff6eae2d2236")
+(define-public sbcl-curry-compose-reader-macros
+ (let ((commit "beaa92dedf392726c042184bfd6149fa8d9e6ac2")
(revision "0"))
(package
- (name "sbcl-napa-fft3")
- (version (git-version "0.0.1" revision commit))
+ (name "sbcl-curry-compose-reader-macros")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/pkhuong/Napa-FFT3")
- (commit commit)))
+ (uri
+ (git-reference
+ (url "https://github.com/eschulte/curry-compose-reader-macros")
+ (commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1hxjf599xgwm28gbryy7q96j9ys6hfszmv0qxpr5698hxnhknscp"))))
+ (base32
+ "0rv9bl8xrad5wfcg5zs1dazvnpmvqz6297lbn8bywsrcfnlf7h98"))))
(build-system asdf-build-system/sbcl)
- (home-page "https://github.com/pkhuong/Napa-FFT3")
- (synopsis "Fast Fourier Transform routines in Common Lisp")
+ (inputs
+ (list sbcl-alexandria sbcl-named-readtables))
+ (synopsis "Reader macros for partial application and composition")
(description
- "Napa-FFT3 provides Discrete Fourier Transform (DFT) routines, but also
-buildings blocks to express common operations that involve DFTs: filtering,
-convolutions, etc.")
- (license license:bsd-3))))
+ "This 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-napa-fft3
- (sbcl-package->cl-source-package sbcl-napa-fft3))
+(define-public cl-curry-compose-reader-macros
+ (sbcl-package->cl-source-package sbcl-curry-compose-reader-macros))
-(define-public sbcl-cl-tga
- (let ((commit "4dc2f7b8a259b9360862306640a07a23d4afaacc")
- (revision "0"))
+(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-cl-tga")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-custom-hash-table")
+ (version (git-version "0.3" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/fisxoj/cl-tga")
+ (url "https://github.com/metawilm/cl-custom-hash-table")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "03k3npmn0xd3fd2m7vwxph82av2xrfb150imqrinlzqmzvz1v1br"))))
+ (base32 "1k4mvrpbqqds2fwjxp1bxmrfmr8ch4dkwhnkbw559knbqshvrlj5"))))
(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.")
+ (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-tga
- (sbcl-package->cl-source-package sbcl-cl-tga))
+(define-public cl-custom-hash-table
+ (sbcl-package->cl-source-package sbcl-custom-hash-table))
-(define-public ecl-cl-tga
- (sbcl-package->ecl-package sbcl-cl-tga))
+(define-public ecl-custom-hash-table
+ (sbcl-package->ecl-package sbcl-custom-hash-table))
-(define-public sbcl-com.gigamonkeys.binary-data
- (let ((commit "22e908976d7f3e2318b7168909f911b4a00963ee")
- (revision "0"))
+(define-public sbcl-cxml
+ (let ((commit "00b22bf4c4cf11c993d5866fae284f95ab18e6bf")
+ (revision "1"))
(package
- (name "sbcl-com.gigamonkeys.binary-data")
+ (name "sbcl-cxml")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/gigamonkey/monkeylib-binary-data")
+ (url "https://github.com/sharplispers/cxml")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "072v417vmcnvmyh8ddq9vmwwrizm7zwz9dpzi14qy9nsw8q649zw"))))
+ (base32
+ "13kif7rf3gqdycsk9zq0d7y0g9y81krkl0z87k0p2fkbjfgrph37"))))
(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
- (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)))
+ (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-deflate
- (sbcl-package->cl-source-package sbcl-deflate))
+(define-public cl-cxml
+ (sbcl-package->cl-source-package sbcl-cxml))
-(define-public ecl-deflate
- (sbcl-package->ecl-package sbcl-deflate))
+(define-public ecl-cxml
+ (sbcl-package->ecl-package sbcl-cxml))
-(define-public sbcl-skippy
- (let ((commit "e456210202ca702c792292c5060a264d45e47090")
- (revision "0"))
+(define-public sbcl-cxml-rng
+ (let ((commit "bdcfeb92798694b2935a8321e641d8803e814b7b")
+ (revision "1"))
(package
- (name "sbcl-skippy")
- (version (git-version "1.3.12" revision commit))
+ (name "sbcl-cxml-rng")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/xach/skippy")
+ (url "http://www.lichteblau.com/git/cxml-rng.git")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1sxbn5nh24qpx9w64x8mhp259cxcl1x8p126wk3b91ijjsj7l5vj"))))
+ (base32
+ "1rld038hmvm0whaffkszd5ks7mg44z1vfbgddal434df8sgspzql"))))
(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))))
+ (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-skippy
- (sbcl-package->cl-source-package sbcl-skippy))
+(define-public cl-cxml-rng
+ (sbcl-package->cl-source-package sbcl-cxml-rng))
-(define-public ecl-skippy
- (sbcl-package->ecl-package sbcl-skippy))
+;; FIXME: Fails on ECL with
+;; In function STRUCTURE-SET, the value of the first argument is
+;; #<empty 0x7fffeb0fd440>
+;; which is not of the expected type %TYPED-PATTERN.
+;; (define-public ecl-cxml-rng
+;; (sbcl-package->ecl-package sbcl-cxml-rng))
-(define-public sbcl-cl-freetype2
- (let ((commit "8bcb232b319a66fb700eaea88d0b308a837bce04")
+(define-public sbcl-daemon
+ (let ((commit "d5652f4332c3cee21e9bf83b9237129605004597")
(revision "1"))
(package
- (name "sbcl-cl-freetype2")
- (version (git-version "1.1" revision commit))
+ (name "sbcl-daemon")
+ (version (git-version "0.0.4" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/rpav/cl-freetype2")
+ (url "https://github.com/snmsts/daemon")
(commit commit)))
- (file-name (git-file-name "cl-freetype2" version))
+ (file-name (git-file-name "daemon" version))
(sha256
- (base32 "1nhq3qslja0bcgpbmzfycqhd4vw1l58zh4ia15m1h6535qxliy0q"))))
+ (base32 "1kdxfnhh9fz34j8qs7pn7mwjz3v33q4v9nh0hqkyzraq5xs2j3f4"))))
(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")
+ (list sbcl-trivial-features))
+ (home-page "https://github.com/snmsts/daemon")
+ (synopsis "Daemonize Common Lisp processes")
(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))))
+ "DAEMON provides the functionality of daemonizing Common Lisp processes
+on UNIX like platforms.")
+ (license license:expat))))
-(define-public cl-freetype2
- (sbcl-package->cl-source-package sbcl-cl-freetype2))
+(define-public cl-daemon
+ (sbcl-package->cl-source-package sbcl-daemon))
-(define-public ecl-cl-freetype2
- (sbcl-package->ecl-package sbcl-cl-freetype2))
+(define-public ecl-daemon
+ (sbcl-package->ecl-package sbcl-daemon))
-(define-public sbcl-opticl-core
- (let ((commit "b7cd13d26df6b824b216fbc360dc27bfadf04999")
- (revision "0"))
+(define-public sbcl-data-format-validation
+ (let ((commit "95d44766e829582598f9dcdc5c23719c462d5bfb")
+ (revision "1"))
(package
- (name "sbcl-opticl-core")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-data-format-validation")
+ (version (git-version "0.2.0" revision commit))
(source
(origin
(method git-fetch)
- (uri (git-reference
- (url "https://github.com/slyrus/opticl-core")
- (commit commit)))
- (file-name (git-file-name name version))
+ (uri
+ (git-reference
+ (url "https://github.com/willijar/cl-data-format-validation/")
+ (commit commit)))
+ (file-name (git-file-name "data-format-validation" version))
(sha256
- (base32 "0458bllabcdjghfrqx6aki49c9qmvfmkk8jl75cfpi7q0i12kh95"))))
+ (base32
+ "0zmk47xmicyqvp1impn8kgh5373ysmx3gfpqcvbi9r31qsir2nqa"))))
(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")
+ (list sbcl-cl-ppcre))
+ (synopsis "Validation and conversion between user and internal data")
(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))
+ "@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-retrospectiff
- (let ((commit "2fbf8c687799487654d988c7036d19d75a7fc67d")
- (revision "1"))
+(define-public sbcl-data-frame
+ (let ((commit "6f02e58312654ddf19d686f234dcf699fc4cd0f5")
+ (revision "0"))
(package
- (name "sbcl-retrospectiff")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-data-frame")
+ (version (git-version "1.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slyrus/retrospectiff")
+ (url "https://github.com/Lisp-Stat/data-frame")
(commit commit)))
- (file-name (git-file-name "cl-retrospectiff" version))
+ (file-name (git-file-name "cl-data-frame" version))
(sha256
- (base32 "1vfcbfzhkm2wkxnjg7y6gg93wlib9cqpbdbhyqcm5kc7170ci3vz"))))
+ (base32 "0bs1jh66bml25bj1lxdzz8cjhj3g060yyd5ggqsnsr4l2j0zyszv"))))
(build-system asdf-build-system/sbcl)
- (native-inputs
- (list sbcl-fiveam))
+ (native-inputs (list sbcl-clunit2))
(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))))
+ (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-retrospectif
- (sbcl-package->cl-source-package sbcl-retrospectiff))
+(define-public cl-data-frame
+ (sbcl-package->cl-source-package sbcl-data-frame))
-(define-public ecl-retrospectiff
- (sbcl-package->ecl-package sbcl-retrospectiff))
+;; 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-mmap
- (let ((commit "ba2e98c67e25f0fb8ff838238561120a23903ce7")
+(define-public sbcl-data-lens
+ (let ((commit "801bc1e0331f19fdc38be314c86ccac9362fde78")
(revision "0"))
(package
- (name "sbcl-mmap")
- (version (git-version "1.0.0" revision commit))
- (source
+ (name "sbcl-data-lens")
+ (version (git-version "0.0.0" revision commit))
+ (source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/Shinmera/mmap")
+ (url "https://github.com/fiddlerwoaroof/data-lens")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-data-lens" 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))))
+ (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-mmap
- (sbcl-package->cl-source-package sbcl-mmap))
+(define-public cl-data-lens
+ (sbcl-package->cl-source-package sbcl-data-lens))
-(define-public ecl-mmap
- (sbcl-package->ecl-package sbcl-mmap))
+(define-public ecl-data-lens
+ (sbcl-package->ecl-package sbcl-data-lens))
-(define-public sbcl-marray
- (let ((commit "0352f316b6830f0b119088ba9be836e4726bd7d8")
- (revision "0"))
+(define-public sbcl-data-sift
+ (let ((commit "fd617d8200cdcc1b87ecf45ab59bb38e8b16ef7e")
+ (revision "1"))
(package
- (name "sbcl-marray")
+ (name "sbcl-data-sift")
(version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/death/marray")
+ (url "https://github.com/archimag/data-sift")
(commit commit)))
- (file-name (git-file-name "cl-marray" version))
+ (file-name (git-file-name "cl-data-sift" version))
(sha256
- (base32 "0l4kvzpiw14vqhlsaflp3c7y51vznjjgbdi0q3axqk1wxvzy1zlx"))))
+ (base32 "1v7gf0x4ibjzp0c56n9m77hxdgwcm9356zlk5n4l3fx4i0hj6146"))))
(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")
+ ;; 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
- "MARRAY is a library which provides access to memory-mapped files
-through Common Lisp arrays.")
- (license license:expat))))
+ "@code{DATA-SIFT} is a Common Lisp data validation and transformation
+library inspired by @code{cl-data-format-validation} and WTForms validators.")
+ (license license:llgpl))))
-(define-public cl-marray
- (sbcl-package->cl-source-package sbcl-marray))
+(define-public cl-data-sift
+ (sbcl-package->cl-source-package sbcl-data-sift))
-;; ECL support not implemented yet.
-;; (define-public ecl-marray
-;; (sbcl-package->ecl-package sbcl-marray))
+(define-public ecl-data-sift
+ (sbcl-package->ecl-package sbcl-data-sift))
-(define-public sbcl-3bz
- (let ((commit "569614c40408f3aefc77ba233e0e4bd66d3850ad")
+(define-public sbcl-datafly
+ (let ((commit "adece27fcbc4b5ea39ad1a105048b6b7166e3b0d")
(revision "1"))
(package
- (name "sbcl-3bz")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-datafly")
+ (version (git-version "0.1" revision commit))
+ (home-page "https://github.com/fukamachi/datafly")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/3b/3bz")
+ (url home-page)
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "0kvvlvf50jhhw1s510f3clpr1a68632bq6d698yxcrx722igcrg4"))))
+ (base32 "16b78kzmglp2a4nxlxxl7rpf5zaibsgagn0p3c56fsxvx0c4hszv"))))
(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-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)))
+ `(("alexandria" ,sbcl-alexandria)
+ ("iterate" ,sbcl-iterate)
+ ("optima" ,sbcl-optima)
+ ("trivial-types" ,sbcl-trivial-types)
+ ("closer-mop" ,sbcl-closer-mop)
+ ("cl-syntax" ,sbcl-cl-syntax)
+ ("sxql" ,sbcl-sxql)
+ ("dbi" ,sbcl-dbi)
+ ("babel" ,sbcl-babel)
+ ("local-time" ,sbcl-local-time)
+ ("function-cache" ,sbcl-function-cache)
+ ("jonathan" ,sbcl-jonathan)
+ ("kebab" ,sbcl-kebab)
+ ("log4cl" ,sbcl-log4cl)))
+ (native-inputs
+ (list sbcl-prove))
+ (arguments
+ ;; TODO: Tests fail with
+ ;; While evaluating the form starting at line 22, column 0
+ ;; of #P"/tmp/guix-build-sbcl-datafly-0.1-1.adece27.drv-0/source/t/datafly.lisp":
+ ;; Unhandled SQLITE:SQLITE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING
+ ;; {10009F8083}>:
+ ;; Error when binding parameter 1 to value NIL.
+ ;; Code RANGE: column index out of range.
+ `(#:tests? #f))
+ (synopsis "Lightweight database library for Common Lisp")
+ (description "Datafly is a lightweight database library for Common Lisp.")
+ (license license:bsd-3))))
-(define-public cl-zpb-exif
- (sbcl-package->cl-source-package sbcl-zpb-exif))
+(define-public cl-datafly
+ (sbcl-package->cl-source-package sbcl-datafly))
-(define-public ecl-zpb-exif
- (sbcl-package->ecl-package sbcl-zpb-exif))
+(define-public ecl-datafly
+ (sbcl-package->ecl-package sbcl-datafly))
-(define-public sbcl-pngload
- (let ((commit "91f1d703c65bb6a94d6fee06ddbbbbbc5778b71f")
- (revision "2"))
+(define-public sbcl-db3
+ (let ((commit "38e5ad35f025769fb7f8dcdc6e56df3e8efd8e6d")
+ (revision "1"))
(package
- (name "sbcl-pngload")
- (version (git-version "2.0.0" revision commit))
+ (name "sbcl-db3")
+ (version (git-version "0.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://git.mfiano.net/mfiano/pngload.git")
+ (url "https://github.com/dimitri/cl-db3")
(commit commit)))
- (file-name (git-file-name "pngload" version))
+ (file-name (git-file-name "cl-db3" version))
(sha256
- (base32 "0s94fdbrbqj12qvgyn2g4lfwvz7qhhzbclrpz5ni7adwxgrmvxl1"))))
+ (base32 "1i7j0mlri6kbklcx1lsm464s8kmyhhij5c4xh4aybrw8m4ixn1s5"))))
(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")
+ (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 to load images in the PNG image format,
-both from files on disk, or streams in memory.")
- (license license:expat))))
+ "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-pngload
- (sbcl-package->cl-source-package sbcl-pngload))
+(define-public cl-db3
+ (sbcl-package->cl-source-package sbcl-db3))
-(define-public ecl-pngload
- (sbcl-package->ecl-package sbcl-pngload))
+(define-public ecl-db3
+ (sbcl-package->ecl-package sbcl-db3))
-(define-public sbcl-opticl
- (let ((commit "f6fc4dc5fa61ae3f2527b77e4bda99001ba37dcb")
- (revision "1"))
+(define-public sbcl-dbi
+ (let ((commit "738a74dd69adb2a7c21fa67e140d89c7df25b227")
+ (revision "2"))
(package
- (name "sbcl-opticl")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-dbi")
+ (version (git-version "0.9.5" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/slyrus/opticl")
+ (url "https://github.com/fukamachi/cl-dbi")
(commit commit)))
- (file-name (git-file-name "cl-opticl" version))
+ (file-name (git-file-name "cl-dbi" version))
(sha256
- (base32 "1jx9n78d4lf53iz24yid34l92zrpqxfihv6049ixcy0xigf7j4ac"))))
+ (base32 "0f8z7an8ssg8mdf9k781r4ygdppv798v6f08ibgpd8mv8a6491fg"))))
(build-system asdf-build-system/sbcl)
(native-inputs
- (list sbcl-fiveam))
+ `(("alexandria" ,sbcl-alexandria)
+ ("rove" ,sbcl-rove)
+ ("trivial-types" ,sbcl-trivial-types)))
(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")
+ `(("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
- "Opticl is a Common Lisp library for representing, processing, loading,
-and saving 2-dimensional pixel-based images.")
- (license license:bsd-2))))
+ "@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-opticl
- (sbcl-package->cl-source-package sbcl-opticl))
+(define-public cl-dbi
+ (sbcl-package->cl-source-package sbcl-dbi))
-(define-public ecl-opticl
- (sbcl-package->ecl-package sbcl-opticl))
+(define-public ecl-dbi
+ (sbcl-package->ecl-package sbcl-dbi))
-(define-public sbcl-cl-dejavu
- (let ((commit "9d68ced4edee6f96fead42cb4835d0ff4a158373")
+(define-public sbcl-dbus
+ (let ((commit "24b452df3a45ca5dc95015500f34baad175c981a")
(revision "1"))
(package
- (name "sbcl-cl-dejavu")
- (version (git-version "0.0.0" revision commit))
+ (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 "https://github.com/dkochmanski/cl-dejavu")
+ (url home-page)
(commit commit)))
- (file-name (git-file-name "cl-dejavu" version))
+ (file-name (git-file-name name version))
(sha256
- (base32 "1lbxiq21bxj8r11c58cqskgn8gnl2p8q1ydkhdsv7i7xnhv2y7r0"))))
+ (base32
+ "0fw2q866yddbf23nk9pxphm9gsasx35vjyss82xzvndnjmzlqfl5"))))
(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/"))))))
+ (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-dejavu
- (sbcl-package->cl-source-package sbcl-cl-dejavu))
+(define-public cl-dbus
+ (sbcl-package->cl-source-package sbcl-dbus))
-(define-public ecl-dejavu
- (sbcl-package->ecl-package sbcl-cl-dejavu))
+(define-public ecl-dbus
+ (sbcl-package->ecl-package sbcl-dbus))
-(define-public sbcl-mcclim
+(define-public sbcl-decimals
(package
- (name "sbcl-mcclim")
- (version "0.9.8")
+ (name "sbcl-decimals")
+ (version "2021")
(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))
+ (url "https://github.com/tlikonen/cl-decimals")
+ (commit version)))
+ (file-name (git-file-name "cl-decimals" version))
(sha256
- (base32 "0gbi61jnnsz6fvhv18mf57jkq46bvcd0355vqdcnrni7xyi10sk8"))))
+ (base32 "0wn5hq1pwd3wpjqqhpjzarcdk1q6416g8y447iaf55j5nbhlmbn6"))))
(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+)))
+ (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-mcclim
- (sbcl-package->cl-source-package sbcl-mcclim))
+(define-public cl-decimals
+ (sbcl-package->cl-source-package sbcl-decimals))
-(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 ecl-decimals
+ (sbcl-package->ecl-package sbcl-decimals))
-(define-public sbcl-cl-inflector
- (let ((commit "f1ab16919ccce3bd82a0042677d9616dde2034fe")
- (revision "1"))
+(define-public sbcl-deeds
+ ;; taged branch is outdated
+ (let ((revision "1")
+ (commit "f5df54eac79b58a34030e0eb8acf3952c788410d"))
(package
- (name "sbcl-cl-inflector")
- (version (git-version "0.2" revision commit))
+ (name "sbcl-deeds")
+ (version (git-version "1.1.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/AccelerationNet/cl-inflector")
+ (url "https://github.com/Shinmera/deeds")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "1xwwlhik1la4fp984qnx2dqq24v012qv4x0y49sngfpwg7n0ya7y"))))
+ (base32 "062cnb2dwli6pw3zvv46jfxyxdzcbzwsck5pa6nw03qf1j1hyg3k"))))
(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")
+ (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
- "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))))
+ "@code{deeds} allows for efficient event delivery to multiple handlers
+with a complex event filtering system.")
+ (license license:zlib))))
-(define-public cl-inflector
- (sbcl-package->cl-source-package sbcl-cl-inflector))
+(define-public cl-deeds
+ (sbcl-package->cl-source-package sbcl-deeds))
-(define-public ecl-cl-inflector
- (sbcl-package->ecl-package sbcl-cl-inflector))
+(define-public ecl-deeds
+ (sbcl-package->ecl-package sbcl-deeds))
-(define-public sbcl-ixf
- (let ((commit "ed26f87e4127e4a9e3aac4ff1e60d1f39cca5183")
- (revision "1"))
+(define-public sbcl-definitions
+ (let ((commit "1f4bd7a634a2299aea19cefb5da8041bbb27f2ec"))
(package
- (name "sbcl-ixf")
- (version (git-version "0.1.0" revision commit))
+ (name "sbcl-definitions")
+ (version (git-version "1.0.0" "1" commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/dimitri/cl-ixf")
+ (url "https://github.com/Shinmera/definitions/")
(commit commit)))
- (file-name (git-file-name "cl-ixf" version))
+ (file-name (git-file-name "cl-definitions" version))
(sha256
- (base32 "1wjdnf4vr9z7lcfc49kl43g6l2i23q9n81siy494k17d766cdvqa"))))
+ (base32 "16dh9iy3v344xj4qllsp47007px3yx26fxxh9gh2cvs8dqgk3kch"))))
(build-system asdf-build-system/sbcl)
(inputs
- (list sbcl-alexandria
- sbcl-babel
- sbcl-cl-ppcre
- sbcl-ieee-floats
- sbcl-local-time
- sbcl-md5
- sbcl-split-sequence))
- (home-page "https://github.com/dimitri/cl-ixf")
- (synopsis "Parse IBM IXF file format")
+ (list sbcl-documentation-utils))
+ (home-page "https://shinmera.github.io/definitions")
+ (synopsis "General definitions reflection library")
(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))))
+ "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 ecl-ixf
- (sbcl-package->ecl-package sbcl-ixf))
+(define-public cl-definitions
+ (sbcl-package->cl-source-package sbcl-definitions))
-(define-public cl-ixf
- (sbcl-package->cl-source-package sbcl-ixf))
+(define-public ecl-definitions
+ (sbcl-package->ecl-package sbcl-definitions))
-(define-public sbcl-qbase64
+(define-public sbcl-definitions-systems
(package
- (name "sbcl-qbase64")
- (version "0.3.0")
+ (name "sbcl-definitions-systems")
+ (version "2.0.1")
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/chaitanyagupta/qbase64")
- (commit version)))
- (file-name (git-file-name name version))
+ (url "https://github.com/Hexstream/definitions-systems")
+ (commit (string-append "v" version))))
+ (file-name (git-file-name "cl-definitions-systems" version))
(sha256
- (base32 "1dir0s70ca3hagxv9x15zq4p4ajgl7jrcgqsza2n2y7iqbxh0dwi"))))
+ (base32 "009392mj0qdq4jy0dw5r41schnygwj286759yvyg7xja30a0psfq"))))
(build-system asdf-build-system/sbcl)
- (inputs
- (list sbcl-metabang-bind sbcl-trivial-gray-streams))
(native-inputs
- (list sbcl-fiveam))
- (home-page "https://github.com/chaitanyagupta/qbase64")
- (synopsis "Base64 encoder and decoder for Common Lisp")
- (description "@code{qbase64} provides a fast and flexible base64 encoder
-and decoder for Common Lisp.")
- (license license:bsd-3)))
+ (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-qbase64
- (sbcl-package->cl-source-package sbcl-qbase64))
+(define-public cl-definitions-systems
+ (sbcl-package->cl-source-package sbcl-definitions-systems))
-(define-public ecl-qbase64
- (sbcl-package->ecl-package sbcl-qbase64))
+(define-public ecl-definitions-systems
+ (sbcl-package->ecl-package sbcl-definitions-systems))
-(define-public sbcl-lw-compat
- ;; No release since 2013.
- (let ((commit "aabfe28c6c1a4949f9d7b3cb30319367c9fd1c0d"))
+(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-lw-compat")
- (version (git-version "1.0.0" "1" commit))
+ (name "sbcl-defpackage-plus")
+ (version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/pcostanza/lw-compat/")
+ (url "https://github.com/rpav/defpackage-plus")
(commit commit)))
(file-name (git-file-name name version))
(sha256
- (base32 "131rq5k2mlv9bfhmafiv6nfsivl4cxx13d9wr06v5jrqnckh4aav"))))
+ (base32 "0lzljvf343xb6mlh6lni2i27hpm5qd376522mk6hr2pa20vd6rdq"))))
(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))))
+ (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-lw-compat
- (sbcl-package->cl-source-package sbcl-lw-compat))
+(define-public cl-defpackage-plus
+ (sbcl-package->cl-source-package sbcl-defpackage-plus))
-(define-public ecl-lw-compat
- (sbcl-package->ecl-package sbcl-lw-compat))
+(define-public ecl-defpackage-plus
+ (sbcl-package->ecl-package sbcl-defpackage-plus))
-(define-public sbcl-contextl
- ;; No release since 2013.
- (let ((commit "f4fb3f59b0844788613fc4d1cc0d2b08df9488bb")
+(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-contextl")
+ (name "sbcl-deploy")
(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/Shinmera/deploy")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "deploy" version))
(sha256
- (base32 "0apgznz4g6lpmd86lq7w0xddfjgnirk83ig7p0j6i93xadhy9wh0"))))
+ (base32 "07pfkibaridihg8lbq2czwa4iqifqk24n6rx7bfnv7i49p1ppja1"))))
(build-system asdf-build-system/sbcl)
+ (native-inputs
+ (list sbcl-cl-mpg123 sbcl-cl-out123))
(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))))
+ (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-contextl
- (sbcl-package->cl-source-package sbcl-contextl))
+(define-public cl-deploy
+ (sbcl-package->cl-source-package sbcl-deploy))
-(define-public ecl-contextl
- (sbcl-package->ecl-package sbcl-contextl))
+(define-public ecl-deploy
+ (sbcl-package->ecl-package sbcl-deploy))
-(define-public sbcl-hu.dwim.common-lisp
- (let ((commit "90558195773383142a57a16687d5e7f4adea6418"))
+(define-public sbcl-depot
+ (let ((commit "73822d9f480cbad00971b45ee80117297a67fb53")
+ (revision "1"))
(package
- (name "sbcl-hu.dwim.common-lisp")
- (version "2021-01-27")
+ (name "sbcl-depot")
+ (version (git-version "1.0.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.common-lisp/")
+ (url "https://github.com/Shinmera/depot/")
(commit commit)))
- (file-name (git-file-name name version))
(sha256
- (base32 "06zkdw3scnaw0d4nmsgkv7pi7sw00dikdgfgsqmbqfbz2yrsdabk"))))
+ (base32 "1v42pirdwbxy8l8i9a2jmbpri8a62vh0r4vm25xwaak0y4gr71va"))
+ (file-name (git-file-name "depot" version))))
(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))))
+ (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-hu.dwim.common-lisp
- (sbcl-package->cl-source-package sbcl-hu.dwim.common-lisp))
+(define-public cl-depot
+ (sbcl-package->cl-source-package sbcl-depot))
-(define-public ecl-hu.dwim.common-lisp
- (sbcl-package->ecl-package sbcl-hu.dwim.common-lisp))
+(define-public ecl-depot
+ (sbcl-package->ecl-package sbcl-depot))
-(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 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-hu.dwim.common
- (sbcl-package->cl-source-package sbcl-hu.dwim.common))
+(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-hu.dwim.common
- (sbcl-package->ecl-package sbcl-hu.dwim.common))
+(define-public ecl-dexador
+ (sbcl-package->ecl-package sbcl-dexador))
-(define-public sbcl-hu.dwim.defclass-star
- (let ((commit "3086878a485074f9b2913c58267a9b764cd632fd"))
+(define-public sbcl-dfio
+ (let ((commit "5caf473acb9bc464839e87395724cbd941167915")
+ (revision "0"))
(package
- (name "sbcl-hu.dwim.defclass-star")
- ;; We used to set version from the date when it was a darcs repo, so we
- ;; keep the year so that package gets updated on previous installs.
- (version (git-version "2021" "2" commit))
+ (name "sbcl-dfio")
+ (version (git-version "1.0.2" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
- (url "https://github.com/hu-dwim/hu.dwim.defclass-star")
+ (url "https://github.com/Lisp-Stat/dfio")
(commit commit)))
- (file-name (git-file-name name version))
+ (file-name (git-file-name "cl-dfio" version))
(sha256
- (base32 "19ipds9r71qymfdp4izg0l7zmvinp06adr8rdalhaq7v7mzpg83z"))))
+ (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 ;; 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))))
+ (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-hu.dwim.defclass-star
- (sbcl-package->cl-source-package sbcl-hu.dwim.defclass-star))
+(define-public cl-dfio
+ (sbcl-package->cl-source-package sbcl-dfio))
-(define-public ecl-hu.dwim.defclass-star
- (sbcl-package->ecl-package sbcl-hu.dwim.defclass-star))
+;; This depends on ecl-data-frame, which doesn't work yet.
+;; (define-public ecl-dfio
+;; (sbcl-package->ecl-package sbcl-dfio))
-(define-public sbcl-livesupport
- (let ((commit "71e6e412df9f3759ad8378fabb203913d82e228a")
- (revision "1"))
+(define-public sbcl-diff
+ (let ((commit "9c84befa598d4e07c3d223242b5b3f83cd94f301")
+ (revision "1"))
(package
- (name "sbcl-livesupport")
- (version (git-version "0.0.0" revision commit))
+ (name "sbcl-diff")
+ (version (git-version "0.4" revision commit))
(source
(origin
(method git-fetch)