;;; GNU Guix --- Functional package management for GNU
;;;
;;; Copyright © 2022 jgart <jgart@dismail.de>
;;; Copyright © 2022 (unmatched parenthesis <paren@disroot.org>
;;;
;;; This file is not 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 (guixrus packages common lisp)
#:use-module (gnu packages)
#:use-module ((guix licenses) #:prefix license:)
#:use-module (guix packages)
#:use-module (gnu packages audio)
#:use-module (gnu packages gcc)
#:use-module (gnu packages lisp-xyz)
#:use-module (gnu packages lisp-check)
#:use-module (gnu packages linux)
#:use-module (gnu packages music)
#:use-module (guix download)
#:use-module (guix git-download)
#:use-module (guix utils)
#:use-module (guix build utils)
#:use-module (guix build-system asdf)
#:use-module (srfi srfi-1)
#:use-module (srfi srfi-19))
(define-public sbcl-rollbar
(let ((commit "fbaf644e3a0b077f6853d25874de6a5827b4094c")
(revision "0"))
(package
(name "sbcl-rollbar")
(version "0.0.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/adventuring/rollbar.lisp")
(commit commit)))
(sha256
(base32 "01lax9qkb4xcd56ck88ickgpisw30zwg0s3y7rm6cnxv4qgamhzg"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/source) ; FIXME?
(inputs
(list sbcl-alexandria
sbcl-drakma
sbcl-jonathan
sbcl-trivial-backtrace))
(home-page "https://github.com/adventuring/rollbar.lisp")
(synopsis "Rollbar.com interface for Common Lisp")
(description
"Rollbar.com is a service for collecting automated telemetry (ie, bug
reports, mostly) through their web service.")
(license license:bsd-3))))
(define-public sbcl-defstar
(let ((commit "132829dac9f84fa7202a0c5793aa6accb8d2662a")
(revision "0"))
(package
(name "sbcl-defstar")
(version "0.4.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/lisp-maintainers/defstar")
(commit commit)))
(sha256
(base32 "0n6m3aqvdfnsrhlhqjcy72d1i55lbkjg13ij5c7vw003p1n78wxi"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("defstar.asd")))
(home-page "https://github.com/lisp-maintainers/defstar")
(synopsis "Type declarations for defun et all")
(description
"@code{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.")
(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-2am
(let ((commit "1d2fd21bbd8f26ec91b962705cab098dd7b5f11c")
(revision "0"))
(package
(name "sbcl-2am")
(version "0.4.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://gitlab.common-lisp.net/dkochmanski/2am")
(commit commit)))
(sha256
(base32 "0zgx4ymyzvfg44z36yr4l87cd9mprajd7sycr2zc67ab6330rynf"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("2am.asd")))
(home-page "https://gitlab.common-lisp.net/dkochmanski/2am")
(synopsis "Small testing framework based on 1am")
(description
"Small testing framework for Common Lisp. The entire API consists of:
@code{test}, @code{is}, @code{signals}, @code{finishes}, @code{run},
suite and @code{setf} suite.")
(license license:expat))))
(define-public cl-2am
(sbcl-package->cl-source-package sbcl-2am))
(define-public ecl-2am
(sbcl-package->ecl-package sbcl-2am))
(define-public sbcl-cl-hamcrest
(let ((commit "a54553e59a70dc5a539b683e79bfcdb0e8bae5c8")
(revision "0"))
(package
(name "sbcl-cl-hamcrest")
(version "0.4.4")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/40ants/cl-hamcrest")
(commit commit)))
(sha256
(base32 "181nnb2fjbsdqjqdvwg2x9n1jjalkfzszwdgqcap4py2q63q1kxj"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("hamcrest.asd"
"hamcrest-test.asd")
#:asd-systems '("hamcrest"
"hamcrest-test")))
(inputs
(list sbcl-iterate
sbcl-split-sequence
sbcl-cl-ppcre
sbcl-alexandria
sbcl-rove
sbcl-prove))
(home-page "http://40ants.com/cl-hamcrest/")
(synopsis "Make CL unittests more readable")
(description
"@code{sbcl-cl-hamcrest} is an implementation of the Hamcrest idea in Common
Lisp. It simplifes unittests and make them more readable. Hamcrest uses
idea of pattern-matching, to construct matchers from different pieces
and to apply them to the data.")
(license license:bsd-3))))
(define-public cl-hamcrest
(sbcl-package->cl-source-package sbcl-cl-hamcrest))
(define-public ecl-cl-hamcrest
(sbcl-package->ecl-package sbcl-cl-hamcrest))
(define-public sbcl-positional-lambda
(let ((commit "a43a7bb4ef6faa277e6a7440ec9839711c4b9d28")
(revision "0"))
(package
(name "sbcl-positional-lambda")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/positional-lambda")
(commit commit)))
(sha256
(base32 "1l27mw5ciqz7rnjq1lwslgk220i8iqcr39rs8b7hxkp1yqmah5zq"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; fixme
#:asd-files '("positional-lambda.asd")
#:asd-systems '("positional-lambda")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-map-bind))
(home-page "https://www.hexstreamsoft.com/libraries/positional-lambda/")
(synopsis "Macro favouring positional references over naming")
(description
"@code{sbcl-positional-lambda} is a concise, intuitive and flexible
syntax (macro) for trivial lambdas that eschews explicit (and often
contextually-redundant) 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-map-bind
(let ((commit "532d55d93540c632e22b2cd264b5daa5f9d3d900")
(revision "0"))
(package
(name "sbcl-map-bind")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/map-bind")
(commit commit)))
(sha256
(base32 "0hfy65xyqc4zqfncn11pp3hjjkdz7m91cynnv91s3lgcl3kffva0"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; fixme
#:asd-files '("map-bind.asd")
#:asd-systems '("map-bind")))
(native-inputs
(list sbcl-parachute))
(home-page "https://www.hexstreamsoft.com/libraries/map-bind/")
(synopsis "Macro favouring positional references over naming")
(description
"@code{sbcl-map-bind} is a concise, intuitive and flexible
syntax (macro) for trivial lambdas that eschews explicit (and often
contextually-redundant) 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-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-fwoar-lisputils
(let ((commit "ea2e6a55ef097e14b97cb40f155dec19601ff9e9")
(revision "0"))
(package
(name "sbcl-fwoar-lisputils")
(version "0.4.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/fiddlerwoaroof/fwoar.lisputils")
(commit commit)))
(sha256
(base32 "00j6fbq779b8pg5ismaisgf267qlzdwcxww2bsn1114aaqmnjzmr"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/source) ; FIXME
(inputs
(list
sbcl-anaphora
sbcl-alexandria
sbcl-cl-containers
sbcl-closer-mop
sbcl-iterate))
(home-page "https://github.com/fiddlerwoaroof/fwoar.lisputils")
(synopsis "Hodgepodge of useful Lisp snippets")
(description "A hodgepodge of useful Lisp snippets.")
(license license:expat))))
(define-public sbcl-definitions-systems
(let ((commit "03ef8090479f65f96017319a65fb2d7afe031de5")
(revision "0"))
(package
(name "sbcl-definitions-systems")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/definitions-systems")
(commit commit)))
(sha256
(base32 "009392mj0qdq4jy0dw5r41schnygwj286759yvyg7xja30a0psfq"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("definitions-systems.asd")
#:asd-systems '("definitions-systems")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-simple-guess sbcl-canonicalized-initargs))
(home-page "https://www.hexstreamsoft.com/libraries/definitions-systems/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{definitions-systems} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-definitions-systems
(sbcl-package->cl-source-package sbcl-definitions-systems))
(define-public ecl-cl-definitions-systems
(sbcl-package->ecl-package sbcl-definitions-systems))
(define-public sbcl-canonicalized-initargs
(let ((commit "66d51e8f9f4949d5fccc0d99100fb25a80b5b5e1")
(revision "0"))
(package
(name "sbcl-canonicalized-initargs")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/canonicalized-initargs")
(commit commit)))
(sha256
(base32 "17aqzsf5xl30j54s3rgn89d9svfqfhcnp4r4230lphgmyj8hw52j"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("canonicalized-initargs.asd")
#:asd-systems '("canonicalized-initargs")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop sbcl-cesdi
sbcl-enhanced-typep
sbcl-compatible-metaclasses
sbcl-enhanced-defclass))
(home-page "https://www.hexstreamsoft.com/libraries/canonicalized-initargs/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{canonicalized-initargs} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-canonicalized-initargs
(sbcl-package->cl-source-package sbcl-canonicalized-initargs))
(define-public ecl-cl-canonicalized-initargs
(sbcl-package->ecl-package sbcl-canonicalized-initargs))
(define-public sbcl-enhanced-typep
(let ((commit "e6058aedd4f4d2a63a8efc2778ebbe6b8bf7a58e")
(revision "0"))
(package
(name "sbcl-enhanced-typep")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/enhanced-typep")
(commit commit)))
(sha256
(base32 "1cymjjcalm3g16ai03ddp9a319gb24j9h76gpma1qlscjj7v6ady"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("enhanced-typep.asd")
#:asd-systems '("enhanced-typep")))
(native-inputs
(list sbcl-enhanced-boolean sbcl-parachute))
(home-page "https://www.hexstreamsoft.com/libraries/enhanced-typep/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{enhanced-typep} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-enhanced-typep
(sbcl-package->cl-source-package sbcl-enhanced-typep))
(define-public ecl-cl-enhanced-typep
(sbcl-package->ecl-package sbcl-enhanced-typep))
(define-public sbcl-enhanced-defclass
(let ((commit "d62e72209a71a02a9a09baf8cab8b72d864bd638")
(revision "0"))
(package
(name "sbcl-enhanced-defclass")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/enhanced-defclass")
(commit commit)))
(sha256
(base32 "1pgr0zm5283q5ji7j090c6i5gl2wb0kfkjavl01083wk125346k5"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("enhanced-defclass.asd")
#:asd-systems '("enhanced-defclass")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop
sbcl-cesdi
sbcl-simple-guess
sbcl-object-class
sbcl-shared-preferences
sbcl-enhanced-eval-when
sbcl-compatible-metaclasses ))
(home-page "https://www.hexstreamsoft.com/libraries/enhanced-defclass/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{enhanced-defclass} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-enhanced-defclass
(sbcl-package->cl-source-package sbcl-enhanced-defclass))
(define-public ecl-cl-enhanced-defclass
(sbcl-package->ecl-package sbcl-enhanced-defclass))
(define-public sbcl-object-class
(let ((commit "70ad3a6c8f16da347674ddf5d348d2740aec52cf")
(revision "0"))
(package
(name "sbcl-object-class")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/object-class")
(commit commit)))
(sha256
(base32 "0ccyyxxsbpn63sripg4q38mfkaqyzgrpf8l2fgcqwjf0d1pla5p9"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("object-class.asd")
#:asd-systems '("object-class")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop
sbcl-enhanced-find-class
sbcl-compatible-metaclasses))
(home-page "https://www.hexstreamsoft.com/libraries/object-class/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{object-class} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-object-class
(sbcl-package->cl-source-package sbcl-object-class))
(define-public ecl-cl-object-class
(sbcl-package->ecl-package sbcl-object-class))
(define-public sbcl-shared-preferences
(let ((commit "99e51ed3e7b8eeb5fc171195ce06e8569f42eb66")
(revision "0"))
(package
(name "sbcl-shared-preferences")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/shared-preferences")
(commit commit)))
(sha256
(base32 "0gb2ibyy4g5908gycnsq063kvxlwa35mgyc8r36axxmffspsnlhy"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("shared-preferences.asd")
#:asd-systems '("shared-preferences")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-trivial-garbage
sbcl-inheriting-readers))
(home-page "https://www.hexstreamsoft.com/libraries/shared-preferences/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{shared-preferences} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-shared-preferences
(sbcl-package->cl-source-package sbcl-shared-preferences))
(define-public ecl-cl-shared-preferences
(sbcl-package->ecl-package sbcl-shared-preferences))
(define-public sbcl-inheriting-readers
(let ((commit "212fb42eb454d6c3c64699660950e48cbbdbd7fc")
(revision "0"))
(package
(name "sbcl-inheriting-readers")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/inheriting-readers")
(commit commit)))
(sha256
(base32 "0ngn4f4w6phk091w24ndz3nmb546s8098rwmpigws2f2lpf9dayc"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("inheriting-readers.asd")
#:asd-systems '("inheriting-readers")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop
sbcl-compatible-metaclasses
sbcl-class-options))
(home-page "https://www.hexstreamsoft.com/libraries/inheriting-readers/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{inheriting-readers} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-inheriting-readers
(sbcl-package->cl-source-package sbcl-inheriting-readers))
(define-public ecl-cl-inheriting-readers
(sbcl-package->ecl-package sbcl-inheriting-readers))
(define-public sbcl-simple-guess
(let ((commit "34744e3200a96e6aba285d70f91cdbd6c25508a6")
(revision "0"))
(package
(name "sbcl-simple-guess")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/simple-guess")
(commit commit)))
(sha256
(base32 "0404vj7ln97x7rn9ypbw4rshs56nnpyjnh1z9k03s039s5q3kpv0"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("simple-guess.asd")
#:asd-systems '("simple-guess")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop
sbcl-cesdi
sbcl-evaled-when
sbcl-compatible-metaclasses ))
(home-page "https://www.hexstreamsoft.com/libraries/simple-guess/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{simple-guess} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-simple-guess
(sbcl-package->cl-source-package sbcl-simple-guess))
(define-public ecl-cl-simple-guess
(sbcl-package->ecl-package sbcl-simple-guess))
(define-public sbcl-evaled-when
(let ((commit "c59f8ab20b846cac81d4be80d056a3d65676e8eb")
(revision "0"))
(package
(name "sbcl-evaled-when")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/evaled-when")
(commit commit)))
(sha256
(base32 "07g1a50aairvsj57issb18si5a9r3skpbk05nlixmlj0mva3gkl3"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("evaled-when.asd")
#:asd-systems '("evaled-when")))
(native-inputs
(list sbcl-parachute sbcl-enhanced-boolean))
(inputs
(list sbcl-trivial-cltl2))
(home-page "https://www.hexstreamsoft.com/libraries/evaled-when/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{evaled-when} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-evaled-when
(sbcl-package->cl-source-package sbcl-evaled-when))
(define-public ecl-cl-evaled-when
(sbcl-package->ecl-package sbcl-evaled-when))
(define-public sbcl-enhanced-eval-when
(let ((commit "7e858ca9c76239387ea804b96babf94043dbe4e5")
(revision "0"))
(package
(name "sbcl-enhanced-eval-when")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/enhanced-eval-when")
(commit commit)))
(sha256
(base32 "15gczqzfqaxfyz6j54lfhzimpwgc13nfpqhvyi188f7npx5n5qs3"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("enhanced-eval-when.asd")
#:asd-systems '("enhanced-eval-when")))
(native-inputs
(list sbcl-parachute))
(home-page "https://www.hexstreamsoft.com/libraries/enhanced-eval-when/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{enhanced-eval-when} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-enhanced-eval-when
(sbcl-package->cl-source-package sbcl-enhanced-eval-when))
(define-public ecl-cl-enhanced-eval-when
(sbcl-package->ecl-package sbcl-enhanced-eval-when))
(define-public sbcl-enhanced-boolean
(let ((commit "c8f0200955996733bd24810d2ffbe89e27dbf2ff")
(revision "0"))
(package
(name "sbcl-enhanced-boolean")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/enhanced-boolean")
(commit commit)))
(sha256
(base32 "1hn3qiy8s0ixh5cyxjjajdwgydk4grcjsd07ry5xaxa79c7wmq27"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("enhanced-boolean.asd")
#:asd-systems '("enhanced-boolean")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-trivial-cltl2))
(home-page "https://www.hexstreamsoft.com/libraries/enhanced-boolean/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{enhanced-boolean} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-enhanced-boolean
(sbcl-package->cl-source-package sbcl-enhanced-boolean))
(define-public ecl-cl-enhanced-boolean
(sbcl-package->ecl-package sbcl-enhanced-boolean))
(define-public sbcl-cesdi
(let ((commit "3b02ea23b01713747b3afa21a201df722dcb3742")
(revision "0"))
(package
(name "sbcl-cesdi")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/cesdi")
(commit commit)))
(sha256
(base32 "14fnivnllwpj8vv6f283ghmp36wxymz29bs88b58lilxils28p8n"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("cesdi.asd")
#:asd-systems '("cesdi")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop))
(home-page "https://www.hexstreamsoft.com/libraries/cesdi/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{cesdi} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-cesdi
(sbcl-package->cl-source-package sbcl-cesdi))
(define-public ecl-cl-cesdi
(sbcl-package->ecl-package sbcl-cesdi))
(define-public sbcl-compatible-metaclasses
(let ((commit "e80cb32ffc34d050a2949b94e5bf2b1d4c8a2d4d")
(revision "0"))
(package
(name "sbcl-compatible-metaclasses")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/compatible-metaclasses")
(commit commit)))
(sha256
(base32 "0k32p9vrsyh9wpnc0bzkmkjb58hq24d2f3q4y7k99fjn6lgwvdnb"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("compatible-metaclasses.asd")
#:asd-systems '("compatible-metaclasses")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-class-options
sbcl-enhanced-find-class
sbcl-closer-mop))
(home-page "https://www.hexstreamsoft.com/libraries/compatible-metaclasses/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{compatible-metaclasses} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-compatible-metaclasses
(sbcl-package->cl-source-package sbcl-compatible-metaclasses))
(define-public ecl-cl-compatible-metaclasses
(sbcl-package->ecl-package sbcl-compatible-metaclasses))
(define-public sbcl-class-options
(let ((commit "b44eef1eab4911c2b40c79b508bfad54daf7f9ea")
(revision "0"))
(package
(name "sbcl-class-options")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/class-options")
(commit commit)))
(sha256
(base32 "060b4ib2ja6zh723asjpx549wp5im54l1gw2wx1kkpibgvnshx14"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("class-options.asd")
#:asd-systems '("class-options")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-enhanced-find-class sbcl-closer-mop))
(home-page "https://www.hexstreamsoft.com/libraries/class-options/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{class-options} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-class-options
(sbcl-package->cl-source-package sbcl-class-options))
(define-public ecl-cl-class-options
(sbcl-package->ecl-package sbcl-class-options))
(define-public sbcl-enhanced-find-class
(let ((commit "c94f92a8e23b638ac290f079aff922b329afa3b1")
(revision "0"))
(package
(name "sbcl-enhanced-find-class")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Hexstream/enhanced-find-class")
(commit commit)))
(sha256
(base32 "1ph3nq7j9zbj6cwylid1i61klf51kcrhslkg45gv928yqclikp53"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl) ; FIXME
(arguments
`(#:tests? #f ; fixme
#:asd-files '("enhanced-find-class.asd")
#:asd-systems '("enhanced-find-class")))
(native-inputs
(list sbcl-parachute))
(inputs
(list sbcl-closer-mop))
(home-page "https://www.hexstreamsoft.com/libraries/enhanced-find-class/")
(synopsis "Unified extensible way of processing named definitions")
(description
"@code{enhanced-find-class} provides a simple unified extensible way of
processing named definitions.")
(license license:unlicense))))
(define-public cl-enhanced-find-class
(sbcl-package->cl-source-package sbcl-enhanced-find-class))
(define-public ecl-cl-enhanced-find-class
(sbcl-package->ecl-package sbcl-enhanced-find-class))
(define-public sbcl-fare-memoization
(let ((commit "8b43ac6bcc0057d1a92052e39b6d34c05c2eb7e4")
(revision "0"))
(package
(name "sbcl-fare-memoization")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://gitlab.common-lisp.net/frideau/fare-memoization")
(commit commit)))
(sha256
(base32 "1blmrb4c9gsxj87scz74z1s8w9d1w2r48fyxj0y1sw3vr6bsbb8f"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("fare-memoization.asd")
#:asd-systems '("fare-memoization")))
(native-inputs
(list sbcl-hu.dwim.stefil))
(home-page "https://gitlab.common-lisp.net/frideau/fare-memoization")
(synopsis "Memoization library for common-lisp")
(description
"The @code{fare-memoization} library builds on an age-old idea:
dynamically memoizing Lisp functions. A memoized function remembers
results from previous computations, and returns cached results when called
with the same arguments again, rather than re-doing the computation.")
(license license:expat))))
(define-public cl-fare-memoization
(sbcl-package->cl-source-package sbcl-fare-memoization))
(define-public ecl-fare-memoization
(sbcl-package->ecl-package sbcl-fare-memoization))
(define-public sbcl-meta
(let ((commit "74faea662139fbbfb9c99341aaed989f5b0e9da3")
(revision "0"))
(package
(name "sbcl-meta")
(version "0.4.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://gitlab.common-lisp.net/frideau/meta")
(commit commit)))
(sha256
(base32 "08s53zj3mcx82kszp1bg2vsb4kydvkc70kj4hpq9h1l5a1wh44cy"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("meta.asd")))
(inputs
(list sbcl-named-readtables))
(home-page "https://gitlab.common-lisp.net/frideau/meta")
(synopsis "Recursive-descent parser DSL for common-lisp")
(description
"Recursive-descent parser DSL that is a simpler alternative to parser
generators.")
(license license:bsd-3))))
(define-public cl-meta
(sbcl-package->cl-source-package sbcl-meta))
(define-public ecl-meta
(sbcl-package->ecl-package sbcl-meta))
(define-public sbcl-scribble
(let ((commit "4e5369bec6d5e4eed4f99c3dc009fce3e3427cd3")
(revision "0"))
(package
(name "sbcl-scribble")
(version "0.4.2")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://gitlab.common-lisp.net/frideau/scribble")
(commit commit)))
(sha256
(base32 "056qi6vw9bk19s42mapyg55mimhhvhlwgny080v9mhv4fhnqi196"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("scribble.asd")))
(native-inputs
(list sbcl-babel))
(inputs
(list sbcl-fare-utils
;; sbcl-fare-matcher
sbcl-fare-memoization
sbcl-fare-quasiquote
sbcl-meta
sbcl-named-readtables))
(home-page "https://gitlab.common-lisp.net/frideau/scribble")
(synopsis "SCRibe-like reader extension for Common Lisp")
(description "SCRibe-like reader extension for Common Lisp.")
(license license:llgpl))))
(define-public cl-scribble
(sbcl-package->cl-source-package sbcl-scribble))
(define-public ecl-scribble
(sbcl-package->ecl-package sbcl-scribble))
(define-public sbcl-wordnet
(let ((commit "8cd0db8f5e84e7a930fa74e590ecddf75cd8e5d6")
(revision "0"))
(package
(name "sbcl-wordnet")
(version (git-version "20220213" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/phoe/wordnet")
(commit commit)))
(sha256
(base32 "07p60k295fsfcp0gmkqhrxd68hb38aqva8f4k8xk8bqqxxf42vkq"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("wordnet.asd")
#:asd-systems '("wordnet")))
(inputs
(list sbcl-split-sequence))
(home-page "https://github.com/phoe/wordnet")
(synopsis "Common Lisp interface to WordNet")
(description
"This software provides an interface by which Common Lisp programs can
access lexicographic data from WordNet.")
(license license:expat))))
(define-public cl-wordnet
(sbcl-package->cl-source-package sbcl-wordnet))
(define-public ecl-wordnet
(sbcl-package->ecl-package sbcl-wordnet))
(define-public sbcl-cxp
(let ((commit "cdea8984d7dcf7fa075200973482bf9a27341003")
(revision "0"))
(package
(name "sbcl-cxp")
(version (git-version "20220221" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://git.sr.ht/~ilmu/cxp")
(commit commit)))
(sha256
(base32 "1cb0pg2a7j583dymnrlbb8xa2n1pka5p5bh82rpjqm4d30lyalx0"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("cxp.asd")
#:asd-systems '("cxp")))
(inputs
`(("cl-ppcre" ,cl-ppcre)
("cl-str" ,cl-str)
("cl-chanl" ,cl-chanl)
("cl-alexandria" ,cl-alexandria)
("cl-trivia" ,cl-trivia)))
(synopsis "Simple pipeline components built on canonical S-expressions.")
(description
"A modern take on line editors; cxp offers various ways to break a
text file into snippets, rearrange the snippets and then reassemble the
text file. The cxp dsl is based on string diagrams and has experimental
datalisp name system features.")
;; Home page is on a Distributed Web Gateway for IPFS provided
;; by Cloudflare.
(home-page "http://datalisp.is")
(license license:bsd-3))))
(define-public cl-cxp
(sbcl-package->cl-source-package sbcl-cxp))
(define-public ecl-cxp
(sbcl-package->ecl-package sbcl-cxp))
(define-public sbcl-string-pokemonize
(let ((commit "2dc01643defb497e4d1eb833def71dfc1e8d5da6")
(revision "0"))
(package
(name "sbcl-string-pokemonize")
(version (git-version "20210503" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/phoe/string-pokemonize")
(commit commit)))
(sha256
(base32 "1zk5klc94pxv7mhx6qrp93rk4ypwd6wfijap7gf9l0wpphg90r9x"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("string-pokemonize.asd")
#:asd-systems '("string-pokemonize")))
(synopsis "Forgive me, Father, for I have sinned")
(description
"@code{string-pokemonize} alternates uppercase and lowercase characters
for a given string.")
(home-page "https://github.com/phoe/string-pokemonize")
(license license:expat))))
(define-public cl-string-pokemonize
(sbcl-package->cl-source-package sbcl-string-pokemonize))
(define-public ecl-string-pokemonize
(sbcl-package->ecl-package sbcl-string-pokemonize))
(define-public sbcl-doplus
(package
(name "sbcl-doplus")
(version "1.1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/alessiostalla/doplus")
(commit (string-append "v" version))))
(sha256
(base32 "1yvda9psw9m08d3bzdb8a2drvhrnr07a0rhza5ibk30v1dkwfw7c"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
(inputs
(list sbcl-parse-declarations sbcl-fset))
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("doplus.asd" "doplus-tests.asd" "doplus-fset.asd")
#:asd-systems '("doplus" "doplus-tests" "doplus-fset")))
(synopsis "Iteration macro for Common Lisp")
(description "@code{doplus} is an iteration macro for Common Lisp.")
(home-page "https://github.com/alessiostalla/doplus")
(license license:expat)))
(define-public cl-doplus
(sbcl-package->cl-source-package sbcl-doplus))
(define-public ecl-doplus
(sbcl-package->ecl-package sbcl-doplus))
(define-public sbcl-cl-morse
(package
(name "sbcl-cl-morse")
(version "0.1.0")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/em7/cl-morse")
(commit (string-append "v" version))))
(sha256
(base32 "0x010s9l305jl0y2cxggim8hjx0hm08c29p67qjqvzdbaiw7gimq"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-rove
sbcl-dissect))
(inputs
(list sbcl-cl-ppcre))
(arguments
`(#:asd-files '("cl-morse.asd")
#:asd-systems '("cl-morse" "cl-morse/tests")))
(synopsis "Morse code translation library written in Common Lisp")
(description
"@code{cl-morse} is a morse code translation library written in Common Lisp.")
(home-page "https://github.com/em7/cl-morse")
(license license:bsd-3)))
(define-public cl-morse
(sbcl-package->cl-source-package sbcl-cl-morse))
(define-public ecl-cl-morse
(sbcl-package->ecl-package sbcl-cl-morse))
(define-public sbcl-variatio
(let ((commit "6991bf3e810c4fd11523550a563645dad1ba333f")
(revision "0"))
(package
(name "sbcl-variatio")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/ntrocado/variatio")
(commit commit)))
(sha256
(base32 "0rvsngm4pk0yvxsaagcckyk2ih0jp7r0jx6cxw64ql02rx3ddp1p"))
(file-name (git-file-name name commit))
(modules '((guix build utils)))
(snippet
'(begin
;; delete debian and roswell files/scripts
(delete-file-recursively "bin")
(delete-file "Aptfile")))))
(build-system asdf-build-system/sbcl)
(inputs
(list lilypond
sbcl-hunchentoot
sbcl-alexandria
sbcl-parenscript
sbcl-cl-ppcre
sbcl-cl-who
sbcl-parse-float))
(arguments
`(#:tests? #f
#:asd-files '("variatio.asd")
#:asd-systems '("variatio")
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'patch-lilypond-executable
(lambda _
(substitute* "variatio.lisp"
(("/app/.apt/usr/bin/lilypond.real") (which "lilypond"))))))))
(synopsis "Generate variations on a musical phrase")
(description
"@code{variatio} is a web app that generates variations from a
given initial musical phrase. A textual mini-language is defined for
the input. The variations are obtained from a series of algorithmic
transformations. The user is then offered a pdf score with the results.")
(home-page "http://variatio.nunotrocado.com/")
(license license:llgpl))))
(define-public cl-variatio
(sbcl-package->cl-source-package sbcl-variatio))
(define-public ecl-variatio
(sbcl-package->ecl-package sbcl-variatio))
(define-public sbcl-mondo
(let ((commit "0c05a7e53ea0b6551dab90a247e9a42ebda8dca7")
(revision "0"))
(package
(name "sbcl-mondo")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/fukamachi/mondo")
(commit commit)))
(sha256
(base32 "1dlza3px0876svs65rifc4hvx1mg1izgb33zkg54yrckvkwjw5z2"))
(file-name (git-file-name name commit))
(modules '((guix build utils)))
(snippet
'(begin
;; delete roswell script
;; how to build an executable?
;; https://github.com/koji-kojiro/cl-repl/issues/19
(delete-file-recursively "roswell")))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-rove
sbcl-cl-interpol))
(inputs
(list sbcl-cl-readline
sbcl-usocket
sbcl-alexandria
sbcl-bordeaux-threads
sbcl-slime-swank
sbcl-babel))
(arguments
`(#:asd-files '("mondo.asd")
#:asd-systems '("mondo" "mondo/command" "mondo/tests")
#:phases
(modify-phases %standard-phases
(add-after 'create-asdf-configuration 'make-cli-executable
(lambda* (#:key outputs #:allow-other-keys)
(build-program
(string-append (assoc-ref outputs "out") "/bin/mondo")
outputs
#:dependencies '("mondo/command")
#:entry-program '("mondo/cli:main")))))))
(synopsis "Common Lisp REPL interface")
(description
"@code{cl-mondo} is a simple Common Lisp REPL, just like the SLIME REPL
that works on the terminal.")
(home-page "https://github.com/fukamachi/mondo/")
(license license:gpl3+))))
(define-public cl-mondo
(sbcl-package->cl-source-package sbcl-mondo))
(define-public ecl-mondo
(sbcl-package->ecl-package sbcl-mondo))
(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))))
(sha256
(base32 "0nd9fdjli22ygfw3c8k9nh7d36c92866hics5aij6x7ly1q781gz"))
(file-name (git-file-name name version))))
(build-system asdf-build-system/sbcl)
(native-inputs
(list sbcl-fiveam))
(arguments
`(#:asd-files '("alea.asd")
#:asd-systems '("alea" "alea/tests")))
(synopsis "Morse code translation library written in Common Lisp")
(description
"@code{alea} is a morse code translation library written in Common Lisp.")
(home-page "https://github.com/eXodiquas/alea")
(license license:expat)))
(define-public cl-alea
(sbcl-package->cl-source-package sbcl-alea))
(define-public ecl-alea
(sbcl-package->ecl-package sbcl-alea))
(define-public sbcl-quicklisp-stats
(let ((commit "953b45c2212ae513d48a611d3dd09c846a6102cd")
(revision "0"))
(package
(name "sbcl-quicklisp-stats")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/phoe/quicklisp-stats")
(commit commit)))
(sha256
(base32 "0v8dgmlgd283n1g486q4sj2mghgdvgywg2nqp43nnrfc04mkvgc0"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(inputs
(list sbcl-drakma
sbcl-split-sequence
sbcl-alexandria))
(arguments
`(#:tests? #f ; no tests
#:asd-files '("quicklisp-stats.asd")
#:asd-systems '("quicklisp-stats")))
(synopsis "Fetches and operates on Quicklisp download statistics")
(description
"@code{cl-quicklisp-stats} is a system that fetches and performs basic
operations on the Quicklisp download statistics.")
(home-page "https://github.com/phoe/quicklisp-stats/")
(license license:expat))))
(define-public cl-quicklisp-stats
(sbcl-package->cl-source-package sbcl-quicklisp-stats))
(define-public ecl-quicklisp-stats
(sbcl-package->ecl-package sbcl-quicklisp-stats))
(define-public sbcl-lacrida
(let ((commit "8ad8cece447e6503a6e689d4e42a835fef07bbc7")
(revision "0"))
(package
(name "sbcl-lacrida")
(version "")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/thrig/lacrida")
(commit commit)))
(sha256
(base32 "0skngjmk4zxhmf06b6zk7c49c9i3kq9gkh7252r9670cd1li9pf1"))
(file-name (git-file-name name commit))
(snippet
'(begin
;; delete quicklisp scripts
(delete-file "compile")
(delete-file "run")))))
(build-system asdf-build-system/sbcl)
(inputs
(list sbcl-cl-charms
sbcl-alexandria))
(arguments
`(#:tests? #f ; no tests
#:asd-files '("lacrida.asd")
#:asd-systems '("lacrida")))
(synopsis "Spring Lisp Game Jam 2020 game")
(description
"@code{cl-lacrida} is a computer fantasy game. The object of the game
is to obtain food scattered throughout the garden of some Wizard, and
to ideally escape unharmed.")
(home-page "https://github.com/thrig/lacrida/")
(license license:isc))))
(define-public cl-lacrida
(sbcl-package->cl-source-package sbcl-lacrida))
(define-public ecl-lacrida
(sbcl-package->ecl-package sbcl-lacrida))
(define-public sbcl-smug
(let ((commit "647a2428df297e1dd183ba7c19574bdb1320ae79")
(revision "0"))
(package
(name "sbcl-smug")
(version (git-version "20211214" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/drewc/smug")
(commit commit)))
(sha256
(base32 "13gzkj9skya2ziwclk041v7sif392ydbvhvikhg2raa3qjcxb3rq"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("smug.asd")
#:asd-systems '("smug")))
(synopsis "Parser combinators for Common Lisp")
(description
"@code{cl-smug} is a library for parsing text, based on monadic parser
combinators. Using a simple technique from the functional programming
camp, @code{cl-smug} makes it simple to create quick extensible recursive
descent parsers without funky syntax or impenetrable macrology.")
(home-page "http://smug.drewc.ca/")
(license license:expat))))
(define-public cl-smug
(sbcl-package->cl-source-package sbcl-smug))
(define-public ecl-smug
(sbcl-package->ecl-package sbcl-smug))
(define-public sbcl-draw-cons-tree
(let ((commit "04334f5885a85cd7127db8dda3f6d6686a0438b1")
(revision "0"))
(package
(name "sbcl-draw-cons-tree")
(version (git-version "20220205" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
;; https://github.com/cbaggers/draw-cons-tree/pull/5
(url "https://github.com/phoe-trash/draw-cons-tree")
(commit commit)))
(sha256
(base32 "1523bdkq8a5qn0qp9q7r16w47y6jb0hkfj7hbjfj6mg3xv001s3x"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("draw-cons-tree.asd")
#:asd-systems '("draw-cons-tree" "draw-cons-tree/test")))
(native-inputs
(list sbcl-split-sequence
sbcl-fiveam))
(inputs
(list sbcl-alexandria))
(synopsis "Draws an ascii picture of a cons tree")
(description
"@code{cl-draw-cons-tree} draws a cons tree in ASCII-art style.")
(home-page "https://github.com/cbaggers/draw-cons-tree/")
(license license:unlicense))))
(define-public cl-draw-cons-tree
(sbcl-package->cl-source-package sbcl-draw-cons-tree))
(define-public ecl-draw-cons-tree
(sbcl-package->ecl-package sbcl-draw-cons-tree))
(define-public sbcl-osc
(let ((commit "e1ac269e257c642032881237af015aae86e698ec")
(revision "0"))
(package
(name "sbcl-osc")
(version (git-version "20220205" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/zzkt/osc")
(commit commit)))
(sha256
(base32 "1808w72d2bbnc7n75aap1lhyai8lp0100h80a2lhjcx6wl0z1lvl"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("osc.asd")
#:asd-systems '("osc")))
(synopsis "Common lisp implementation of the Open Sound Control protocol")
(description
"@code{cl-osc} is a common lisp implementation of the Open Sound Control
Protocol aka OSC. The code should be close to the ansi standard, and
does not rely on any external code/ffi/etc+ to do the basic encoding
and decoding of packets.")
(home-page "https://github.com/zzkt/osc/")
(license license:llgpl))))
(define-public cl-osc
(sbcl-package->cl-source-package sbcl-osc))
(define-public ecl-osc
(sbcl-package->ecl-package sbcl-osc))
(define-public sbcl-cl-collider
(let ((commit "fbf85e933bc688d0388309a964ca515008fb1805")
(revision "0"))
(package
(name "sbcl-cl-collider")
(version (git-version "2018.7.15" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/byulparan/cl-collider")
(commit commit)))
(sha256
(base32 "0czq8r6v5sm6pb3kk33ajv7hhk3z9agykwgl93s2xdlgl3x1h3rv"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("cl-collider.asd" "osc/sc-osc.asd")
#:asd-systems '("cl-collider" "sc-osc")
#:phases
(modify-phases %standard-phases
(add-after 'unpack 'patch-supercollider-executable
(lambda _
(substitute* "server.lisp"
(("which scsynth") (which "scsynth"))
(("jack_connect") (which "jack_connect"))))))))
(inputs
(list supercollider
jack-2
sbcl-osc
sbcl-alexandria
sbcl-cffi
sbcl-bordeaux-threads
sbcl-pileup
sbcl-flexi-streams
sbcl-split-sequence
sbcl-named-readtables
sbcl-simple-inferiors
sbcl-cl-ppcre
sbcl-ieee-floats ; sc-osc dependencies
sbcl-usocket))
(synopsis "SuperCollider client for CommonLisp")
(description
"@code{cl-cl-collider} is a @code{supercollider} client for CommonLisp.")
(home-page "https://github.com/byulparan/cl-collider/")
(license license:public-domain))))
(define-public cl-collider
(sbcl-package->cl-source-package sbcl-cl-collider))
(define-public ecl-cl-collider
(sbcl-package->ecl-package sbcl-cl-collider))
(define-public sbcl-cl-gendoc
(let ((commit "c8fed7dd008a0cc34138521e45116e063aea33bd")
(revision "0"))
(package
(name "sbcl-cl-gendoc")
(version (git-version "1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/chfin/cl-gendoc")
(commit commit)))
(sha256
(base32 "19f8fmz2hj332kh3y3fbil2dchpckdsqci6ljhadymd8p2h6w4ws"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("cl-gendoc.asd")
#:asd-systems '("cl-gendoc" "cl-gendoc-docs")))
(inputs
(list sbcl-cl-who sbcl-3bmd))
(synopsis "Simple component-based documentation generator")
(description
"@code{cl-gendoc} is a simple component-based documentation generator.")
(home-page "https://github.com/chfin/cl-gendoc/")
(license license:expat))))
(define-public cl-gendoc
(sbcl-package->cl-source-package sbcl-cl-gendoc))
(define-public ecl-cl-gendoc
(sbcl-package->ecl-package sbcl-cl-gendoc))
(define-public sbcl-date-time-parser
(let ((commit "00d6fc70b599f460fdf13cf0cf7e6bf843312410")
(revision "0"))
(package
(name "sbcl-date-time-parser")
(version (git-version "1.03" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/chfin/cl-date-time-parser")
(commit commit)))
(sha256
(base32 "0dswpbbb57jm609xxfah25dxxhjzc7qh5lr1a1ffkpms84l0r7m5"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("cl-date-time-parser.asd")
#:asd-systems '("cl-date-time-parser")))
(inputs
(list
sbcl-alexandria
sbcl-split-sequence
sbcl-anaphora
sbcl-cl-ppcre
sbcl-local-time
sbcl-parse-float))
(synopsis "Parse date-time-string, liberally")
(description
"The goal of @code{cl-date-time-parser} is to hide the difference
between date-time formats, and to manage date and time as the
universal time.")
(home-page "https://github.com/chfin/cl-date-time-parser/")
(license license:expat))))
(define-public cl-date-time-parser
(sbcl-package->cl-source-package sbcl-date-time-parser))
(define-public ecl-date-time-parser
(sbcl-package->ecl-package sbcl-date-time-parser))
(define-public sbcl-ratify
(let ((commit "5cb1471ff93b8ab45f343e548666d2effc1efc67")
(revision "0"))
(package
(name "sbcl-ratify")
(version (git-version "0.1.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Shinmera/ratify")
(commit commit)))
(sha256
(base32 "0lhz3g85sc8ral59bs6g32f9nvxvbz126wchr8c3f5jj95xhngma"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("ratify.asd")
#:asd-systems '("ratify")))
(inputs
(list sbcl-cl-ppcre
sbcl-local-time
sbcl-parse-float))
(synopsis "Collection of utilities to ratify, validate and parse inputs")
(description
"@code{cl-ratify} is a collection of utilities to perform
validation checks and parsing. The main intention of usage for this is
in web-applications in order to check form inputs for correctness and
automatically parse them into their proper representations or return
meaningful errors.")
(home-page "https://shinmera.github.io/ratify/")
(license license:zlib))))
(define-public cl-ratify
(sbcl-package->cl-source-package sbcl-ratify))
(define-public ecl-ratify
(sbcl-package->ecl-package sbcl-ratify))
(define-public sbcl-data-lens
(let ((commit "c80aff0f0bc0137e229f5fbc234b08dd1aa97777")
(revision "0"))
(package
(name "sbcl-data-lens")
(version (git-version "20210118" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/fiddlerwoaroof/data-lens")
(commit commit)))
(sha256
(base32 "138vlmi1ixkj60np3jmnb57cz2bn2x2fihm16gryb1r93r6scx56"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:asd-files '("data-lens.asd")
#:asd-systems '("data-lens")))
(native-inputs
(list sbcl-fiveam))
(inputs
(list sbcl-cl-ppcre
sbcl-alexandria
sbcl-serapeum))
(synopsis "Functional utilities for Common Lisp")
(description
"The @code{cl-data-lens} library provides a language for expressing data
manipulations as the composition of more primitive operations.")
(home-page "https://fiddlerwoaroof.github.io/data-lens/")
(license license:asl2.0))))
(define-public cl-data-lens
(sbcl-package->cl-source-package sbcl-data-lens))
(define-public ecl-data-lens
(sbcl-package->ecl-package sbcl-data-lens))
(define-public sbcl-planks
(let ((commit "ac600345ac5f01b1610720a69bfe57953dfb5695")
(revision "0"))
(package
(name "sbcl-planks")
(version (git-version "20110502" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/drewc/planks")
(commit commit)))
(sha256
(base32 "138vlmi1ixkj60np3jmnb57cz2bn2x2fihm16gryb1r93r6scx56"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("planks.asd")
#:asd-systems '("planks")))
(inputs
(list sbcl-rucksack
sbcl-ironclad
sbcl-bordeaux-threads
sbcl-trivial-garbage
sbcl-babel
sbcl-closer-mop))
(synopsis "Functional utilities for Common Lisp")
(description
"The @code{cl-planks} library provides a language for expressing data
manipulations as the composition of more primitive operations.")
(home-page "https://drewc.github.io/planks/")
(license license:expat))))
(define-public cl-planks
(sbcl-package->cl-source-package sbcl-planks))
(define-public ecl-planks
(sbcl-package->ecl-package sbcl-planks))
(define-public sbcl-rucksack
(let ((commit "89278f88513ef328d290aa8b2baa06d63b44a9b1")
(revision "0"))
(package
(name "sbcl-rucksack")
(version (git-version "20110502" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/arieltan/rucksack")
(commit commit)))
(sha256
(base32 "0acpsxaxpp90km7gdbn9sysilycp3yg1g040fg1vqakpj2yb8vad"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`(#:tests? #f ; There are no tests.
#:asd-files '("rucksack.asd" "tests/rucksack-test.asd")
#:test-asd-file "tests/rucksack-test.asd"
#:asd-systems '("rucksack" "rucksack-test")))
(synopsis "Flexible, light weight, persistence library")
(description
"The @code{cl-rucksack} is a persistence library based on Arthur Lemmens's
Rucksack with some enhancements.")
(home-page "https://github.com/arieltan/rucksack/")
(license license:expat))))
(define-public cl-rucksack
(sbcl-package->cl-source-package sbcl-rucksack))
(define-public ecl-rucksack
(sbcl-package->ecl-package sbcl-rucksack))
(define-public sbcl-amb
(let ((commit "884bef69a1ea02f3b9deae0341e1a038ff31b896")
(revision "0"))
(package
(name "sbcl-amb")
(version (git-version "20220117" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/phoe/amb")
(commit commit)))
(sha256
(base32 "1klh1aakklj1famrff0sccnwlv8238b1q446288aqnqgxxw6pf21"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`( #:asd-files '("amb.asd")
#:asd-systems '("amb" "amb/test")))
(inputs
(list sbcl-alexandria))
(native-inputs
(list sbcl-parachute))
(synopsis "Implementation of John McCarthy's ambiguous operator")
(description
"The @code{cl-amb} provides an implementation of John McCarthy's ambiguous
operator in portable Common Lisp.")
(home-page "https://github.com/phoe/amb/")
(license license:expat))))
(define-public cl-amb
(sbcl-package->cl-source-package sbcl-amb))
(define-public ecl-amb
(sbcl-package->ecl-package sbcl-amb))
(define-public sbcl-lass
(let ((commit "a7a4452f6a670b8fb01a73d3007030d16bd1ec2c")
(revision "0"))
(package
(name "sbcl-lass")
(version (git-version "20210902" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Shinmera/LASS")
(commit commit)))
(sha256
(base32 "06wds1qzj8s862pmmza1427n7gdpplqplxqnxyqkrr0hgxdl4xbf"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`( #:asd-files '("lass.asd")
#:asd-systems '("lass")))
(inputs
(list sbcl-trivial-indent
sbcl-trivial-mimes
sbcl-cl-base64))
(synopsis "Lisp Augmented Style Sheets")
(description
"Writing CSS files comes with a lot of repetition and is generally much
too verbose. With lispy syntax, shortcuts, and improvements, LASS aims
to help you out in writing CSS quick and easy. LASS was largely inspired
by SASS.")
(home-page "https://shinmera.github.io/LASS/")
(license license:expat))))
(define-public cl-lass
(sbcl-package->cl-source-package sbcl-lass))
(define-public ecl-lass
(sbcl-package->ecl-package sbcl-lass))
(define-public sbcl-trivial-irc
(let ((commit "7cb6e99e68c5391a31c693fcc65144d74ed4063a")
(revision "0"))
(package
(name "sbcl-trivial-irc")
(version (git-version "20210902" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/tstenhaug/trivial-irc")
(commit commit)))
(sha256
(base32 "0jjgx6ld2gcr0w0g5k62dr0rl6202ydih6ylmypv6m5jmrarcbza"))
(file-name (git-file-name name commit))))
(build-system asdf-build-system/sbcl)
(arguments
`( #:asd-files '("trivial-irc.asd" "trivial-irc-echobot.asd")
#:asd-systems '("trivial-irc" "trivial-irc-echobot")))
(inputs
(list sbcl-cl-ppcre
sbcl-split-sequence
sbcl-usocket))
(synopsis "Trivial IRC client library for Common Lisp")
(description
"@code{cl-trivial-irc} is a an IRC client library with simple facilities
for receiving, handling and sending messages, and without facilities
for CTCP.")
(home-page "https://github.com/tstenhaug/trivial-irc/")
(license license:expat))))
(define-public cl-trivial-irc
(sbcl-package->cl-source-package sbcl-trivial-irc))
(define-public ecl-trivial-irc
(sbcl-package->ecl-package sbcl-trivial-irc))
(define-public sbcl-cron
(let ((commit "092aef5d5666fb43c04258e4043f609670a20456")
(revision "0"))
(package
(name "sbcl-cron")
(version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/ciel-lang/cl-cron")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "0y4li8j2h1nbpldpqm39ld9kgs4a7biy94h49n27l59l7mn1jd0d"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f
#:asd-files '("cl-cron.asd")
#:asd-systems '("cl-cron" ))) ; There are no tests.
(inputs
(list sbcl-bordeaux-threads))
(home-page "https://github.com/ciel-lang/cl-cron")
(synopsis
"Simple tool that provides cron like facilities directly inside of
common lisp.")
(description
"@code{cl-cron} is simple tool that provides cron like facilities directly
inside of common lisp.")
(license license:gpl3+))))
(define-public cl-cron
(sbcl-package->cl-source-package sbcl-cron))
(define-public ecl-cron
(sbcl-package->ecl-package sbcl-cron))
(define-public sbcl-lisp-stat
(let ((commit "ff57cd5636de240c4b4976d095c9c29c4ea061d1")
(revision "0"))
(package
(name "sbcl-lisp-stat")
(version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Lisp-Stat/lisp-stat")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "0xh9z5qn4308qg681805zg8bxv715z9rix9fpd2r5rm88bzx3dp2"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f ; fixme
#:asd-files '("lisp-stat.asd")
#:asd-systems '("lisp-stat" ))) ; There are no tests.
(inputs
(list sbcl-alexandria
sbcl-let-plus
sbcl-array-operations
sbcl-data-frame
sbcl-dfio
sbcl-numerical-utilities
sbcl-select
sbcl-dexador
sbcl-split-sequence))
(native-inputs
(list sbcl-parachute))
(home-page "https://lisp-stat.github.io/lisp-stat")
(synopsis "Statistical computing environment for Common Lisp")
(description
"@code{cl-lisp-stat} provides support for vectorized mathematical
operations, and a comprehensive set of statistical methods that are
implemented using the latest numerical algorithms. In addition,
Common Lisp provides a dynamic programming environment, an excellent
object-oriented facility and meta-object protocol.")
(license license:gpl3+))))
(define-public cl-lisp-stat
(sbcl-package->cl-source-package sbcl-lisp-stat))
(define-public ecl-lisp-stat
(sbcl-package->ecl-package sbcl-lisp-stat))
(define-public sbcl-data-frame
(let ((commit "e094a181d08163244a77fac7750ffa0385e9d798")
(revision "0"))
(package
(name "sbcl-data-frame")
(version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Lisp-Stat/data-frame")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "1rq51dbhjzjm1vicjq7sps21i0wvl27m0x17qykx8qjnmg7np0va"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f
#:asd-files '("data-frame.asd")
#:asd-systems '("data-frame" ))) ; There are no tests.
(inputs
(list sbcl-alexandria
sbcl-serapeum ; https://github.com/Lisp-Stat/data-frame/pull/12
sbcl-anaphora
sbcl-let-plus
sbcl-alexandria-plus
sbcl-array-operations
sbcl-numerical-utilities
sbcl-select))
(native-inputs
(list sbcl-clunit2))
(home-page "https://data-frame.github.io/data-frame")
(synopsis "Data frames for Common Lisp")
(description
"@code{cl-data-frame} is a data manipulation package, conceptually
similar to R's data.frame.")
(license license:ms-pl))))
(define-public cl-data-frame
(sbcl-package->cl-source-package sbcl-data-frame))
(define-public ecl-data-frame
(sbcl-package->ecl-package sbcl-data-frame))
(define-public sbcl-select
(let ((commit "49bf60ef2d6bfb6b425a9246794ff6037ddd4e5f")
(revision "0"))
(package
(name "sbcl-select")
(version (git-version "0.3.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 name version))
(sha256
(base32 "1kplgpn79av1p2icyk7h93cy00gshyan96vxlinvwxibhsrhxsj2"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:asd-files '("select.asd")
#:asd-systems '("select" ))) ; There are no tests.
(inputs
(list sbcl-alexandria
sbcl-anaphora
sbcl-let-plus))
(native-inputs
(list sbcl-fiveam))
(home-page "https://select.github.io/select")
(synopsis "Data frames for Common Lisp")
(description
"@code{cl-select} is a data manipulation package, conceptually
similar to R's data.frame.")
(license license:ms-pl))))
(define-public cl-select
(sbcl-package->cl-source-package sbcl-select))
(define-public ecl-select
(sbcl-package->ecl-package sbcl-select))
(define-public sbcl-dfio
(let ((commit "f7984b792bf4d9010083db08472bc84d2d31430c")
(revision "0"))
(package
(name "sbcl-dfio")
(version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Lisp-Stat/dfio")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "1wka8y4526x8yy3asiy15jxdzhsmyiq6ra6wbi8a4vcry3g2v9a0"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:asd-files '("dfio.asd")
#:asd-systems '("dfio" "dfio/json" "dfio/tests"))) ; There are no tests.
;; dfio/json
(inputs
(list sbcl-alexandria
sbcl-anaphora
sbcl-data-frame
sbcl-yason
sbcl-dexador
sbcl-fare-csv ; not packaged
sbcl-let-plus))
(native-inputs
(list sbcl-clunit2))
(home-page "https://dfio.github.io/dfio")
(synopsis "Read data to and from data frames")
(description
"Data frames are not of much use if you have to type all the data in by
hand. This system provides I/O functions to read data sets from delimited
(CSV, TSV, etc.) files. File may be either on local disk or accessible
from network locations frame.")
(license license:ms-pl))))
(define-public cl-dfio
(sbcl-package->cl-source-package sbcl-dfio))
(define-public ecl-dfio
(sbcl-package->ecl-package sbcl-dfio))
(define-public sbcl-fare-csv
(let ((commit "39fcada5db2899af172454899ff13a07c62ebdb9")
(revision "0"))
(package
(name "sbcl-fare-csv")
(version (git-version "20151210" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/fare/fare-csv")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "09iq4mfvqlgfcj8gazdwr8y03jrh10aa2y847sz46wdnr2bkys00"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f ; fixme
#:asd-files '("fare-csv.asd")
#:asd-systems '("fare-csv")))
(home-page "https://fare-csv.github.io/fare-csv")
(synopsis "Read data to and from data frames")
(description
"allows you to read and write CSV files, according to any of the
prevailing standards and their popular variants.")
(license license:ms-pl))))
(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-alexandria-plus
(let ((commit "f886514c44332e912e200807605c3b333a222729")
(revision "0"))
(package
(name "sbcl-alexandria-plus")
(version (git-version "20211227" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Symbolics/alexandria-plus")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "0qi20xc20mjxbyqcrgvc71qp7222xd9gbl5k9cfnh68d901q5c9m"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:asd-files '("alexandria+.asd")
#:asd-systems '("alexandria+" "alexandria+/tests")))
(inputs
(list sbcl-alexandria))
(native-inputs
(list sbcl-parachute))
(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
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-numerical-utilities
(let ((commit "e50b2f1b0b7fc0620a6157e2aae2626f07270fbb")
(revision "0"))
(package
(name "sbcl-numerical-utilities")
(version (git-version "0.3.0" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/Lisp-Stat/numerical-utilities")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "0csm9z6gady6810aw0mmifj6y3zkyi0khsd0hdmk66qdgdm4rb37"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #t
#:asd-files '("num-utils.asd")
#:asd-systems '("num-utils" "num-utils/tests")))
(inputs
(list sbcl-alexandria
sbcl-anaphora
sbcl-let-plus
sbcl-array-operations))
(native-inputs
(list sbcl-fiveam
sbcl-select))
(home-page "https://lisp-stat.github.io/numerical-utilities")
(synopsis "Utilities for numerical programming")
(description
"@code{cl-numerical-utilities} is a collection of packages useful in numerical
applications, each big enough to be its own package, but too small to
split out into a separate ASDF system.")
(license license:ms-pl))))
(define-public cl-numerical-utilities
(sbcl-package->cl-source-package sbcl-numerical-utilities))
(define-public ecl-numerical-utilities
(sbcl-package->ecl-package sbcl-numerical-utilities))
(define-public sbcl-yason
(package
(name "sbcl-yason")
(version "0.7.8")
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/phmarek/yason")
(commit (string-append "v" version))))
(file-name (git-file-name name version))
(sha256
(base32
"0zxs80m97pb9wbjqi1g1rsrk8cm2rncxnmw4rmczdkhz1ni9sgdl"))))
(build-system asdf-build-system/sbcl)
(inputs
(list sbcl-alexandria sbcl-trivial-gray-streams))
(synopsis "Common Lisp JSON parser/encoder")
(description
"YASON is a Common Lisp library for encoding and decoding data in the
JSON interchange format.")
(home-page "https://github.com/phmarek/yason")
(license license:bsd-3)))
(define-public cl-yason
(sbcl-package->cl-source-package sbcl-yason))
(define-public ecl-yason
(sbcl-package->ecl-package sbcl-yason))
(define-public sbcl-wild-package-inferred-system
(let ((commit "800b5f89b61cc4a0a9cf14706fd3f7e7fcd3e539")
(revision "0"))
(package
(name "sbcl-wild-package-inferred-system")
(version (git-version "20210520" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/privet-kitty/wild-package-inferred-system")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "0sp3j3i83aqyq9bl3djs490nilryi9sh1wjbcqd9z94d9wfbfz80"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:asd-files '("wild-package-inferred-system.asd")
#:asd-systems '("wild-package-inferred-system"
"wild-package-inferred-system/test")))
(native-inputs
(list sbcl-fiveam))
(home-page "https://github.com/privet-kitty/wild-package-inferred-system/")
(synopsis "Introduces wildcard into ASDF package-inferred-system")
(description
"@code{cl-wild-package-inferred-system} is an extension of ASDF
package-inferred-system that interprets star * and globstar ** in package
(or system) names.")
(license license:expat))))
(define-public cl-wild-package-inferred-system
(sbcl-package->cl-source-package sbcl-wild-package-inferred-system))
(define-public ecl-wild-package-inferred-system
(sbcl-package->ecl-package sbcl-wild-package-inferred-system))
(define-public sbcl-azure
(let ((commit "03b097256d85ea09f090987c0c833c61eb7b9b5d")
(revision "0"))
(package
(name "sbcl-azure")
(version (git-version "0.2.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://github.com/RobBlackwell/cl-azure")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "19sgzbvgs1f1h3qhx11xhpia2x3n8x729h9fsqkc7fap0ak1h31d"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f ; There are no tests.
#:asd-files '("cl-azure.asd")
#:asd-systems '("cl-azure")))
(inputs
(list sbcl-drakma
sbcl-ironclad
sbcl-cxml
sbcl-cl-base64
sbcl-babel
sbcl-cl-ppcre
sbcl-puri
sbcl-cl-json
sbcl-rt))
(home-page "https://github.com/RobBlackwell/cl-azure/")
(synopsis "Windows Azure cloud services library for Common Lisp")
(description
"@code{cl-azure} provides a library to access Microsoft Windows Azure
cloud services from Common Lisp.")
(license license:expat))))
(define-public cl-azure
(sbcl-package->cl-source-package sbcl-azure))
(define-public ecl-azure
(sbcl-package->ecl-package sbcl-azure))
(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 name version))
(sha256
(base32 "0s9nn8ml1j4839rycvdjcbsynkqnhxw1zmrgpjz48smscwdf1f8p"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f))
(native-inputs
(list sbcl-prove))
(inputs
(list sbcl-cl-syntax sbcl-myway sbcl-lack sbcl-alexandria
sbcl-babel))
(home-page "https://8arrow.org/ningle/")
(synopsis "Super micro framework for Common Lisp")
(description
"Ningle is a lightweight web application framework for Common Lisp.")
(license license:llgpl))))
(define-public 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 name version))
(sha256
(base32 "1h0csxk4db1hid793mk5kz3nbjyl7z4ic1zk2wy46k1vz5lnnsph"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f ; There are no tests.
#:asd-files '("cl-ipfs-api2.asd")
#:asd-systems '("cl-ipfs-api2")))
(inputs
(list sbcl-drakma
sbcl-yason
sbcl-arnesi))
(home-page "https://github.com/JadedCtrl/cl-ipfs-api2/")
(synopsis "Bindings for the IPFS HTTP API")
(description
"@code{cl-sbcl-cl-ipfs-api2} is a pretty simple set of IPFS bindings for
Common Lisp, using the HTTP API for (almost) everything, except for pubsub
(which uses the locally installed go-ipfs program).")
(license license:lgpl3+))))
(define-public cl-ipfs-api2
(sbcl-package->cl-source-package sbcl-cl-ipfs-api2))
(define-public ecl-cl-ipfs-api2
(sbcl-package->ecl-package sbcl-cl-ipfs-api2))
(define-public sbcl-clm
(package
(name "sbcl-clm")
(version "5")
(source
(origin
(method url-fetch)
(uri "https://ccrma.stanford.edu/software/clm/clm-5.tar.gz")
(sha256
(base32 "1ckgl7rsnxppnf47jqayrbyhm3hv6c4f7n2994ylva6wiy5w7wp8"))))
(build-system asdf-build-system/sbcl)
(native-inputs
`(("gcc" ,gcc)))
(inputs
`(("alsa-lib" ,alsa-lib)))
(arguments
`(#:phases
(modify-phases %standard-phases
(add-after 'unpack 'fix-build
(lambda _
(substitute* "configure"
(("/bin/sh")
(which "bash")))
(substitute* '("all.lisp"
"index.cl"
"initmus.lisp")
(("/bin/csh")
(which "bash")))
(substitute* "all.lisp"
(("#\\sbcl \\(shadowing-import 'clm:double\\)" all)
(string-append all
" #sbcl (shadowing-import 'clm:env)"))))))))
(home-page "https://ccrma.stanford.edu/software/clm/")
(synopsis "Music synthesis and signal processing package")
(description
"Common Lisp Music is a music synthesis and signal processing package
in the Music V family.")
(license license:expat)))
(define-public cl-clm
(sbcl-package->cl-source-package sbcl-clm))
(define-public sbcl-clones
(let ((commit "a2f7d84ad6a12c0a33b50a453a377a1fb9e3afac")
(revision "0"))
(package
(name "sbcl-clones")
(version (git-version "0.1" revision commit))
(source
(origin
(method git-fetch)
(uri (git-reference
(url "https://git.sr.ht/~kingcons/clones")
(commit commit)))
(file-name (git-file-name name version))
(sha256
(base32 "1i0wg6da6svvy0mm8jxgiw6zfs4canmv1bv5dqrbz8l61b3brzgs"))))
(build-system asdf-build-system/sbcl)
(arguments
'(#:tests? #f ; Tests are currently failing at this commit.
#:asd-files '("clones.asd" "clones-test.asd")
#:asd-systems '("clones" "clones-test")))
(native-inputs
(list sbcl-split-sequence
sbcl-prove))
(inputs
(list sbcl-alexandria))
(home-page "https://git.sr.ht/~kingcons/clones")
(synopsis "Common Lisp NES Emulator")
(description "@code{sbcl-clones} is a Common Lisp NES Emulator.")
(license license:llgpl))))
(define-public cl-clones
(sbcl-package->cl-source-package sbcl-clones))
(define-public ecl-clones
(sbcl-package->ecl-package sbcl-clones))