gnu/packages/guile-xyz.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020 Ludovic Courtès <ludo@gnu.org>
   3 ;;; Copyright © 2014, 2015, 2018 Mark H Weaver <mhw@netris.org>
   4 ;;; Copyright © 2015, 2017 Christopher Allan Webber <cwebber@dustycloud.org>
   5 ;;; Copyright © 2016 Alex Sassmannshausen <alex@pompo.co>
   6 ;;; Copyright © 2016, 2017, 2018, 2019, 2020 Ricardo Wurmus <rekado@elephly.net>
   7 ;;; Copyright © 2016 Erik Edrosa <erik.edrosa@gmail.com>
   8 ;;; Copyright © 2016, 2019, 2020 Eraim Flashner <efraim@flashner.co.il>
   9 ;;; Copyright © 2016, 2017 Alex Kost <alezost@gmail.com>
  10 ;;; Copyright © 2016, 2017 Adonay "adfeno" Felipe Nogueira <https://libreplanet.org/wiki/User:Adfeno> <adfeno@openmailbox.org>
  11 ;;; Copyright © 2016 Amirouche <amirouche@hypermove.net>
  12 ;;; Copyright © 2016, 2019 Jan Nieuwenhuizen <janneke@gnu.org>
  13 ;;; Copyright © 2017 Andy Wingo <wingo@igalia.com>
  14 ;;; Copyright © 2017 David Thompson <davet@gnu.org>
  15 ;;; Copyright © 2017, 2018, 2019, 2020 Mathieu Othacehe <m.othacehe@gmail.com>
  16 ;;; Copyright © 2017 Theodoros Foradis <theodoros@foradis.org>
  17 ;;; Copyright © 2017 Nikita <nikita@n0.is>
  18 ;;; Copyright © 2017, 2018 Tobias Geerinckx-Rice <me@tobias.gr>
  19 ;;; Copyright © 2018 Maxim Cournoyer <maxim.cournoyer@gmail.com>
  20 ;;; Copyright © 2018, 2019, 2020 Arun Isaac <arunisaac@systemreboot.net>
  21 ;;; Copyright © 2018 Pierre-Antoine Rouby <pierre-antoine.rouby@inria.fr>
  22 ;;; Copyright © 2018 Eric Bavier <bavier@member.fsf.org>
  23 ;;; Copyright © 2019 swedebugia <swedebugia@riseup.net>
  24 ;;; Copyright © 2019, 2020 Amar Singh <nly@disroot.org>
  25 ;;; Copyright © 2019 Timothy Sample <samplet@ngyro.com>
  26 ;;; Copyright © 2019, 2020 Martin Becze <mjbecze@riseup.net>
  27 ;;; Copyright © 2020 Evan Straw <evan.straw99@gmail.com>
  28 ;;; Copyright © 2020 Jack Hill <jackhill@jackhill.us>
  29 ;;; Copyright © 2020 Julien Lepiler <julien@lepiller.eu>
  30 ;;; Copyright © 2020 Marius Bakke <marius@gnu.org>
  31 ;;; Copyright © 2020 Masaya Tojo <masaya@tojo.tokyo>
  32 ;;; Copyright © 2020 Jesse Gibbons <jgibbons2357@gmail.com>
  33 ;;; Copyright © 2020 Mike Rosset <mike.rosset@gmail.com>
  34 ;;;
  35 ;;; This file is part of GNU Guix.
  36 ;;;
  37 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  38 ;;; under the terms of the GNU General Public License as published by
  39 ;;; the Free Software Foundation; either version 3 of the License, or (at
  40 ;;; your option) any later version.
  41 ;;;
  42 ;;; GNU Guix is distributed in the hope that it will be useful, but
  43 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  44 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  45 ;;; GNU General Public License for more details.
  46 ;;;
  47 ;;; You should have received a copy of the GNU General Public License
  48 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  49
  50 (define-module (gnu packages guile-xyz)
  51   #:use-module ((guix licenses) #:prefix license:)
  52   #:use-module (gnu packages)
  53   #:use-module (gnu packages algebra)
  54   #:use-module (gnu packages aspell)
  55   #:use-module (gnu packages autotools)
  56   #:use-module (gnu packages base)
  57   #:use-module (gnu packages bash)
  58   #:use-module (gnu packages compression)
  59   #:use-module (gnu packages databases)
  60   #:use-module (gnu packages disk)
  61   #:use-module (gnu packages emacs)
  62   #:use-module (gnu packages emacs-xyz)
  63   #:use-module (gnu packages gawk)
  64   #:use-module (gnu packages gettext)
  65   #:use-module (gnu packages gl)
  66   #:use-module (gnu packages glib)
  67   #:use-module (gnu packages gnome)
  68   #:use-module (gnu packages gnupg)
  69   #:use-module (gnu packages gperf)
  70   #:use-module (gnu packages gstreamer)
  71   #:use-module (gnu packages gtk)
  72   #:use-module (gnu packages guile)
  73   #:use-module (gnu packages hurd)
  74   #:use-module (gnu packages image)
  75   #:use-module (gnu packages imagemagick)
  76   #:use-module (gnu packages libffi)
  77   #:use-module (gnu packages libunistring)
  78   #:use-module (gnu packages linux)
  79   #:use-module (gnu packages man)
  80   #:use-module (gnu packages maths)
  81   #:use-module (gnu packages multiprecision)
  82   #:use-module (gnu packages ncurses)
  83   #:use-module (gnu packages networking)
  84   #:use-module (gnu packages noweb)
  85   #:use-module (gnu packages nss)
  86   #:use-module (gnu packages password-utils)
  87   #:use-module (gnu packages perl)
  88   #:use-module (gnu packages pkg-config)
  89   #:use-module (gnu packages python)
  90   #:use-module (gnu packages readline)
  91   #:use-module (gnu packages sdl)
  92   #:use-module (gnu packages search)
  93   #:use-module (gnu packages slang)
  94   #:use-module (gnu packages sqlite)
  95   #:use-module (gnu packages swig)
  96   #:use-module (gnu packages tex)
  97   #:use-module (gnu packages texinfo)
  98   #:use-module (gnu packages tls)
  99   #:use-module (gnu packages version-control)
 100   #:use-module (gnu packages webkit)
 101   #:use-module (gnu packages xdisorg)
 102   #:use-module (gnu packages xorg)
 103   #:use-module (guix packages)
 104   #:use-module (guix download)
 105   #:use-module (guix git-download)
 106   #:use-module (guix hg-download)
 107   #:use-module (guix build-system gnu)
 108   #:use-module (guix build-system guile)
 109   #:use-module (guix utils)
 110   #:use-module (ice-9 match)
 111   #:use-module ((srfi srfi-1) #:select (alist-delete)))
 112
 113 (define-public artanis
 114   (package
 115     (name "artanis")
 116     (version "0.4.1")
 117     (source (origin
 118               (method url-fetch)
 119               (uri (string-append "mirror://gnu/artanis/artanis-"
 120                                   version ".tar.gz"))
 121               (sha256
 122                (base32
 123                 "0nnmdfx5xwcc3kck64var7msz7g3qk817d7bv9l159nkmic0v9w4"))
 124               (modules '((guix build utils)))
 125               (snippet
 126                '(begin
 127                   ;; Unbundle guile-redis and guile-json
 128                   (delete-file-recursively "artanis/third-party/json.scm")
 129                   (delete-file-recursively "artanis/third-party/json")
 130                   (delete-file-recursively "artanis/third-party/redis.scm")
 131                   (delete-file-recursively "artanis/third-party/redis")
 132                   (substitute* '("artanis/artanis.scm"
 133                                  "artanis/lpc.scm"
 134                                  "artanis/oht.scm")
 135                     (("(#:use-module \\()artanis third-party (json\\))" _
 136                       use-module json)
 137                      (string-append use-module json)))
 138                   (substitute* '("artanis/lpc.scm"
 139                                  "artanis/session.scm")
 140                     (("(#:use-module \\()artanis third-party (redis\\))" _
 141                       use-module redis)
 142                      (string-append use-module redis)))
 143                   (substitute* "artanis/oht.scm"
 144                     (("([[:punct:][:space:]]+)(->json-string)([[:punct:][:space:]]+)"
 145                       _ pre json-string post)
 146                      (string-append pre
 147                                     "scm" json-string
 148                                     post)))
 149                   (substitute* "artanis/artanis.scm"
 150                     (("[[:punct:][:space:]]+->json-string[[:punct:][:space:]]+")
 151                      ""))
 152                   #t))))
 153     (build-system gnu-build-system)
 154     (inputs
 155      `(("guile" ,guile-2.2)
 156        ("nss" ,nss)))
 157     ;; FIXME the bundled csv contains one more exported procedure
 158     ;; (sxml->csv-string) than guile-csv. The author is maintainer of both
 159     ;; projects.
 160     ;; TODO: Add guile-dbi and guile-dbd optional dependencies.
 161     (propagated-inputs
 162      `(("guile-json" ,guile-json-1) ; This ia already using guile-2.2.
 163        ("guile-readline" ,guile2.2-readline)
 164        ("guile-redis" ,guile2.2-redis)))
 165     (native-inputs
 166      `(("bash"       ,bash)         ;for the `source' builtin
 167        ("pkgconfig"  ,pkg-config)
 168        ("util-linux" ,util-linux))) ;for the `script' command
 169     (arguments
 170      '(#:make-flags
 171        ;; TODO: The documentation must be built with the `docs' target.
 172        (let* ((out (assoc-ref %outputs "out"))
 173               (scm (string-append out "/share/guile/site/2.2"))
 174               (go  (string-append out "/lib/guile/2.2/site-ccache")))
 175          ;; Don't use (%site-dir) for site paths.
 176          (list (string-append "MOD_PATH=" scm)
 177                (string-append "MOD_COMPILED_PATH=" go)))
 178        #:test-target "test"
 179        #:phases
 180        (modify-phases %standard-phases
 181          (add-after 'unpack 'patch-site-dir
 182            (lambda* (#:key outputs #:allow-other-keys)
 183              (substitute* "artanis/commands/help.scm"
 184                (("\\(%site-dir\\)")
 185                 (string-append "\""
 186                                (assoc-ref outputs "out")
 187                                "/share/guile/site/2.2\"")))))
 188          (add-after 'unpack 'patch-reference-to-libnss
 189            (lambda* (#:key inputs #:allow-other-keys)
 190              (substitute* "artanis/security/nss.scm"
 191                (("ffi-binding \"libnss3\"")
 192                 (string-append
 193                  "ffi-binding \""
 194                  (assoc-ref inputs "nss") "/lib/nss/libnss3.so"
 195                  "\"")))
 196              #t))
 197          (add-before 'install 'substitute-root-dir
 198            (lambda* (#:key outputs #:allow-other-keys)
 199              (let ((out  (assoc-ref outputs "out")))
 200                (substitute* "Makefile"   ;ignore the execution of bash.bashrc
 201                  ((" /etc/bash.bashrc") " /dev/null"))
 202                (substitute* "Makefile"   ;set the root of config files to OUT
 203                  ((" /etc") (string-append " " out "/etc")))
 204                (mkdir-p (string-append out "/bin")) ;for the `art' executable
 205                #t)))
 206          (add-after 'install 'wrap-art
 207            (lambda* (#:key inputs outputs #:allow-other-keys)
 208              (let* ((out (assoc-ref outputs "out"))
 209                     (bin (string-append out "/bin"))
 210                     (scm (string-append out "/share/guile/site/2.2"))
 211                     (go  (string-append out "/lib/guile/2.2/site-ccache")))
 212                (wrap-program (string-append bin "/art")
 213                  `("GUILE_LOAD_PATH" ":" prefix
 214                    (,scm ,(getenv "GUILE_LOAD_PATH")))
 215                  `("GUILE_LOAD_COMPILED_PATH" ":" prefix
 216                    (,go ,(getenv "GUILE_LOAD_COMPILED_PATH"))))
 217                #t))))))
 218     (synopsis "Web application framework written in Guile")
 219     (description "GNU Artanis is a web application framework written in Guile
 220 Scheme.  A web application framework (WAF) is a software framework that is
 221 designed to support the development of dynamic websites, web applications, web
 222 services and web resources.  The framework aims to alleviate the overhead
 223 associated with common activities performed in web development.  Artanis
 224 provides several tools for web development: database access, templating
 225 frameworks, session management, URL-remapping for RESTful, page caching, and
 226 more.")
 227     (home-page "https://www.gnu.org/software/artanis/")
 228     (license (list license:gpl3+ license:lgpl3+)))) ;dual license
 229
 230 ;; There has not been any release yet.
 231 (define-public guildhall
 232   (let ((commit "2fe2cc539f4b811bbcd69e58738db03eb5a2b778")
 233         (revision "1"))
 234     (package
 235       (name "guildhall")
 236       (version (string-append "0-" revision "." (string-take commit 9)))
 237       (source (origin
 238                 (method git-fetch)
 239                 (uri (git-reference
 240                       (url "https://github.com/ijp/guildhall")
 241                       (commit commit)))
 242                 (file-name (string-append name "-" version "-checkout"))
 243                 (sha256
 244                  (base32
 245                   "115bym7bg66h3gs399yb2vkzc2ygriaqsn4zbrg8f054mgy8wzn1"))))
 246       (build-system gnu-build-system)
 247       (arguments
 248        `(#:phases
 249          (modify-phases %standard-phases
 250            ;; Tests fail without this fix because they try to load the bash
 251            ;; executable as a Scheme file.  See bug report at
 252            ;; https://github.com/ijp/guildhall/issues/22
 253            (add-after 'unpack 'fix-bug-22
 254              (lambda _
 255                (substitute* "Makefile.am"
 256                  (("TESTS_ENVIRONMENT=.*")
 257                   "AM_TESTS_ENVIRONMENT=srcdir=$(abs_top_srcdir)/tests/
 258 TEST_EXTENSIONS = .scm
 259 SCM_LOG_COMPILER= $(top_builddir)/env $(GUILE)
 260 AM_SCM_LOG_FLAGS =  --no-auto-compile -s")
 261                  ;; FIXME: one of the database tests fails for unknown
 262                  ;; reasons.  It does not fail when run outside of Guix.
 263                  (("tests/database.scm") ""))
 264                #t)))))
 265       (inputs
 266        `(("guile" ,guile-2.0)))
 267       (native-inputs
 268        `(("zip" ,zip) ; for tests
 269          ("autoconf" ,autoconf)
 270          ("automake" ,automake)
 271          ("texinfo" ,texinfo)))
 272       (synopsis "Package manager for Guile")
 273       (description
 274        "Guildhall is a package manager written for Guile Scheme.  A guild is
 275 an association of independent craftspeople.  A guildhall is where they meet.
 276 This Guildhall aims to make a virtual space for Guile wizards and journeyfolk
 277 to share code.
 278
 279 On a practical level, Guildhall lets you share Scheme modules and programs
 280 over the internet, and install code that has been shared by others.  Guildhall
 281 can handle dependencies, so when a program requires several libraries, and
 282 each of those has further dependencies, all of the prerequisites for the
 283 program can be installed in one go.")
 284       (home-page "https://github.com/ijp/guildhall")
 285       (license license:gpl3+))))
 286
 287 (define-public guile-aspell
 288   (package
 289     (name "guile-aspell")
 290     (version "0.4")
 291     (source (origin
 292               (method url-fetch)
 293               (uri (string-append
 294                     "http://lonelycactus.com/tarball/guile_aspell-"
 295                     version ".tar.gz"))
 296               (sha256
 297                (base32
 298                 "0vpk5xj9m9qc702z3khmkwhgpb949qbsyz8kw2qycda6qnxk0077"))))
 299     (build-system gnu-build-system)
 300     (arguments
 301      '(#:phases (modify-phases %standard-phases
 302                   (add-before 'configure 'set-guilesitedir
 303                     (lambda _
 304                       (substitute* "Makefile.in"
 305                         (("^guilesitedir =.*$")
 306                          "guilesitedir = \
 307 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 308                       #t))
 309                   (add-before 'build 'set-libaspell-file-name
 310                     (lambda* (#:key inputs #:allow-other-keys)
 311                       (let ((aspell (assoc-ref inputs "aspell")))
 312                         (substitute* "aspell.scm"
 313                           (("\"libaspell\\.so\"")
 314                            (string-append "\"" aspell
 315                                           "/lib/libaspell\"")))
 316                         #t))))))
 317     (native-inputs `(("pkg-config" ,pkg-config)))
 318     (inputs `(("guile" ,guile-2.2)
 319               ("aspell" ,aspell)))
 320     (home-page "https://github.com/spk121/guile-aspell")
 321     (synopsis "Spell-checking from Guile")
 322     (description
 323      "guile-aspell is a Guile Scheme library for comparing a string against a
 324 dictionary and suggesting spelling corrections.")
 325     (license license:gpl3+)))
 326
 327 (define-public guile-bash
 328   ;; This project is currently retired.  It was initially announced here:
 329   ;; <https://lists.gnu.org/archive/html/guile-user/2015-02/msg00003.html>.
 330   (let ((commit "1eabc563ca5692b3e08d84f1f0e6fd2283284469")
 331         (revision "0"))
 332     (package
 333       (name "guile-bash")
 334       (version (string-append "0.1.6-" revision "." (string-take commit 7)))
 335       (home-page
 336        "https://anonscm.debian.org/cgit/users/kaction-guest/retired/dev.guile-bash.git")
 337       (source (origin
 338                 (method git-fetch)
 339                 (uri (git-reference
 340                       (commit commit)
 341                       (url home-page)))
 342                 (sha256
 343                  (base32
 344                   "097vny990wp2qpjij6a5a5gwc6fxzg5wk56inhy18iki5v6pif1p"))
 345                 (file-name (string-append name "-" version "-checkout"))))
 346       (build-system gnu-build-system)
 347       (arguments
 348        '(#:configure-flags
 349          ;; Add -I to match 'bash.pc' of Bash 4.4.
 350          (list (string-append "CPPFLAGS=-I"
 351                               (assoc-ref %build-inputs "bash:include")
 352                               "/include/bash/include")
 353
 354                ;; The '.a' file is useless.
 355                "--disable-static"
 356
 357                ;; Install 'lib/bash' as Bash 4.4 expects.
 358                (string-append "--libdir=" (assoc-ref %outputs "out")
 359                               "/lib/bash"))))
 360       (native-inputs `(("pkg-config" ,pkg-config)
 361                        ("autoconf" ,autoconf-wrapper)
 362                        ("automake" ,automake)
 363                        ("libtool" ,libtool)
 364                        ;; Gettext brings 'AC_LIB_LINKFLAGS_FROM_LIBS'.
 365                        ("gettext" ,gettext-minimal)
 366
 367                        ;; Bash with loadable module support, for the test
 368                        ;; suite.
 369                        ("bash-full" ,bash)))
 370       (inputs `(("guile" ,guile-2.0)
 371                 ("bash:include" ,bash "include")))
 372       (synopsis "Extend Bash using Guile")
 373       (description
 374        "Guile-Bash provides a shared library and set of Guile modules,
 375 allowing you to extend Bash in Scheme.  Scheme interfaces allow you to access
 376 the following aspects of Bash:
 377
 378 @itemize
 379 @item aliases;
 380 @item setting and getting Bash variables;
 381 @item creating dynamic variables;
 382 @item creating Bash functions with a Scheme implementation;
 383 @item reader macro for output capturing;
 384 @item reader macro for evaluating raw Bash commands.
 385 @end itemize
 386
 387 To enable it, run:
 388
 389 @example
 390 enable -f ~/.guix-profile/lib/bash/libguile-bash.so scm
 391 @end example
 392
 393 and then run @command{scm example.scm}.")
 394       (license license:gpl3+))))
 395
 396 (define-public guile-8sync
 397   (package
 398     (name "guile-8sync")
 399     (version "0.4.2")
 400     (source (origin
 401               (method url-fetch)
 402               (uri (string-append "mirror://gnu/8sync/8sync-" version
 403                                   ".tar.gz"))
 404               (sha256
 405                (base32
 406                 "031wm13srak3wsnll7j2mbbi29g1pcm4swdb71ds9yn567pn20qw"))))
 407     (build-system gnu-build-system)
 408     (native-inputs `(("autoconf" ,autoconf)
 409                      ("automake" ,automake)
 410                      ("guile" ,guile-2.2)
 411                      ("pkg-config" ,pkg-config)
 412                      ("texinfo" ,texinfo)))
 413     (arguments
 414      `(#:phases (modify-phases %standard-phases
 415                   (add-before 'configure 'setenv
 416                     (lambda _
 417                       ;; quiet warnings
 418                       (setenv "GUILE_AUTO_COMPILE" "0")
 419                       #t)))))
 420     (home-page "https://gnu.org/s/8sync/")
 421     (synopsis "Asynchronous actor model library for Guile")
 422     (description
 423      "GNU 8sync (pronounced \"eight-sync\") is an asynchronous programming
 424 library for GNU Guile based on the actor model.
 425
 426 Note that 8sync is only available for Guile 2.2.")
 427     (properties '((upstream-name . "8sync")))
 428     (license license:lgpl3+)))
 429
 430 (define-public guile-daemon
 431   (package
 432     (name "guile-daemon")
 433     (version "0.1.3")
 434     (source (origin
 435               (method url-fetch)
 436               (uri (string-append "https://github.com/alezost/" name
 437                                   "/releases/download/v" version
 438                                   "/" name "-" version ".tar.gz"))
 439               (sha256
 440                (base32
 441                 "08gaqrgjlly9k5si72vvpbr4xhq5v52l5ma5y6a7spid5dd057cy"))))
 442     (build-system gnu-build-system)
 443     (native-inputs
 444      `(("pkg-config" ,pkg-config)))
 445     (inputs
 446      `(("guile" ,guile-2.2)))
 447     (home-page "https://github.com/alezost/guile-daemon")
 448     (synopsis "Evaluate code in a running Guile process")
 449     (description
 450      "Guile-Daemon is a small Guile program that loads your initial
 451 configuration file, and then reads and evaluates Guile expressions that
 452 you send to a FIFO file.")
 453     (license license:gpl3+)))
 454
 455 (define-public guile-dsv
 456   (package
 457     (name "guile-dsv")
 458     (version "0.3.0")
 459     (source (origin
 460               (method git-fetch)
 461               (uri (git-reference
 462                     (url "https://github.com/artyom-poptsov/guile-dsv")
 463                     (commit "6c867915dc4198eacc548a4834ef0e1aef852795")))
 464               (file-name (string-append name "-" version "-checkout"))
 465               (sha256
 466                (base32
 467                 "1mxbbcsmbjfnh4yydqz44ihbkdnzdwz38xanaam128arlb7hwr8n"))))
 468     (build-system gnu-build-system)
 469     (native-inputs
 470      `(("autoconf" ,autoconf)
 471        ("automake" ,automake)
 472        ("pkg-config" ,pkg-config)
 473        ("texinfo" ,texinfo)))
 474     (inputs `(("guile" ,guile-3.0)))
 475     (propagated-inputs `(("guile-lib" ,guile-lib)))
 476     (arguments
 477      `(#:modules (((guix build guile-build-system)
 478                    #:select (target-guile-effective-version))
 479                   ,@%gnu-build-system-modules)
 480        #:imported-modules ((guix build guile-build-system)
 481                            ,@%gnu-build-system-modules)
 482        #:phases (modify-phases %standard-phases
 483                   ;; Support Guile 3.0 in configure from upstream commit
 484                   ;; 4c724577ccf19bb88580f72f2f6b166a0447ce3f
 485                   (add-before 'bootstrap 'configure-support-guile3.0
 486                     (lambda _
 487                       (substitute* "configure.ac"
 488                                   (("GUILE_PKG.*")
 489                                    "GUILE_PKG([3.0 2.0 2.2])"))
 490                       #t))
 491                   (add-before 'configure 'set-guilesitedir
 492                     (lambda _
 493                       (substitute* "Makefile.in"
 494                         (("^guilesitedir =.*$")
 495                          "guilesitedir = \
 496 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 497                       (substitute* "modules/Makefile.in"
 498                         (("^guilesitedir =.*$")
 499                          "guilesitedir = \
 500 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 501                       (substitute* "modules/dsv/Makefile.in"
 502                         (("^guilesitedir =.*$")
 503                          "guilesitedir = \
 504 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 505                       #t))
 506                   (add-after 'install 'wrap-program
 507                     (lambda* (#:key inputs outputs #:allow-other-keys)
 508                       (let* ((out (assoc-ref outputs "out"))
 509                              (bin (string-append out "/bin"))
 510                              (guile-lib (assoc-ref inputs "guile-lib"))
 511                              (version (target-guile-effective-version))
 512                              (scm (string-append "/share/guile/site/"
 513                                                  version))
 514                              (go (string-append  "/lib/guile/"
 515                                                  version "/site-ccache")))
 516                         (wrap-program (string-append bin "/dsv")
 517                           `("GUILE_LOAD_PATH" prefix
 518                             (,(string-append out scm)
 519                              ,(string-append guile-lib scm)))
 520                           `("GUILE_LOAD_COMPILED_PATH" prefix
 521                             (,(string-append out go)
 522                              ,(string-append guile-lib go)))))
 523                       #t)))))
 524     (home-page "https://github.com/artyom-poptsov/guile-dsv")
 525     (synopsis "DSV module for Guile")
 526     (description
 527      "Guile-DSV is a GNU Guile module for working with the
 528 delimiter-separated values (DSV) data format.  Guile-DSV supports the
 529 Unix-style DSV format and RFC 4180 format.")
 530     (license license:gpl3+)))
 531
 532 (define-public guile2.2-dsv
 533   (package
 534     (inherit guile-dsv)
 535     (name "guile2.2-dsv")
 536     (inputs `(("guile" ,guile-2.2)))
 537     (propagated-inputs `(("guile-lib" ,guile2.2-lib)))))
 538
 539 (define-public guile-fibers
 540   (package
 541     (name "guile-fibers")
 542     (version "1.0.0")
 543     (source (origin
 544               (method url-fetch)
 545               (uri (string-append "https://wingolog.org/pub/fibers/fibers-"
 546                                   version ".tar.gz"))
 547               (sha256
 548                (base32
 549                 "0vjkg72ghgdgphzbjz9ig8al8271rq8974viknb2r1rg4lz92ld0"))
 550               (modules '((guix build utils)))
 551               (snippet
 552                '(begin
 553                   ;; Allow builds with Guile 3.0.
 554                   (substitute* "configure"
 555                     (("search=\"2\\.2\"")
 556                      "search=\"3.0 2.2\""))
 557
 558                   ;; Explicitly include system headers rather than relying on
 559                   ;; <libguile.h> to do it for us.
 560                   (substitute* "epoll.c"
 561                     (("#include.*libguile\\.h.*$" all)
 562                      (string-append "#include <unistd.h>\n"
 563                                     "#include <string.h>\n"
 564                                     all "\n")))
 565
 566                   ;; Import (ice-9 threads) for 'current-processor-count'.
 567                   (substitute* "tests/channels.scm"
 568                     (("#:use-module \\(fibers\\)")
 569                      (string-append "#:use-module (fibers)\n"
 570                                     "#:use-module (ice-9 threads)\n")))
 571                   #t))
 572               (patches
 573                ;; fixes a resource leak that causes crashes in the tests
 574                (search-patches "guile-fibers-destroy-peer-schedulers.patch"))))
 575     (build-system gnu-build-system)
 576     (arguments
 577      '(;; The code uses 'scm_t_uint64' et al., which are deprecated in 3.0.
 578        #:configure-flags '("CFLAGS=-Wno-error=deprecated-declarations")
 579        #:phases (modify-phases %standard-phases
 580                   (add-after 'install 'mode-guile-objects
 581                     (lambda* (#:key outputs #:allow-other-keys)
 582                       ;; .go files are installed to "lib/guile/X.Y/cache".
 583                       ;; This phase moves them to "…/site-ccache".
 584                       (let* ((out (assoc-ref outputs "out"))
 585                              (lib (string-append out "/lib/guile"))
 586                              (old (car (find-files lib "^ccache$"
 587                                                    #:directories? #t)))
 588                              (new (string-append (dirname old)
 589                                                  "/site-ccache")))
 590                         (rename-file old new)
 591                         #t))))))
 592     (native-inputs
 593      `(("texinfo" ,texinfo)
 594        ("pkg-config" ,pkg-config)))
 595     (inputs
 596      `(("guile" ,guile-3.0)))
 597     (synopsis "Lightweight concurrency facility for Guile")
 598     (description
 599      "Fibers is a Guile library that implements a a lightweight concurrency
 600 facility, inspired by systems like Concurrent ML, Go, and Erlang.  A fiber is
 601 like a \"goroutine\" from the Go language: a lightweight thread-like
 602 abstraction.  Systems built with Fibers can scale up to millions of concurrent
 603 fibers, tens of thousands of concurrent socket connections, and many parallel
 604 cores.  The Fibers library also provides Concurrent ML-like channels for
 605 communication between fibers.
 606
 607 Note that Fibers makes use of some Guile 2.1/2.2-specific features and
 608 is not available for Guile 2.0.")
 609     (home-page "https://github.com/wingo/fibers")
 610     (license license:lgpl3+)))
 611
 612 (define-public guile2.0-fibers
 613   (package
 614     (inherit guile-fibers)
 615     (name "guile2.2-fibers")
 616     (inputs `(("guile" ,guile-2.2)))))
 617
 618 (define-public guile3.0-fibers
 619   (deprecated-package "guile3.0-fibers" guile-fibers))
 620
 621 (define-public guile-syntax-highlight
 622   (package
 623     (name "guile-syntax-highlight")
 624     (version "0.1")
 625     (source (origin
 626               (method url-fetch)
 627               (uri (string-append "https://files.dthompson.us/"
 628                                   "guile-syntax-highlight/"
 629                                   "guile-syntax-highlight-"
 630                                   version ".tar.gz"))
 631               (sha256
 632                (base32
 633                 "1p771kq15x83483m23bhah1sz6vkalg3drm7x279f4j1cxligkzi"))
 634               (modules '((guix build utils)))
 635               (snippet
 636                '(begin
 637                   ;; Allow builds with Guile 3.0.
 638                   (substitute* "configure"
 639                     (("2\\.2 2\\.0")
 640                      "3.0 2.2 2.0"))
 641                   #t))))
 642     (build-system gnu-build-system)
 643     (native-inputs
 644      `(("pkg-config" ,pkg-config)))
 645     (inputs
 646      `(("guile" ,guile-3.0)))
 647     (synopsis "General-purpose syntax highlighter for GNU Guile")
 648     (description "Guile-syntax-highlight is a general-purpose syntax
 649 highlighting library for GNU Guile.  It can parse code written in various
 650 programming languages into a simple s-expression that can be converted to
 651 HTML (via SXML) or any other format for rendering.")
 652     (home-page "https://dthompson.us/projects/guile-syntax-highlight.html")
 653     (license license:lgpl3+)))
 654
 655 (define-public guile2.2-syntax-highlight
 656   (package
 657     (inherit guile-syntax-highlight)
 658     (name "guile2.2-syntax-highlight")
 659     (inputs `(("guile" ,guile-2.2)))))
 660
 661 (define-public guile3.0-syntax-highlight
 662   (deprecated-package "guile3.0-syntax-highlight" guile-syntax-highlight))
 663
 664 (define-public guile-sjson
 665   (package
 666     (name "guile-sjson")
 667     (version "0.2.1")
 668     (source (origin
 669               (method url-fetch)
 670               (uri (string-append "https://dustycloud.org/misc/sjson-" version
 671                                   ".tar.gz"))
 672               (sha256
 673                (base32
 674                 "1mzmapln79vv10qxaggz9qwcdbag3jnrj19xx8bgkmxss8h03sv3"))
 675               (modules '((guix build utils)))
 676               (snippet
 677                '(begin
 678                   ;; Allow builds with Guile 3.0.
 679                   (substitute* "configure"
 680                     (("2\\.2 2\\.0")
 681                      "3.0 2.2 2.0"))
 682                   #t))))
 683     (build-system gnu-build-system)
 684     (native-inputs
 685      `(("autoconf" ,autoconf)
 686        ("automake" ,automake)
 687        ("pkg-config" ,pkg-config)))
 688     (inputs
 689      `(("guile" ,guile-3.0)))
 690     (home-page "https://gitlab.com/dustyweb/guile-sjson")
 691     (synopsis "S-expression based json reader/writer for Guile")
 692     (description "guile-sjson is a json reader/writer for Guile.
 693 It has a nice, simple s-expression based syntax.")
 694     (license license:lgpl3+)))
 695
 696 (define-public guile2.2-sjson
 697   (package
 698     (inherit guile-sjson)
 699     (name "guile2.2-sjson")
 700     (inputs `(("guile" ,guile-2.2)))))
 701
 702 (define-public guile-squee
 703   (let ((commit "a85902a92bf6f58a1d35fd974a01ade163deda8d")
 704         (revision "0"))
 705     (package
 706       (name "guile-squee")
 707       (version (string-append "0-" revision "." (string-take commit 7)))
 708       (source (origin
 709                 (method git-fetch)
 710                 (uri (git-reference
 711                       (url "https://notabug.org/cwebber/guile-squee.git")
 712                       (commit commit)))
 713                 (file-name (git-file-name name version))
 714                 (sha256
 715                  (base32
 716                   "0p1lpsp4kx57j3ai1dkxilm4ziavzzx8wbbc42m3hpziq0a7qz5z"))))
 717       (build-system guile-build-system)
 718       (arguments
 719        '(#:phases
 720          (modify-phases %standard-phases
 721            (add-after 'unpack 'patch
 722              (lambda* (#:key inputs #:allow-other-keys)
 723                (substitute* "squee.scm"
 724                  (("dynamic-link \"libpq\"")
 725                   (string-append
 726                    "dynamic-link \""
 727                    (assoc-ref inputs "postgresql") "/lib/libpq.so"
 728                    "\"")))
 729                #t)))))
 730       (inputs
 731        `(("postgresql" ,postgresql)))
 732       (native-inputs
 733        `(("guile" ,guile-3.0)))
 734       (home-page "https://notabug.org/cwebber/guile-squee")
 735       (synopsis "Connect to PostgreSQL using Guile")
 736       (description
 737        "@code{squee} is a Guile library for connecting to PostgreSQL databases
 738 using Guile's foreign function interface.")
 739       (license license:lgpl3+))))
 740
 741 (define-public guile2.2-squee
 742   (package
 743     (inherit guile-squee)
 744     (name "guile2.2-squee")
 745     (native-inputs `(("guile" ,guile-2.2)
 746                      ,@(alist-delete "guile"
 747                                      (package-native-inputs guile-squee))))))
 748
 749 (define-public guile3.0-squee
 750   (deprecated-package "guile3.0-squee" guile-squee))
 751
 752 (define-public guile-colorized
 753   (package
 754     (name "guile-colorized")
 755     (version "0.1")
 756     (source
 757      (origin
 758        (method git-fetch)
 759        (uri (git-reference
 760              (url "https://gitlab.com/NalaGinrut/guile-colorized.git")
 761              (commit (string-append "v" version))))
 762        (file-name (git-file-name name version))
 763        (sha256
 764         (base32 "10mv8c63159r3qvwwdvsgnsvdg7nc2ghak85zapwqpv4ywrqp9zc"))))
 765     (build-system guile-build-system)
 766     (native-inputs
 767      `(("guile" ,guile-3.0)))
 768     (home-page "https://gitlab.com/NalaGinrut/guile-colorized")
 769     (synopsis "Colorized REPL for Guile")
 770     (description
 771      "Guile-colorized provides you with a colorized REPL for GNU Guile.")
 772     (license license:gpl3+)))
 773
 774 (define-public guile2.2-colorized
 775   (package
 776     (inherit guile-colorized)
 777     (name "guile2.2-colorized")
 778     (native-inputs `(("guile" ,guile-2.2)))))
 779
 780 (define-public guile3.0-colorized
 781   (deprecated-package "guile3.0-colorized" guile-colorized))
 782
 783 (define-public guile-pfds
 784   (package
 785     (name "guile-pfds")
 786     (version "0.3")
 787     (home-page "https://github.com/ijp/pfds")
 788     (source (origin
 789               (method git-fetch)
 790               (uri (git-reference
 791                     (url home-page)
 792                     (commit (string-append "v" version))))
 793               (sha256
 794                (base32
 795                 "19y33wg94pf0n98dkfqd1zbw93fgky4sawxsxl6s3vyqwl0yi5vh"))
 796               (file-name (string-append name "-" version "-checkout"))))
 797     (build-system guile-build-system)
 798     (arguments
 799      '(#:source-directory "src"
 800        #:phases (modify-phases %standard-phases
 801                   (add-after 'unpack 'move-files-around
 802                     (lambda _
 803                       ;; Move files under a pfds/ directory to reflect the
 804                       ;; module hierarchy.
 805                       (mkdir-p "src/pfds")
 806                       (for-each (lambda (file)
 807                                   (rename-file file
 808                                                (string-append "src/pfds/"
 809                                                               file)))
 810                                 '("bbtrees.sls"
 811                                   "deques"
 812                                   "deques.sls"
 813                                   "dlists.sls"
 814                                   "fingertrees.sls"
 815                                   "hamts.sls"
 816                                   "heaps.sls"
 817                                   "private"
 818                                   "psqs.sls"
 819                                   "queues"
 820                                   "queues.sls"
 821                                   "sequences.sls"
 822                                   "sets.sls"))
 823
 824                       ;; In Guile <= 2.2.4, there's no way to tell 'guild
 825                       ;; compile' to accept the ".sls" extension.  So...
 826                       (for-each (lambda (file)
 827                                   (rename-file file
 828                                                (string-append
 829                                                 (string-drop-right file 4)
 830                                                 ".scm")))
 831                                 (find-files "." "\\.sls$"))
 832                       #t)))))
 833     (native-inputs
 834      `(("guile" ,guile-3.0)))
 835     (synopsis "Purely functional data structures for Guile")
 836     (description
 837      "This package provides purely functional data structures written in R6RS
 838 Scheme and compiled for Guile.  It has been tested with Racket, Guile 2,
 839 Vicare Scheme and IronScheme.  Right now it contains:
 840
 841 @itemize
 842 @item queues
 843 @item deques
 844 @item bbtrees
 845 @item sets
 846 @item dlists
 847 @item priority search queues (PSQs)
 848 @item finger trees
 849 @item sequences
 850 @item heaps
 851 @item hash array mapped tries (HAMTs).
 852 @end itemize\n")
 853     (license license:bsd-3)))
 854
 855 (define-public guile2.2-pfds
 856   (package
 857     (inherit guile-pfds)
 858     (name "guile2.2-pfds")
 859     (native-inputs `(("guile" ,guile-2.2)))
 860     (arguments
 861      (substitute-keyword-arguments (package-arguments guile-pfds)
 862        ((#:phases phases)
 863         `(modify-phases ,phases
 864            (delete 'work-around-guile-bug)))))))
 865
 866 (define-public guile3.0-pfds
 867   (deprecated-package "guile3.0-pfds" guile-pfds))
 868
 869 (define-public guile-aa-tree
 870   (package
 871     (name "guile-aa-tree")
 872     (version "3.1.1")
 873     (source (origin
 874               (method url-fetch)
 875               (uri (string-append "mirror://savannah/guile-aa-tree/guile-aa-tree-"
 876                                   version ".tar.gz"))
 877               (sha256
 878                (base32
 879                 "0044c105r3q9vpl17pv3phl1b79kjm1llhkakqgiasixyav01blh"))))
 880     (build-system guile-build-system)
 881     (native-inputs `(("guile" ,guile-2.2)))
 882     ;; https://savannah.nongnu.org/projects/guile-aa-tree
 883     (home-page "https://qlfiles.net/guile-aa-tree/")
 884     (synopsis "AA tree data structure for Guile")
 885     (description
 886      "This package provides an implementation of @dfn{AA trees}, a
 887 self-balancing binary tree data structure, for Guile.  It ensure @math{O(log
 888 n)} worst case performance for core operations.  The module provides
 889 non-mutating insert, delete, and search operations, with support for
 890 convenient nested tree operations.")
 891     (license license:gpl3+)))
 892
 893 (define-public guile-simple-zmq
 894   (let ((commit "68bedb6679716214fb9d3472da57544526f7a618")
 895         (revision "3"))
 896     (package
 897       (name "guile-simple-zmq")
 898       (version (git-version "0.0.0" revision commit))
 899       (source
 900        (origin
 901          (method git-fetch)
 902          (uri (git-reference
 903                (url "https://github.com/jerry40/guile-simple-zmq")
 904                (commit commit)))
 905          (sha256
 906           (base32
 907            "1ad3xg69qqviy1f6dnlw0ysmfdbmp1jq65rfqb8nfd8dsrq2syli"))
 908          (file-name (git-file-name name version))))
 909       (build-system guile-build-system)
 910       (arguments
 911        `(#:source-directory "src"
 912          #:phases (modify-phases %standard-phases
 913                     (add-after 'unpack 'set-libzmq-file-name
 914                       (lambda* (#:key inputs #:allow-other-keys)
 915                         (substitute* "src/simple-zmq.scm"
 916                           (("\\(dynamic-link \"libzmq\"\\)")
 917                            (format #f "(dynamic-link \"~a/lib/libzmq.so\")"
 918                                    (assoc-ref inputs "zeromq"))))
 919                         #t)))))
 920       (native-inputs
 921        `(("guile" ,guile-3.0)))
 922       (inputs
 923        `(("zeromq" ,zeromq)))
 924       (home-page "https://github.com/jerry40/guile-simple-zmq")
 925       (synopsis "Guile wrapper over ZeroMQ library")
 926       (description
 927        "This package provides a Guile programming interface to the ZeroMQ
 928 messaging library.")
 929       (license license:gpl3+))))
 930
 931 (define-public guile2.2-simple-zmq
 932   (package
 933     (inherit guile-simple-zmq)
 934     (name "guile2.2-simple-zmq")
 935     (native-inputs `(("guile" ,guile-2.2)))))
 936
 937 (define-public guile3.0-simple-zmq
 938   (deprecated-package "guile3.0-simple-zmq" guile-simple-zmq))
 939
 940 (define-public jupyter-guile-kernel
 941   (let ((commit "f25fb90b95529b17a006a807bd04e6aee12ea304")
 942         (revision "2"))
 943     (package
 944       (name "jupyter-guile-kernel")
 945       (version (git-version "0.0.0" revision commit))
 946       (source
 947        (origin
 948          (method git-fetch)
 949          (uri (git-reference
 950                (url "https://github.com/jerry40/guile-kernel")
 951                (commit commit)))
 952          (file-name (git-file-name name version))
 953          (sha256
 954           (base32
 955            "0zr1fasdb2yv9kn21yll993y9higqss4jnfs030ndhjb93raa9sr"))))
 956       (build-system guile-build-system)
 957       (arguments
 958        '(#:phases (modify-phases %standard-phases
 959                     (add-after 'unpack 'set-openssl-file-name
 960                       (lambda* (#:key inputs #:allow-other-keys)
 961                         ;; Record the absolute file name of the 'openssl'
 962                         ;; command.
 963                         (substitute* "src/hmac.scm"
 964                           (("openssl")
 965                            (string-append (assoc-ref inputs "openssl")
 966                                           "/bin/openssl")))
 967                         #t))
 968
 969                     ;; XXX: The code uses 'include' to include its own source
 970                     ;; files, and "-L src" isn't enough in this case.
 971                     (add-before 'build 'chdir
 972                       (lambda _ (chdir "src") #t))
 973                     (add-after 'build 'chdir-back
 974                       (lambda _ (chdir "..") #t))
 975
 976                     (add-after 'install 'install-kernel
 977                       (lambda* (#:key inputs outputs #:allow-other-keys)
 978                         (let* ((out   (assoc-ref outputs "out"))
 979                                (json  (assoc-ref inputs "guile-json"))
 980                                (zmq   (assoc-ref inputs "guile-simple-zmq"))
 981                                (deps  (list json zmq))
 982                                (dir   (string-append
 983                                        out "/share/jupyter/kernels/guile"))
 984                                (effective (target-guile-effective-version)))
 985                           ;; Install kernel.
 986                           (install-file "src/kernel.json" dir)
 987
 988                           ;; Fix hard-coded file name in the kernel.
 989                           (substitute* (string-append dir "/kernel.json")
 990                             (("/usr/local/.*/guile-jupyter-kernel.scm")
 991                              (string-append out "/share/guile/site/"
 992                                             (target-guile-effective-version)
 993                                             "/guile-jupyter-kernel.scm"))
 994                             (("\"guile\"")
 995                              (string-append "\"" (assoc-ref inputs "guile")
 996                                             "/bin/guile\""))
 997                             (("-s")
 998                              ;; Add '-L' and '-C' flags so that the kernel
 999                              ;; finds its dependencies.
1000                              (let ((-L (map (lambda (item)
1001                                               (string-append "\"" item
1002                                                              "/share/guile/site/"
1003                                                              effective "\""))
1004                                             deps))
1005                                    (-C (map (lambda (item)
1006                                               (string-append "\"" item
1007                                                              "/lib/guile/"
1008                                                              effective
1009                                                              "/site-ccache\""))
1010                                             deps)))
1011                                (string-append "--no-auto-compile\""
1012                                               (string-join -L ", \"-L\", "
1013                                                            'prefix)
1014                                               (string-join -C ", \"-C\", "
1015                                                            'prefix)
1016                                               ", \"-s"))))
1017                           #t))))))
1018       (inputs
1019        `(("openssl" ,openssl)
1020          ("guile" ,guile-3.0)
1021          ("guile-json" ,guile-json-3)
1022          ("guile-simple-zmq" ,guile-simple-zmq)))
1023       (synopsis "Guile kernel for the Jupyter Notebook")
1024       (description
1025        "This package provides a Guile 2.x kernel for the Jupyter Notebook.  It
1026 allows users to interact with the Guile REPL through Jupyter.")
1027       (home-page "https://github.com/jerry40/guile-kernel")
1028       (license license:gpl3+))))
1029
1030 (define-public guile-sparql
1031   (package
1032    (name "guile-sparql")
1033    (version "0.0.7")
1034    (source (origin
1035             (method url-fetch)
1036             (uri (string-append
1037                   "https://github.com/roelj/guile-sparql/releases/download/"
1038                   version "/guile-sparql-" version ".tar.gz"))
1039             (sha256
1040              (base32 "1drnvhsgl0gc5crmb16yyw1j98nkhwwcgssv9vgm36ng43nnzffd"))))
1041    (build-system gnu-build-system)
1042    (arguments `(#:tests? #f)) ; There are no tests.
1043    (native-inputs
1044     `(("pkg-config" ,pkg-config)))
1045    (inputs
1046     `(("guile" ,guile-2.2)))
1047    (home-page "https://github.com/roelj/guile-sparql")
1048    (synopsis "SPARQL module for Guile")
1049    (description "This package provides the functionality to query a SPARQL
1050 endpoint.  Additionally, it provides an interface to write SPARQL queries
1051 using S-expressions.")
1052    (license license:gpl3+)))
1053
1054 (define-public guile-debbugs
1055   (package
1056     (name "guile-debbugs")
1057     (version "0.0.3")
1058     (source (origin
1059               (method url-fetch)
1060               (uri (string-append "mirror://gnu/guile-debbugs/guile-debbugs-"
1061                                   version ".tar.gz"))
1062               (sha256
1063                (base32
1064                 "1cc63nw3xdfjrfk8c58r6d5lidmfq5cpqcy32yd5xp81yccprvn9"))))
1065     (build-system gnu-build-system)
1066     (propagated-inputs
1067      `(("guile-email" ,guile-email)))
1068     (native-inputs
1069      `(("guile" ,guile-3.0)
1070        ("pkg-config" ,pkg-config)))
1071     (home-page "https://savannah.gnu.org/projects/guile-debbugs/")
1072     (synopsis "Guile interface to the Debbugs bug tracking service")
1073     (description
1074      "This package provides a Guile library to communicate with a Debbugs bug
1075 tracker's SOAP service, such as @url{https://bugs.gnu.org}.")
1076     (license license:gpl3+)))
1077
1078 (define-public guile-email
1079   (package
1080     (name "guile-email")
1081     (version "0.2.2")
1082     (source
1083      (origin
1084        (method url-fetch)
1085        (uri (string-append
1086              "https://guile-email.systemreboot.net/releases/guile-email-"
1087              version ".tar.lz"))
1088        (sha256
1089         (base32
1090          "1rc8r0fgvflnyq5ckl7ii8sghpsgpkzxa8vskjr1ak2kyar6m35k"))))
1091     (build-system gnu-build-system)
1092     (native-inputs
1093      `(("pkg-config" ,pkg-config)
1094        ("lzip" ,lzip)))
1095     (inputs
1096      `(("guile" ,guile-3.0)))
1097     (arguments
1098      '(#:make-flags '("GUILE_AUTO_COMPILE=0"))) ; to prevent guild warnings
1099     (home-page "https://guile-email.systemreboot.net")
1100     (synopsis "Guile email parser")
1101     (description "guile-email is a collection of email utilities implemented
1102 in pure guile.  It supports parsing MIME (Multipurpose Internet Mail
1103 Extensions) compliant email messages and reading emails from the mbox
1104 format.")
1105     (license license:agpl3+)))
1106
1107 (define-public guile2.2-email
1108   (package
1109     (inherit guile-email)
1110     (name "guile2.2-email")
1111     (inputs `(("guile" ,guile-2.2)
1112               ,@(alist-delete "guile" (package-inputs guile-email))))))
1113
1114 (define-public guile3.0-email
1115   (deprecated-package "guile3.0-email" guile-email))
1116
1117 (define-public guile-newt
1118   (package
1119     (name "guile-newt")
1120     (version "0.0.2")
1121     (source (origin
1122               (method git-fetch)
1123               (uri (git-reference
1124                     (url "https://gitlab.com/mothacehe/guile-newt")
1125                     (commit version)))
1126               (file-name (git-file-name name version))
1127               (sha256
1128                (base32
1129                 "1gksd1lzgjjh1p9vczghg8jw995d22hm34kbsiv8rcryirv2xy09"))))
1130     (build-system gnu-build-system)
1131     (arguments
1132      '(#:make-flags
1133        '("GUILE_AUTO_COMPILE=0"))) ;to prevent guild warnings
1134     (inputs
1135      `(("guile" ,guile-3.0)
1136        ("newt" ,newt)))
1137     (native-inputs
1138      `(("autoconf" ,autoconf)
1139        ("automake" ,automake)
1140        ("pkg-config" ,pkg-config)))
1141     (synopsis "Guile bindings to Newt")
1142     (description
1143      "This package provides bindings for Newt, a programming library for
1144 color text mode, widget based user interfaces.  The bindings are written in pure
1145 Scheme by using Guile’s foreign function interface.")
1146     (home-page "https://gitlab.com/mothacehe/guile-newt")
1147     (license license:gpl3+)))
1148
1149 (define-public guile2.2-newt
1150   (package
1151     (inherit guile-newt)
1152     (name "guile2.2-newt")
1153     (inputs `(("guile" ,guile-2.2)
1154               ,@(alist-delete "guile" (package-inputs guile-newt))))))
1155
1156 (define-public guile3.0-newt
1157   (deprecated-package "guile3.0-newt" guile-newt))
1158
1159 (define-public guile-mastodon
1160   (package
1161     (name "guile-mastodon")
1162     (version "0.0.1")
1163     (source (origin
1164               (method git-fetch)
1165               (uri (git-reference
1166                     (url "https://framagit.org/prouby/guile-mastodon.git")
1167                     (commit (string-append "v" version))))
1168               (file-name (git-file-name name version))
1169               (sha256
1170                (base32
1171                 "1vblf3d1bbwna3l09p2ap5y8ycvl549bz6whgk78imyfmn28ygry"))))
1172     (build-system gnu-build-system)
1173     (native-inputs
1174      `(("autoconf" ,autoconf)
1175        ("automake" ,automake)
1176        ("pkg-config" ,pkg-config)))
1177     (inputs
1178      `(("guile" ,guile-2.2)
1179        ("gnutls" ,gnutls)
1180        ("guile-json" ,guile-json-1)))
1181     (home-page "https://framagit.org/prouby/guile-mastodon")
1182     (synopsis "Guile Mastodon REST API module")
1183     (description "This package provides Guile modules to access the
1184 @uref{https://docs.joinmastodon.org/api/, REST API of Mastodon}, a federated
1185 microblogging service.")
1186     (license license:gpl3+)))
1187
1188 (define-public guile-parted
1189   (package
1190     (name "guile-parted")
1191     (version "0.0.4")
1192     (source (origin
1193               (method git-fetch)
1194               (uri (git-reference
1195                     (url "https://gitlab.com/mothacehe/guile-parted")
1196                     (commit version)))
1197               (file-name (git-file-name name version))
1198               (sha256
1199                (base32
1200                 "0b7h8psfm9gmmwb65pp5zwzglvwnfmw5j40g09hhf3f7kwxc0mv2"))
1201               (modules '((guix build utils)))))
1202     (build-system gnu-build-system)
1203     (arguments
1204      '(#:make-flags
1205        '("GUILE_AUTO_COMPILE=0"))) ;to prevent guild warnings
1206     (inputs
1207      `(("guile" ,guile-3.0)
1208        ("parted" ,parted)))
1209     (propagated-inputs
1210      `(("guile-bytestructures" ,guile-bytestructures)))
1211     (native-inputs
1212      `(("autoconf" ,autoconf)
1213        ("automake" ,automake)
1214        ("pkg-config" ,pkg-config)))
1215     (synopsis "Guile bindings to GNU Parted")
1216     (description
1217      "This package provides bindings for GNU Parted library, a C library
1218 allowing disk partition tables creation and manipulation.  The bindings are
1219 written in pure Scheme by using Guile's foreign function interface.")
1220     (home-page "https://gitlab.com/mothacehe/guile-parted")
1221     (license license:gpl3+)))
1222
1223 (define-public guile2.2-parted
1224   (package
1225     (inherit guile-parted)
1226     (name "guile2.2-parted")
1227     (inputs `(("guile" ,guile-2.2)
1228               ,@(alist-delete "guile" (package-inputs guile-parted))))
1229     (propagated-inputs
1230      `(("guile-bytestructures" ,guile2.2-bytestructures)))))
1231
1232 (define-public guile3.0-parted
1233   (deprecated-package "guile3.0-parted" guile-parted))
1234
1235 (define-public guile-xosd
1236   (package
1237     (name "guile-xosd")
1238     (version "0.2.1")
1239     (source (origin
1240               (method url-fetch)
1241               (uri (string-append "https://github.com/alezost/" name
1242                                   "/releases/download/v" version
1243                                   "/" name "-" version ".tar.gz"))
1244               (sha256
1245                (base32
1246                 "1ri5065c16kmgrf2pysn2ymxjqi5302lhpb07wkl1jr75ym8fn8p"))))
1247     (build-system gnu-build-system)
1248     (native-inputs
1249      `(("pkg-config" ,pkg-config)))
1250     (inputs
1251      `(("guile" ,guile-2.2)
1252        ("libx11" ,libx11)
1253        ("libxext" ,libxext)
1254        ("libxinerama" ,libxinerama)
1255        ("xosd" ,xosd)))
1256     (home-page "https://github.com/alezost/guile-xosd")
1257     (synopsis "XOSD bindings for Guile")
1258     (description
1259      "Guile-XOSD provides Guile bindings for @code{libxosd},
1260 @uref{http://sourceforge.net/projects/libxosd/, the X On Screen Display
1261 library}.")
1262     (license license:gpl3+)))
1263
1264 (define-public guile-dbi
1265   (package
1266     (name "guile-dbi")
1267     (version "2.1.6")
1268     (source (origin
1269               (method url-fetch)
1270               (uri (string-append
1271                     "http://download.gna.org/guile-dbi/guile-dbi-"
1272                     version ".tar.gz"))
1273               (sha256
1274                (base32
1275                 "116njrprhgrsv1qm904sp3b02rq01fx639r433d657gyhw3x159n"))))
1276     (build-system gnu-build-system)
1277     (arguments
1278      '(#:configure-flags
1279        (list (string-append
1280               "--with-guile-site-dir=" %output "/share/guile/site/2.2"))
1281        #:make-flags
1282        (list (string-append
1283               "LDFLAGS=-Wl,-rpath=" %output "/lib:"
1284               (assoc-ref %build-inputs "guile-dbd-sqlite3") "/lib" ":"
1285               (assoc-ref %build-inputs "guile-dbd-postgresql") "/lib"))
1286        #:phases
1287        (modify-phases %standard-phases
1288          (add-after 'install 'patch-extension-path
1289            (lambda* (#:key outputs #:allow-other-keys)
1290              (let* ((out     (assoc-ref outputs "out"))
1291                     (dbi.scm (string-append
1292                               out "/share/guile/site/2.2/dbi/dbi.scm"))
1293                     (ext     (string-append out "/lib/libguile-dbi")))
1294                (substitute* dbi.scm (("libguile-dbi") ext))
1295                #t))))))
1296     (inputs
1297      `(("guile-dbd-sqlite3" ,guile-dbd-sqlite3)
1298        ("guile-dbd-postgresql" ,guile-dbd-postgresql))) ; only shared library, no scheme files
1299     (propagated-inputs
1300      `(("guile" ,guile-2.2)))
1301     (synopsis "Guile database abstraction layer")
1302     (home-page "http://home.gna.org/guile-dbi/guile-dbi.html")
1303     (description
1304      "guile-dbi is a library for Guile that provides a convenient interface to
1305 SQL databases.  Database programming with guile-dbi is generic in that the same
1306 programming interface is presented regardless of which database system is used.
1307 It currently supports MySQL, Postgres and SQLite3.")
1308     (license license:gpl2+)))
1309
1310 (define guile-dbi-bootstrap
1311   (package
1312     (inherit guile-dbi)
1313     (name "guile-dbi-bootstrap")
1314     (inputs '())
1315     (arguments
1316      (substitute-keyword-arguments (package-arguments guile-dbi)
1317        ((#:make-flags _) '(list))))))
1318
1319 (define-public guile-dbd-sqlite3
1320   (package
1321     (name "guile-dbd-sqlite3")
1322     (version "2.1.6")
1323     (source (origin
1324               (method url-fetch)
1325               (uri (string-append
1326                     "http://download.gna.org/guile-dbi/guile-dbd-sqlite3-"
1327                     version ".tar.gz"))
1328               (sha256
1329                (base32
1330                 "0rg71jchxd2y8x496s8zmfmikr5g8zxi8zv2ar3f7a23pph92iw2"))))
1331     (build-system gnu-build-system)
1332     (native-inputs
1333      `(("pkg-config" ,pkg-config)
1334        ("guile-dbi-bootstrap" ,guile-dbi-bootstrap))) ; only required for headers
1335     (inputs
1336      `(("sqlite" ,sqlite)
1337        ("zlib" ,(@ (gnu packages compression) zlib))))
1338     (synopsis "Guile DBI driver for SQLite")
1339     (home-page "https://github.com/jkalbhenn/guile-dbd-sqlite3")
1340     (description
1341      "guile-dbi is a library for Guile that provides a convenient interface to
1342 SQL databases.  This package implements the interface for SQLite.")
1343     (license license:gpl2+)))
1344
1345 (define-public guile-dbd-postgresql
1346   (let ((commit "e97589b6b018b206c901e4cc24db463407a4036b")
1347         (revision 0))
1348     (package
1349       (name "guile-dbd-postgresql")
1350       (version (string-append
1351                 "2.1.6-" (number->string revision) "." (string-take commit 7)))
1352       (source
1353        (origin
1354          (method git-fetch)
1355          (uri (git-reference
1356                (url "https://github.com/opencog/guile-dbi")
1357                (commit commit)))
1358          (file-name (git-file-name name version))
1359          (sha256
1360           (base32 "0n1gv9a0kdys10a4qmnrwvg5sydwb03880asri4gqdchcj3fimni"))))
1361       (build-system gnu-build-system)
1362       (arguments
1363        '(#:phases
1364          (modify-phases %standard-phases
1365            (add-after 'unpack 'chdir
1366              (lambda _
1367                ;; The upstream Git repository contains all the code, so change
1368                ;; to the relevant directory.
1369                (chdir "guile-dbd-postgresql")
1370                #t))
1371            (add-after 'chdir 'patch-src/Makefile.am
1372              (lambda* (#:key inputs #:allow-other-keys)
1373                (substitute* "src/Makefile.am"
1374                  (("/usr/include")
1375                   (string-append (assoc-ref inputs "postgresql") "/include")))
1376                #t))
1377            (add-after 'patch-src/Makefile.am 'patch-src
1378              (lambda _
1379                (substitute* "src/guile-dbd-postgresql.c"
1380                  (("postgresql/libpq-fe\\.h") "libpq-fe.h"))
1381                #t)))))
1382       (native-inputs
1383        `(("pkg-config" ,pkg-config)
1384          ("automake" ,automake)
1385          ("autoconf" ,autoconf)
1386          ("perl" ,perl)
1387          ("libtool" ,libtool)
1388          ("guile-dbi-bootstrap" ,guile-dbi-bootstrap)))
1389       (inputs
1390        `(("postgresql" ,postgresql)
1391          ("zlib" ,zlib)))
1392       (synopsis "Guile DBI driver for PostgreSQL")
1393       (home-page
1394        "https://github.com/opencog/guile-dbi/tree/master/guile-dbd-postgresql")
1395       (description
1396        "@code{guile-dbi} is a library for Guile that provides a convenient
1397 interface to SQL databases.  This package implements the interface for
1398 PostgreSQL.")
1399       (license license:gpl2+))))
1400
1401 (define-public guile-config
1402   (package
1403     (name "guile-config")
1404     (version "0.4.2")
1405     (source
1406      (origin
1407        (method git-fetch)
1408        (uri (git-reference
1409              (url "https://gitlab.com/a-sassmannshausen/guile-config")
1410              (commit version)))
1411        (file-name (git-file-name name version))
1412        (sha256 (base32
1413                 "09028ylbddjdp3d67zdjz3pnsjqz6zs2bfck5rr3dfaa0qjap40n"))))
1414     (build-system gnu-build-system)
1415     (native-inputs
1416      `(("autoconf" ,autoconf)
1417        ("automake" ,automake)
1418        ("pkg-config" ,pkg-config)
1419        ("texinfo" ,texinfo)))
1420     (inputs `(("guile" ,guile-3.0)))
1421     (synopsis
1422      "Guile application configuration parsing library.")
1423     (description
1424      "Guile Config is a library providing a declarative approach to
1425 application configuration specification.  The library provides clean
1426 configuration declaration forms, and processors that take care of:
1427 configuration file creation; configuration file parsing; command-line
1428 parameter parsing using getopt-long; basic GNU command-line parameter
1429 generation (--help, --usage, --version); automatic output generation for the
1430 above command-line parameters.")
1431     (home-page
1432      "https://gitlab.com/a-sassmannshausen/guile-config")
1433     (license license:gpl3+)))
1434
1435 (define-public guile2.2-config
1436   (package
1437     (inherit guile-config)
1438     (name "guile2.2-config")
1439     (inputs `(("guile" ,guile-2.2)
1440               ,@(alist-delete "guile" (package-inputs guile-config))))))
1441
1442 (define-public guile3.0-config
1443   (deprecated-package "guile3.0-config" guile-config))
1444
1445 (define-public guile-hall
1446   (package
1447     (name "guile-hall")
1448     (version "0.3.1")
1449     (source
1450      (origin
1451        (method git-fetch)
1452        (uri (git-reference
1453              (url "https://gitlab.com/a-sassmannshausen/guile-hall")
1454              (commit version)))
1455        (file-name "guile-hall-0.3.1-checkout")
1456        (sha256
1457         (base32 "1s24nigdra6rvclvy15l2aw00c3aq9vv8qwxylzs60darbl36206"))))
1458     (build-system gnu-build-system)
1459     (arguments
1460       `(#:modules
1461         ((ice-9 match)
1462          (ice-9 ftw)
1463          ,@%gnu-build-system-modules)
1464         #:phases
1465         (modify-phases
1466           %standard-phases
1467           (add-after 'install 'hall-wrap-binaries
1468             (lambda* (#:key inputs outputs #:allow-other-keys)
1469               (let* ((compiled-dir
1470                        (lambda (out version)
1471                          (string-append
1472                            out "/lib/guile/" version "/site-ccache")))
1473                      (uncompiled-dir
1474                        (lambda (out version)
1475                          (string-append
1476                           out "/share/guile/site"
1477                           (if (string-null? version) "" "/") version)))
1478                      (dep-path
1479                        (lambda (env modules path)
1480                          (list env ":" 'prefix
1481                                (cons modules
1482                                      (map (lambda (input)
1483                                             (string-append
1484                                               (assoc-ref inputs input)
1485                                               path))
1486                                           ,''("guile-config"))))))
1487                      (out (assoc-ref outputs "out"))
1488                      (bin (string-append out "/bin/"))
1489                      (site (uncompiled-dir out "")))
1490                 (match (scandir site)
1491                        (("." ".." version)
1492                         (for-each
1493                           (lambda (file)
1494                             (wrap-program
1495                               (string-append bin file)
1496                               (dep-path
1497                                 "GUILE_LOAD_PATH"
1498                                 (uncompiled-dir out version)
1499                                 (uncompiled-dir "" version))
1500                               (dep-path
1501                                 "GUILE_LOAD_COMPILED_PATH"
1502                                 (compiled-dir out version)
1503                                 (compiled-dir "" version))))
1504                           ,''("hall"))
1505                         #t))))))))
1506     (native-inputs
1507       `(("autoconf" ,autoconf)
1508         ("automake" ,automake)
1509         ("pkg-config" ,pkg-config)
1510         ("texinfo" ,texinfo)))
1511     (inputs `(("guile" ,guile-3.0)))
1512     (propagated-inputs
1513      `(("guile-config" ,guile-config)))
1514     (synopsis "Guile project tooling")
1515     (description
1516      "Hall is a command-line application and a set of Guile libraries that
1517 allow you to quickly create and publish Guile projects.  It allows you to
1518 transparently support the GNU build system, manage a project hierarchy &
1519 provides tight coupling to Guix.")
1520     (home-page "https://gitlab.com/a-sassmannshausen/guile-hall")
1521     (license license:gpl3+)))
1522
1523 (define-public guile2.2-hall
1524   (package
1525     (inherit guile-hall)
1526     (name "guile2.2-hall")
1527     (inputs `(("guile" ,guile-2.2)
1528               ,@(alist-delete "guile" (package-inputs guile-hall))))
1529     (propagated-inputs
1530      `(("guile-config" ,guile2.2-config)
1531        ,@(alist-delete "guile-config"
1532                        (package-propagated-inputs guile-hall))))))
1533
1534 (define-public guile3.0-hall
1535   (deprecated-package "guile3.0-hall" guile-hall))
1536
1537 (define-public guile-ics
1538   (package
1539     (name "guile-ics")
1540     (version "0.2.0")
1541     (source (origin
1542               (method git-fetch)
1543               (uri (git-reference
1544                     (url "https://github.com/artyom-poptsov/guile-ics")
1545                     (commit (string-append "v" version))))
1546               (file-name (string-append name "-" version "-checkout"))
1547               (sha256
1548                (base32
1549                 "0qjjvadr7gibdq9jvwkmlkb4afsw9n2shfj9phpiadinxk3p4m2g"))
1550               (modules '((guix build utils)))
1551               (snippet
1552                '(begin
1553                   ;; Allow builds with Guile 3.0.
1554                   (substitute* "configure.ac"
1555                     (("^GUILE_PKG.*")
1556                      "GUILE_PKG([3.0 2.2 2.0])\n"))
1557                   #t))))
1558     (build-system gnu-build-system)
1559     (native-inputs
1560      `(("autoconf" ,autoconf-wrapper)
1561        ("automake" ,automake)
1562        ("texinfo" ,texinfo)
1563        ;; Gettext brings 'AC_LIB_LINKFLAGS_FROM_LIBS'.
1564        ("gettext" ,gettext-minimal)
1565        ("pkg-config" ,pkg-config)))
1566     (inputs `(("guile" ,guile-3.0) ("which" ,which)))
1567     (propagated-inputs `(("guile-lib" ,guile-lib)))
1568     (home-page "https://github.com/artyom-poptsov/guile-ics")
1569     (synopsis "Guile parser library for the iCalendar format")
1570     (description
1571      "Guile-ICS is an iCalendar (RFC5545) format parser library written in
1572 pure Scheme.  The library can be used to read and write iCalendar data.
1573
1574 The library is shipped with documentation in Info format and usage examples.")
1575     (license license:gpl3+)))
1576
1577 (define-public guile2.2-ics
1578   (package
1579     (inherit guile-ics)
1580     (name "guile2.2-ics")
1581     (inputs `(("guile" ,guile-2.2)
1582               ,@(alist-delete "guile" (package-inputs guile-ics))))
1583     (propagated-inputs `(("guile-lib" ,guile2.2-lib)))))
1584
1585 (define-public guile3.0-ics
1586   (deprecated-package "guile3.0-ics" guile-ics))
1587
1588 (define-public guile-wisp
1589   (package
1590     (name "guile-wisp")
1591     (version "1.0.2")
1592     (source (origin
1593               (method url-fetch)
1594               (uri (string-append "https://bitbucket.org/ArneBab/"
1595                                   "wisp/downloads/wisp-"
1596                                   version ".tar.gz"))
1597               (sha256
1598                (base32
1599                 "03pz7pj9jyallynhflp5s7qax8dj1fs8la434wrfgz7g1kgjnvf6"))))
1600     (build-system gnu-build-system)
1601     (arguments
1602      `(#:modules ((guix build gnu-build-system)
1603                   ((guix build emacs-build-system) #:prefix emacs:)
1604                   (guix build utils)
1605                   (guix build emacs-utils)
1606                   (ice-9 rdelim)
1607                   (ice-9 popen))
1608        #:imported-modules (,@%gnu-build-system-modules
1609                            (guix build emacs-build-system)
1610                            (guix build emacs-utils))
1611        #:phases
1612        (modify-phases %standard-phases
1613          (add-after 'unpack 'support-guile-3.0
1614            (lambda _
1615              (substitute* "configure"
1616                (("_guile_versions_to_search=\"2.2")
1617                 "_guile_versions_to_search=\"3.0 2.2"))
1618              #t))
1619          (add-before 'configure 'patch-/usr/bin/env
1620            (lambda _
1621              (substitute* "Makefile.in"
1622                (("/usr/bin/env bash") (which "bash")))
1623              #t))
1624          ;; auto compilation breaks, but if we set HOME to /tmp,
1625          ;; that works ok
1626          (add-before 'check 'auto-compile-hacky-workaround
1627            (lambda _ (setenv "HOME" "/tmp") #t))
1628          (add-after 'install 'install-go-files
1629            (lambda* (#:key outputs inputs #:allow-other-keys)
1630              (let* ((out (assoc-ref outputs "out"))
1631                     (effective (read-line
1632                                 (open-pipe* OPEN_READ
1633                                             "guile" "-c"
1634                                             "(display (effective-version))")))
1635                     (module-dir (string-append out "/share/guile/site/"
1636                                                effective))
1637                     (object-dir (string-append out "/lib/guile/" effective
1638                                                "/site-ccache"))
1639                     (prefix     (string-length module-dir)))
1640                ;; compile to the destination
1641                (for-each (lambda (file)
1642                            (let* ((base (string-drop (string-drop-right file 4)
1643                                                      prefix))
1644                                   (go   (string-append object-dir base ".go")))
1645                              (invoke "guild" "compile" "-L" module-dir
1646                                      file "-o" go)))
1647                          (find-files module-dir "\\.scm$"))
1648                #t)))
1649          (add-after 'install 'install-emacs-files
1650            (assoc-ref emacs:%standard-phases 'install))
1651          (add-after 'install-emacs-files 'compile-emacs-files
1652            (assoc-ref emacs:%standard-phases 'build))
1653          (add-after 'compile-emacs-files 'make-autoloads
1654            (assoc-ref emacs:%standard-phases 'make-autoloads)))))
1655     (home-page "https://www.draketo.de/english/wisp")
1656     (inputs
1657      `(("guile" ,guile-3.0)))
1658     (native-inputs
1659      `(("emacs" ,emacs-minimal)
1660        ("python" ,python)
1661        ("pkg-config" ,pkg-config)))
1662     (synopsis "Whitespace to lisp syntax for Guile")
1663     (description "Wisp is a syntax for Guile which provides a Python-like
1664 whitespace-significant language.  It may be easier on the eyes for some
1665 users and in some situations.")
1666     (license license:gpl3+)))
1667
1668 (define-public guile2.2-wisp
1669   (package
1670     (inherit guile-wisp)
1671     (name "guile2.2-wisp")
1672     (inputs `(("guile" ,guile-2.2)))))
1673
1674 (define-public guile3.0-wisp
1675   (deprecated-package "guile3.0-wisp" guile-wisp))
1676
1677 (define-public guile-sly
1678   (package
1679     (name "guile-sly")
1680     (version "0.1")
1681     (source (origin
1682               (method url-fetch)
1683               (uri (string-append "https://files.dthompson.us/sly/sly-"
1684                                   version ".tar.gz"))
1685               (sha256
1686                (base32
1687                 "1svzlbz2vripmyq2kjh0rig16bsrnbkwbsm558pjln9l65mcl4qq"))
1688               (modules '((guix build utils)))
1689               (snippet
1690                '(begin
1691                   (substitute* "configure"
1692                     (("_guile_required_version=\"2.0.11\"")
1693                      "_guile_required_version=\"2\"")
1694                     (("ac_subst_vars='")
1695                      "ac_subst_vars='GUILE_EFFECTIVE_VERSION\n"))
1696                   (substitute* (find-files "." "Makefile.in")
1697                     (("moddir = .*$")
1698                      (string-append
1699                       "moddir = "
1700                       "$(prefix)/share/guile/site/@GUILE_EFFECTIVE_VERSION@\n"))
1701                     (("godir = .*$")
1702                      (string-append
1703                       "godir = "
1704                       "$(prefix)/lib/guile/@GUILE_EFFECTIVE_VERSION@/site-ccache\n")))
1705                   #t))))
1706     (build-system gnu-build-system)
1707     (arguments
1708      '(#:configure-flags
1709        (list (string-append "--with-libfreeimage-prefix="
1710                             (assoc-ref %build-inputs "freeimage"))
1711              (string-append "--with-libgslcblas-prefix="
1712                             (assoc-ref %build-inputs "gsl")))))
1713     (native-inputs
1714      `(("pkg-config" ,pkg-config)))
1715     (propagated-inputs
1716      `(("guile-sdl" ,guile-sdl)
1717        ("guile-opengl" ,guile-opengl)))
1718     (inputs
1719      `(("guile" ,guile-2.2)
1720        ("gsl" ,gsl)
1721        ("freeimage" ,freeimage)
1722        ("mesa" ,mesa)))
1723     (synopsis "2D/3D game engine for GNU Guile")
1724     (description "Sly is a 2D/3D game engine written in Guile Scheme.  Sly
1725 features a functional reactive programming interface and live coding
1726 capabilities.")
1727     (home-page "https://dthompson.us/projects/sly.html")
1728     (license license:gpl3+)))
1729
1730 (define-public g-golf
1731   (let ((commit "5d2903afb4b6b65c22f587835d8fdff91916e5ee"))
1732     (package
1733       (name "g-golf")
1734       (version (git-version "1" "804" commit))
1735       (source (origin
1736                 (method git-fetch)
1737                 (uri (git-reference
1738                       (url "https://git.savannah.gnu.org/git/g-golf.git")
1739                       (commit commit)))
1740                 (file-name (git-file-name name version))
1741                 (sha256
1742                  (base32
1743                   "1xkb6a5d3i9s8lpb5cf06bd64p5srqnnhn5l0b2f5csbvyz8hmmh"))))
1744       (build-system gnu-build-system)
1745       (native-inputs
1746        `(("autoconf" ,autoconf)
1747          ("automake" ,automake)
1748          ("texinfo" ,texinfo)
1749          ("gettext" ,gettext-minimal)
1750          ("libtool" ,libtool)
1751          ("pkg-config" ,pkg-config)
1752          ("xorg-server" ,xorg-server)))
1753       (inputs
1754        `(("guile" ,guile-2.2)
1755          ("guile-lib" ,guile2.2-lib)
1756          ("clutter" ,clutter)
1757          ("gtk" ,gtk+)
1758          ("glib" ,glib)))
1759       (propagated-inputs
1760        `(("gobject-introspection" ,gobject-introspection)))
1761       (arguments
1762        `(#:phases
1763          (modify-phases %standard-phases
1764            (add-before 'configure 'tests-work-arounds
1765              (lambda* (#:key inputs #:allow-other-keys)
1766                ;; In build environment, There is no /dev/tty
1767                (substitute*
1768                    "test-suite/tests/gobject.scm"
1769                  (("/dev/tty") "/dev/null"))))
1770            (add-before 'configure 'substitute-libs
1771              (lambda* (#:key inputs outputs #:allow-other-keys)
1772                (let* ((get (lambda (key lib)
1773                              (string-append (assoc-ref inputs key) "/lib/" lib)))
1774                       (libgi      (get "gobject-introspection" "libgirepository-1.0"))
1775                       (libglib    (get "glib" "libglib-2.0"))
1776                       (libgobject (get "glib" "libgobject-2.0"))
1777                       (libgdk     (get "gtk" "libgdk-3")))
1778                  (substitute* "configure"
1779                    (("SITEDIR=\"\\$datadir/g-golf\"")
1780                     "SITEDIR=\"$datadir/guile/site/$GUILE_EFFECTIVE_VERSION\"")
1781                    (("SITECCACHEDIR=\"\\$libdir/g-golf/")
1782                     "SITECCACHEDIR=\"$libdir/"))
1783                  (substitute* "g-golf/init.scm"
1784                    (("libgirepository-1.0") libgi)
1785                    (("libglib-2.0") libglib)
1786                    (("libgdk-3") libgdk)
1787                    (("libgobject-2.0") libgobject)
1788                    (("\\(dynamic-link \"libg-golf\"\\)")
1789                     (format #f "~s"
1790                             `(dynamic-link
1791                               (format #f "~alibg-golf"
1792                                       (if (getenv "GUILE_GGOLF_UNINSTALLED")
1793                                           ""
1794                                           ,(format #f "~a/lib/"
1795                                                    (assoc-ref outputs "out"))))))))
1796                  (setenv "GUILE_AUTO_COMPILE" "0")
1797                  (setenv "GUILE_GGOLF_UNINSTALLED" "1")
1798                  #t)))
1799            (add-before 'check 'start-xorg-server
1800              (lambda* (#:key inputs #:allow-other-keys)
1801                ;; The test suite requires a running X server.
1802                (system (format #f "~a/bin/Xvfb :1 &"
1803                                (assoc-ref inputs "xorg-server")))
1804                (setenv "DISPLAY" ":1")
1805                #t)))))
1806       (home-page "https://www.gnu.org/software/g-golf/")
1807       (synopsis "Guile bindings for GObject Introspection")
1808       (description
1809        "G-Golf (Gnome: (Guile Object Library for)) is a library for developing
1810 modern applications in Guile Scheme.  It comprises a direct binding to the
1811 GObject Introspection API and higher-level functionality for importing Gnome
1812 libraries and making GObject classes (and methods) available in Guile's
1813 object-oriented programming system, GOOPS.")
1814       (license license:lgpl3+))))
1815
1816 (define-public g-wrap
1817   (package
1818     (name "g-wrap")
1819     (version "1.9.15")
1820     (source (origin
1821               (method url-fetch)
1822               (uri (string-append "mirror://savannah/g-wrap/g-wrap-"
1823                                   version ".tar.gz"))
1824               (sha256
1825                (base32
1826                 "0ak0bha37dfpj9kmyw1r8fj8nva639aw5xr66wr5gd3l1rqf5xhg"))))
1827     (build-system gnu-build-system)
1828     (native-inputs
1829      `(("pkg-config" ,pkg-config)))
1830     (propagated-inputs
1831      `(("guile" ,guile-2.2)
1832        ("guile-lib" ,guile-lib)))
1833     (inputs
1834      `(("libffi" ,libffi)))
1835     (arguments
1836      `(#:configure-flags '("--disable-Werror")
1837        #:phases
1838        (modify-phases %standard-phases
1839          (add-before 'configure 'pre-configure
1840            (lambda* (#:key outputs #:allow-other-keys)
1841              (let ((out (assoc-ref outputs "out")))
1842                (substitute* (find-files "." "^Makefile.in$")
1843                  (("guilemoduledir =.*guile/site" all)
1844                   (string-append all "/@GUILE_EFFECTIVE_VERSION@")))
1845                #t))))))
1846     (synopsis "Generate C bindings for Guile")
1847     (description "G-Wrap is a tool and Guile library for generating function
1848 wrappers for inter-language calls.  It currently only supports generating Guile
1849 wrappers for C functions.  Given a definition of the types and prototypes for
1850 a given C interface, G-Wrap will automatically generate the C code that
1851 provides access to that interface and its types from the Scheme level.")
1852     (home-page "https://www.nongnu.org/g-wrap/index.html")
1853     (license license:lgpl2.1+)))
1854
1855 (define-public guile-miniadapton
1856   (let ((commit "1b5749422304567c96ac5367f2221dda9eff5880")
1857         (revision "1"))
1858     (package
1859       (name "guile-miniadapton")
1860       (version (string-append "0-" revision "." (string-take commit 9)))
1861       (source (origin
1862                 (method git-fetch)
1863                 (uri (git-reference
1864                       (url "https://github.com/fisherdj/miniAdapton")
1865                       (commit commit)))
1866                 (file-name (string-append name "-" version "-checkout"))
1867                 (sha256
1868                  (base32
1869                   "09q51zkw2fypad5xixskfzw2cjhjgs5cswdp3i7cpp651rb3zndh"))))
1870       (build-system guile-build-system)
1871       (native-inputs
1872        `(("guile" ,guile-2.2)))
1873       (home-page "https://github.com/fisherdj/miniAdapton")
1874       (synopsis "Minimal implementation of incremental computation in Guile
1875 Scheme")
1876       (description "This package provides a complete Scheme implementation of
1877 miniAdapton, which implements the core functionality of the Adapton system for
1878 incremental computation (also known as self-adjusting computation).  Like
1879 Adapton, miniAdapton allows programmers to safely combine mutation and
1880 memoization.  miniAdapton is built on top of an even simpler system,
1881 microAdapton.  Both miniAdapton and microAdapton are designed to be easy to
1882 understand, extend, and port to host languages other than Scheme.")
1883       (license license:expat))))
1884
1885 (define-public guile-reader
1886   (package
1887     (name "guile-reader")
1888     (version "0.6.3")
1889     (source  (origin
1890                (method url-fetch)
1891                (uri (string-append "mirror://savannah/guile-reader/guile-reader-"
1892                                    version ".tar.gz"))
1893                (sha256
1894                 (base32
1895                  "1fyjckmygkhq22lq8nqc86yl5zzbqd7a944dnz5c1f6vx92b9hiq"))))
1896     (build-system gnu-build-system)
1897     (native-inputs `(("pkgconfig" ,pkg-config)
1898                      ("gperf" ,gperf)))
1899     (inputs `(("guile" ,guile-3.0)))
1900     (synopsis "Framework for building readers for GNU Guile")
1901     (description
1902      "Guile-Reader is a simple framework for building readers for GNU Guile.
1903
1904 The idea is to make it easy to build procedures that extend Guile’s read
1905 procedure.  Readers supporting various syntax variants can easily be written,
1906 possibly by re-using existing “token readers” of a standard Scheme
1907 readers.  For example, it is used to implement Skribilo’s R5RS-derived
1908 document syntax.
1909
1910 Guile-Reader’s approach is similar to Common Lisp’s “read table”, but
1911 hopefully more powerful and flexible (for instance, one may instantiate as
1912 many readers as needed).")
1913     (home-page "https://www.nongnu.org/guile-reader/")
1914     (license license:gpl3+)))
1915
1916 (define-public guile2.2-reader
1917   (package
1918     (inherit guile-reader)
1919     (name "guile2.2-reader")
1920     (inputs `(("guile" ,guile-2.2)))))
1921
1922 (define-public guile-ncurses
1923   (package
1924     (name "guile-ncurses")
1925     (version "3.0")
1926     (source (origin
1927              (method url-fetch)
1928              (uri (string-append "mirror://gnu/guile-ncurses/guile-ncurses-"
1929                                  version ".tar.gz"))
1930              (sha256
1931               (base32
1932                "038xbffalhymg26lvmzgf7ljilxz2f2zmqg5r5nfzbipfbprwjhf"))))
1933     (build-system gnu-build-system)
1934     (inputs `(("ncurses" ,ncurses)
1935               ("guile" ,guile-3.0)))
1936     (native-inputs `(("pkg-config" ,pkg-config)))
1937     (arguments
1938      `(#:modules ((guix build gnu-build-system)
1939                   ((guix build guile-build-system)
1940                    #:select (target-guile-effective-version))
1941                   (guix build utils))
1942        #:imported-modules ((guix build guile-build-system)
1943                            ,@%gnu-build-system-modules)
1944        #:configure-flags (list "--with-ncursesw" ; Unicode support
1945                                "--with-gnu-filesystem-hierarchy")
1946        #:phases
1947        (modify-phases %standard-phases
1948          (add-before 'build 'fix-libguile-ncurses-file-name
1949            (lambda* (#:key outputs #:allow-other-keys)
1950              (invoke "make" "install"
1951                      "-C" "src/ncurses"
1952                      "-j" (number->string
1953                            (parallel-job-count)))
1954              (let* ((out   (assoc-ref outputs "out"))
1955                     (dir   "src/ncurses")
1956                     (files (find-files dir ".scm")))
1957                (substitute* files
1958                  (("\"libguile-ncurses\"")
1959                   (format #f "\"~a/lib/guile/~a/libguile-ncurses\""
1960                           out (target-guile-effective-version))))
1961                #t))))))
1962     (home-page "https://www.gnu.org/software/guile-ncurses/")
1963     (synopsis "Guile bindings to ncurses")
1964     (description
1965      "guile-ncurses provides Guile language bindings for the ncurses
1966 library.")
1967     (license license:lgpl3+)))
1968
1969 (define-public guile2.2-ncurses
1970   (package
1971     (inherit guile-ncurses)
1972     (name "guile2.2-ncurses")
1973     (inputs `(("ncurses" ,ncurses)
1974               ("guile" ,guile-2.2)))))
1975
1976 (define-public guile3.0-ncurses
1977   (deprecated-package "guile3.0-ncurses" guile-ncurses))
1978
1979 (define-public guile-ncurses/gpm
1980   (package
1981     (inherit guile-ncurses)
1982     (name "guile-ncurses-with-gpm")
1983     (inputs `(("ncurses" ,ncurses/gpm)
1984               ("guile" ,guile-2.2)))))
1985
1986 (define-public guile3.0-ncurses/gpm
1987   (package
1988     (inherit guile3.0-ncurses)
1989     (name "guile3.0-ncurses-with-gpm")
1990     (inputs `(("ncurses" ,ncurses/gpm)
1991               ("guile" ,guile-3.0)))))
1992
1993 (define-public guile-lib
1994   (package
1995     (name "guile-lib")
1996     (version "0.2.6.1")
1997     (source (origin
1998               (method url-fetch)
1999               (uri (string-append "mirror://savannah/guile-lib/guile-lib-"
2000                                   version ".tar.gz"))
2001               (sha256
2002                (base32
2003                 "0aizxdif5dpch9cvs8zz5g8ds5s4xhfnwza2il5ji7fv2h7ks7bd"))
2004               (modules '((guix build utils)))
2005               (snippet
2006                '(begin
2007                   ;; Work around miscompilation on Guile 3.0.0 at -O2:
2008                   ;; <https://bugs.gnu.org/39251>.
2009                   (substitute* "src/md5.scm"
2010                     (("\\(define f-ash ash\\)")
2011                      "(define f-ash (@ (guile) ash))\n")
2012                     (("\\(define f-add \\+\\)")
2013                      "(define f-add (@ (guile) +))\n"))
2014                   #t))))
2015     (build-system gnu-build-system)
2016     (arguments
2017      '(#:make-flags
2018        '("GUILE_AUTO_COMPILE=0")        ; to prevent guild errors
2019        #:phases
2020        (modify-phases %standard-phases
2021          (add-before 'configure 'patch-module-dir
2022            (lambda _
2023              (substitute* "src/Makefile.in"
2024                (("^moddir = ([[:graph:]]+)")
2025                 "moddir = $(datadir)/guile/site/@GUILE_EFFECTIVE_VERSION@\n")
2026                (("^godir = ([[:graph:]]+)")
2027                 "godir = \
2028 $(libdir)/guile/@GUILE_EFFECTIVE_VERSION@/site-ccache\n"))
2029              #t)))))
2030     (native-inputs `(("pkg-config" ,pkg-config)))
2031     (inputs `(("guile" ,guile-3.0)))
2032     (home-page "https://www.nongnu.org/guile-lib/")
2033     (synopsis "Collection of useful Guile Scheme modules")
2034     (description
2035      "Guile-Lib is intended as an accumulation place for pure-scheme Guile
2036 modules, allowing for people to cooperate integrating their generic Guile
2037 modules into a coherent library.  Think \"a down-scaled, limited-scope CPAN
2038 for Guile\".")
2039
2040     ;; The whole is under GPLv3+, but some modules are under laxer
2041     ;; distribution terms such as LGPL and public domain.  See `COPYING' for
2042     ;; details.
2043     (license license:gpl3+)))
2044
2045 (define-public guile2.0-lib
2046   (package
2047     (inherit guile-lib)
2048     (name "guile2.0-lib")
2049     (inputs `(("guile" ,guile-2.0)))))
2050
2051 (define-public guile2.2-lib
2052   (package
2053     (inherit guile-lib)
2054     (name "guile2.2-lib")
2055     (inputs `(("guile" ,guile-2.2)))))
2056
2057 (define-public guile3.0-lib
2058   (deprecated-package "guile3.0-lib" guile-lib))
2059
2060 (define-public guile-minikanren
2061   (package
2062     (name "guile-minikanren")
2063     (version "20150424.e844d85")
2064     (source (origin
2065               (method git-fetch)
2066               (uri (git-reference
2067                     (url "https://github.com/ijp/minikanren")
2068                     (commit "e844d85512f8c055d3f96143ee506007389a25e3")))
2069               (file-name (string-append name "-" version "-checkout"))
2070               (sha256
2071                (base32
2072                 "0r50jlpzi940jlmxyy3ddqqwmj5r12gb4bcv0ssini9v8km13xz6"))))
2073     (build-system guile-build-system)
2074     (native-inputs
2075      `(("guile" ,guile-3.0)))
2076     (home-page "https://github.com/ijp/minikanren")
2077     (synopsis "MiniKanren declarative logic system, packaged for Guile")
2078     (description
2079      "MiniKanren is a relational programming extension to the Scheme
2080 programming Language, written as a smaller version of Kanren suitable for
2081 pedagogical purposes.  It is featured in the book, The Reasoned Schemer,
2082 written by Dan Friedman, William Byrd, and Oleg Kiselyov.
2083
2084 This is Ian Price's r6rs packaged version of miniKanren, which deviates
2085 slightly from miniKanren mainline.
2086
2087 See http://minikanren.org/ for more on miniKanren generally.")
2088     (license license:expat)))
2089
2090 (define-public guile2.0-minikanren
2091   (package
2092     (inherit guile-minikanren)
2093     (name "guile2.0-minikanren")
2094     (native-inputs `(("guile" ,guile-2.0)))))
2095
2096 (define-public guile2.2-minikanren
2097   (package
2098     (inherit guile-minikanren)
2099     (name "guile2.2-minikanren")
2100     (native-inputs `(("guile" ,guile-2.2)))))
2101
2102 (define-public guile3.0-minikanren
2103   (deprecated-package "guile3.0-minikanren" guile-minikanren))
2104
2105 (define-public guile-irregex
2106   (package
2107     (name "guile-irregex")
2108     (version "0.9.6")
2109     (source (origin
2110               (method url-fetch)
2111               (uri (string-append
2112                     "http://synthcode.com/scheme/irregex/irregex-"
2113                     version ".tar.gz"))
2114               (sha256
2115                (base32
2116                 "1ia3m7dp3lcxa048q0gqbiwwsyvn99baw6xkhb4bhhzn4k7bwyqq"))))
2117     (build-system guile-build-system)
2118     (arguments
2119      '(#:phases (modify-phases %standard-phases
2120                   (add-after 'unpack 'move-files-around
2121                     (lambda _
2122                       ;; Move the relevant source files to src/ and create the
2123                       ;; rx/ directory to match the expected module hierarchy.
2124                       (mkdir-p "src/rx/source")
2125                       (rename-file "irregex-guile.scm"
2126                                    "src/rx/irregex.scm")
2127                       (rename-file "irregex.scm"
2128                                    "src/rx/source/irregex.scm")
2129                       ;; Not really reachable via guile's packaging system,
2130                       ;; but nice to have around.
2131                       (rename-file "irregex-utils.scm"
2132                                    "src/rx/source/irregex-utils.scm")
2133                       #t)))
2134        #:source-directory "src"))
2135     (native-inputs
2136      `(("guile" ,guile-3.0)))
2137     (home-page "http://synthcode.com/scheme/irregex")
2138     (synopsis "S-expression based regular expressions")
2139     (description
2140      "Irregex is an s-expression based alternative to your classic
2141 string-based regular expressions.  It implements SRFI 115 and is deeply
2142 inspired by the SCSH regular expression system.")
2143     (license license:bsd-3)))
2144
2145 (define-public guile2.0-irregex
2146   (package
2147     (inherit guile-irregex)
2148     (name "guile2.0-irregex")
2149     (native-inputs `(("guile" ,guile-2.0)))))
2150
2151 (define-public guile2.2-irregex
2152   (package
2153     (inherit guile-irregex)
2154     (name "guile2.2-irregex")
2155     (native-inputs `(("guile" ,guile-2.2)))))
2156
2157 (define-public guile3.0-irregex
2158   (deprecated-package "guile3.0-irregex" guile-irregex))
2159
2160 (define-public haunt
2161   (package
2162     (name "haunt")
2163     (version "0.2.4")
2164     (source (origin
2165               (method url-fetch)
2166               (uri (string-append "https://files.dthompson.us/haunt/haunt-"
2167                                   version ".tar.gz"))
2168               (sha256
2169                (base32
2170                 "056z4znikk83nr5mr0x2ac3iinqbywa2bvb37mhr566a1q50isfc"))
2171               (modules '((guix build utils)))
2172               (snippet
2173                '(begin
2174                   ;; Allow builds with Guile 3.0.
2175                   (substitute* "configure"
2176                     (("2\\.2 2\\.0")
2177                      "3.0 2.2 2.0"))
2178                   #t))))
2179     (build-system gnu-build-system)
2180     (arguments
2181      `(#:modules ((ice-9 match) (ice-9 ftw)
2182                   ,@%gnu-build-system-modules)
2183        #:tests? #f ; test suite is non-deterministic :(
2184        #:phases (modify-phases %standard-phases
2185                   (add-after 'install 'wrap-haunt
2186                     (lambda* (#:key inputs outputs #:allow-other-keys)
2187                       ;; Wrap the 'haunt' command to refer to the right
2188                       ;; modules.
2189                       (let* ((out  (assoc-ref outputs "out"))
2190                              (bin  (string-append out "/bin"))
2191                              (site (string-append
2192                                     out "/share/guile/site"))
2193                              (guile-reader (assoc-ref inputs "guile-reader"))
2194                              (deps `(,@(if guile-reader
2195                                            (list guile-reader)
2196                                            '())
2197                                      ,(assoc-ref inputs "guile-commonmark"))))
2198                         (match (scandir site)
2199                           (("." ".." version)
2200                            (let ((modules (string-append site "/" version))
2201                                  (compiled-modules (string-append
2202                                                     out "/lib/guile/" version
2203                                                     "/site-ccache")))
2204                              (wrap-program (string-append bin "/haunt")
2205                                `("GUILE_LOAD_PATH" ":" prefix
2206                                  (,modules
2207                                   ,@(map (lambda (dep)
2208                                            (string-append dep
2209                                                           "/share/guile/site/"
2210                                                           version))
2211                                          deps)))
2212                                `("GUILE_LOAD_COMPILED_PATH" ":" prefix
2213                                  (,compiled-modules
2214                                   ,@(map (lambda (dep)
2215                                            (string-append dep "/lib/guile/"
2216                                                           version
2217                                                           "/site-ccache"))
2218                                          deps))))
2219                              #t)))))))))
2220     (native-inputs
2221      `(("pkg-config" ,pkg-config)
2222        ("texinfo" ,texinfo)))
2223     (inputs
2224      `(("guile" ,guile-3.0)))
2225     (propagated-inputs
2226      `(("guile-reader" ,guile-reader)
2227        ("guile-commonmark" ,guile-commonmark)))
2228     (synopsis "Functional static site generator")
2229     (description "Haunt is a static site generator written in Guile
2230 Scheme.  Haunt features a functional build system and an extensible
2231 interface for reading articles in any format.")
2232     (home-page "http://haunt.dthompson.us")
2233     (license license:gpl3+)))
2234
2235 (define-public guile2.2-haunt
2236   (package
2237     (inherit haunt)
2238     (name "guile2.2-haunt")
2239     (inputs `(("guile" ,guile-2.2)))
2240     (propagated-inputs
2241      `(("guile-reader" ,guile2.2-reader)
2242        ("guile-commonmark" ,guile2.2-commonmark)))))
2243
2244 (define-public guile2.0-haunt
2245   (package
2246     (inherit haunt)
2247     (name "guile2.0-haunt")
2248     (inputs `(("guile" ,guile-2.0)))))
2249
2250 (define-public guile3.0-haunt
2251   (deprecated-package "guile3.0-haunt" haunt))
2252
2253 (define-public guile-redis
2254   (package
2255     (name "guile-redis")
2256     (version "1.3.0")
2257     (home-page "https://github.com/aconchillo/guile-redis")
2258     (source (origin
2259               (method git-fetch)
2260               (uri (git-reference
2261                      (url home-page)
2262                      (commit version)))
2263               (file-name (git-file-name name version))
2264               (sha256
2265                (base32
2266                 "14izs8daxh7pb7vwpxi5g427qa31137jkaxrb1cy5rpjkwchy723"))))
2267     (build-system gnu-build-system)
2268     (native-inputs
2269      `(("autoconf" ,autoconf)
2270        ("automake" ,automake)
2271        ("pkg-config" ,pkg-config)
2272        ("guile" ,guile-3.0)))
2273     (synopsis "Redis client library for Guile")
2274     (description "Guile-redis provides a Scheme interface to the Redis
2275 key-value cache and store.")
2276     (license license:lgpl3+)))
2277
2278 (define-public guile2.2-redis
2279   (package
2280     (inherit guile-redis)
2281     (name "guile2.2-redis")
2282     (native-inputs `(("guile" ,guile-2.2)
2283                      ,@(alist-delete "guile"
2284                                      (package-native-inputs guile-redis))))))
2285
2286 (define-public guile2.0-redis
2287   (package
2288     (inherit guile-redis)
2289     (name "guile2.0-redis")
2290     (native-inputs `(("guile" ,guile-2.0)
2291                      ,@(alist-delete "guile"
2292                                      (package-native-inputs guile-redis))))))
2293
2294 (define-public guile-commonmark
2295   (package
2296     (name "guile-commonmark")
2297     (version "0.1.2")
2298     (source (origin
2299               (method url-fetch)
2300               (uri (string-append "https://github.com/OrangeShark/" name
2301                                   "/releases/download/v" version
2302                                   "/" name "-" version ".tar.gz"))
2303               (sha256
2304                (base32
2305                 "17lrsdisa3kckh24q114vfmzdc4wkqa6ccwl4hdlrng5wpn1iman"))
2306               (modules '((guix build utils)))
2307               (snippet
2308                '(begin
2309                   ;; Allow builds with Guile 3.0.
2310                   (substitute* "configure"
2311                     (("2\\.2 2\\.0")
2312                      "3.0 2.2 2.0"))
2313                   #t))))
2314     (build-system gnu-build-system)
2315     (inputs
2316      `(("guile" ,guile-3.0)))
2317     (native-inputs
2318      `(("pkg-config" ,pkg-config)))
2319     (synopsis "CommonMark parser for Guile")
2320     (description
2321      "guile-commonmark is a library for parsing CommonMark, a fully specified
2322 variant of Markdown.  The library is written in Guile Scheme and is designed
2323 to transform a CommonMark document to SXML.  guile-commonmark tries to closely
2324 follow the @uref{http://commonmark.org/, CommonMark spec}, the main difference
2325 is no support for parsing block and inline level HTML.")
2326     (home-page "https://github.com/OrangeShark/guile-commonmark")
2327     (license license:lgpl3+)))
2328
2329 (define-public guile2.2-commonmark
2330   (package
2331     (inherit guile-commonmark)
2332     (name "guile2.2-commonmark")
2333     (inputs `(("guile" ,guile-2.2)))))
2334
2335 (define-public guile2.0-commonmark
2336   (package
2337     (inherit guile-commonmark)
2338     (name "guile2.0-commonmark")
2339     (inputs `(("guile" ,guile-2.0)))))
2340
2341 (define-public guile3.0-commonmark
2342   (deprecated-package "guile3.0-commonmark" guile-commonmark))
2343
2344 (define-public mcron
2345   (package
2346     (name "mcron")
2347     (version "1.1.4")
2348     (source (origin
2349               (method url-fetch)
2350               (uri (string-append "mirror://gnu/mcron/mcron-"
2351                                   version ".tar.gz"))
2352               (sha256
2353                (base32
2354                 "1521w3h33bhdlg6qc66sq4dwv3qsx8r8x6srq4ca6kaahy6dszw8"))))
2355     (build-system gnu-build-system)
2356     (arguments
2357      '(#:phases (modify-phases %standard-phases
2358                   (add-before 'check 'adjust-tests
2359                     (lambda _
2360                       (substitute* "tests/job-specifier.scm"
2361                         ;; (getpw) fails with "entry not found" in the build
2362                         ;; environment, so pass an argument.
2363                         (("\\(getpw\\)")
2364                          "(getpwnam (getuid))")
2365                         ;; The build environment lacks an entry for root in
2366                         ;; /etc/passwd.
2367                         (("\\(getpw 0\\)")
2368                          "(getpwnam \"nobody\")")
2369
2370                         ;; FIXME: Skip the 4 faulty tests (see above).
2371                         (("\\(test-equal \"next-year\"" all)
2372                          (string-append "(test-skip 4)\n" all)))
2373                       #t)))))
2374     (native-inputs `(("pkg-config" ,pkg-config)
2375                      ("tzdata" ,tzdata-for-tests)
2376                      ("guile-native"              ;for 'guild compile'
2377                       ,@(assoc-ref (package-inputs this-package) "guile"))))
2378     (inputs `(("guile" ,guile-3.0)))
2379     (home-page "https://www.gnu.org/software/mcron/")
2380     (synopsis "Run jobs at scheduled times")
2381     (description
2382      "GNU Mcron is a complete replacement for Vixie cron.  It is used to run
2383 tasks on a schedule, such as every hour or every Monday.  Mcron is written in
2384 Guile, so its configuration can be written in Scheme; the original cron
2385 format is also supported.")
2386     (license license:gpl3+)))
2387
2388 (define-public guile2.2-mcron
2389   (package
2390     (inherit mcron)
2391     (name "guile2.2-mcron")
2392     (inputs `(("guile" ,guile-2.2)))))
2393
2394 (define-public guile3.0-mcron
2395   (deprecated-package "guile3.0-mcron" mcron))
2396
2397 (define-public guile-picture-language
2398   (let ((commit "91d10c96708d732145006dd2802acc4de08b632e")
2399         (revision "1"))
2400     (package
2401       (name "guile-picture-language")
2402       (version (git-version "0.0.1" revision commit))
2403       (source (origin
2404                 (method git-fetch)
2405                 (uri (git-reference
2406                       (url "https://git.elephly.net/software/guile-picture-language.git")
2407                       (commit commit)))
2408                 (file-name (git-file-name name version))
2409                 (sha256
2410                  (base32
2411                   "1ydvw9dvssdvlvhh1dr8inyzy2x6m41qgp8hsivca1xysr4gc23a"))))
2412       (build-system gnu-build-system)
2413       (inputs
2414        `(("guile" ,guile-3.0)))
2415       (native-inputs
2416        `(("autoconf" ,autoconf)
2417          ("automake" ,automake)
2418          ("imagemagick" ,imagemagick)
2419          ("pkg-config" ,pkg-config)
2420          ("texinfo" ,texinfo)))
2421       (home-page "https://git.elephly.net/software/guile-picture-language.git")
2422       (synopsis "Picture language for Guile")
2423       (description
2424        "This package provides a simple SVG-based picture language for Guile.
2425 The picture values can directly be displayed in Geiser.")
2426       (license license:lgpl3+))))
2427
2428 (define-public guile2.2-picture-language
2429   (package
2430     (inherit guile-picture-language)
2431     (name "guile2.2-picture-language")
2432     (inputs `(("guile" ,guile-2.2)))))
2433
2434 (define-public guile3.0-picture-language
2435   (deprecated-package "guile3.0-picture-language"
2436                       guile-picture-language))
2437
2438 (define-public guile-studio
2439   (let ((commit "d24d59a68e3f1fa9477e3430fc48a2efe97b805d")
2440         (revision "1"))
2441     (package
2442       (name "guile-studio")
2443       (version (git-version "0.0.2" revision commit))
2444       (source (origin
2445                 (method git-fetch)
2446                 (uri (git-reference
2447                       (url "https://git.elephly.net/software/guile-studio.git")
2448                       (commit commit)))
2449                 (file-name (git-file-name name version))
2450                 (sha256
2451                  (base32
2452                   "0kqi0q8a7si65n21b7gn8vbninwcg0fqy5hmvy3l1bi6iync20zr"))))
2453       (build-system gnu-build-system)
2454       (arguments
2455        `(#:modules
2456          ((ice-9 match)
2457           (srfi srfi-1)
2458           ,@%gnu-build-system-modules)
2459          #:tests? #f                    ; there are none
2460          #:make-flags
2461          (list (string-append "ICONS_DIR="
2462                               (assoc-ref %build-inputs "adwaita-icon-theme")
2463                               "/share/icons/Adwaita/")
2464                (string-append "PICT_DIR="
2465                               (assoc-ref %build-inputs "guile-picture-language"))
2466                (string-append "EMACS_DIR="
2467                               (assoc-ref %build-inputs "emacs"))
2468                (string-append "GUILE_DIR="
2469                               (assoc-ref %build-inputs "guile"))
2470                (string-join (cons "INPUTS="
2471                                   (filter-map
2472                                    (lambda (input)
2473                                      (match input
2474                                        ((label . pkg)
2475                                         (and (string-prefix? "emacs" label) pkg))))
2476                                    %build-inputs)))
2477                (string-append "PREFIX=" (assoc-ref %outputs "out")))
2478          #:phases
2479          (modify-phases %standard-phases
2480            (delete 'configure)
2481            (delete 'install))))
2482       (inputs
2483        `(("guile" ,guile-3.0)
2484          ("guile-picture-language" ,guile-picture-language)
2485          ("emacs" ,emacs)
2486          ("emacs-geiser" ,emacs-geiser)
2487          ("emacs-company" ,emacs-company)
2488          ("emacs-flycheck" ,emacs-flycheck)
2489          ("emacs-smart-mode-line" ,emacs-smart-mode-line)
2490          ("emacs-paren-face" ,emacs-paren-face)
2491          ("adwaita-icon-theme" ,adwaita-icon-theme)))
2492       (native-inputs
2493        `(("texinfo" ,texinfo)))
2494       (home-page "https://gnu.org/software/guile")
2495       (synopsis "IDE for Guile")
2496       (description
2497        "This is Emacs with a few settings that make working with Guile easier
2498 for people new to Emacs.  Features include: CUA mode, Geiser, tool bar icons
2499 to evaluate Guile buffers, support for Guile's very own picture language, code
2500 completion, a simple mode line, etc.")
2501       (license license:gpl3+))))
2502
2503 (define-public guile-stis-parser
2504   (package
2505     (name "guile-stis-parser")
2506     (version "1.2.4.1")
2507     (source (origin
2508               (method git-fetch)
2509               (uri (git-reference
2510                     (url "https://gitlab.com/tampe/stis-parser")
2511                     (commit (string-append "v" version))))
2512               (file-name (git-file-name name version))
2513               (sha256
2514                (base32
2515                 "1fvxdfvc80zqhwzq5x3kxyr6j8p4b51yx85fx1gr3d4gy2ddpx5w"))))
2516     (build-system gnu-build-system)
2517     (arguments
2518      `(#:parallel-build? #f             ; not supported
2519        #:phases
2520        (modify-phases %standard-phases
2521          (add-after 'unpack 'chdir
2522            (lambda _ (chdir "modules") #t))
2523          (add-after 'chdir 'delete-broken-symlink
2524            (lambda _
2525              (delete-file "parser/stis-parser/lang/.#calc.scm")
2526              #t)))))
2527     (inputs
2528      `(("guile" ,guile-3.0)))
2529     (native-inputs
2530      `(("autoconf" ,autoconf)
2531        ("automake" ,automake)
2532        ("pkg-config" ,pkg-config)))
2533     (home-page "https://gitlab.com/tampe/stis-parser")
2534     (synopsis "Parser combinator framework")
2535     (description
2536      "This package provides a functional parser combinator library that
2537 supports backtracking and a small logical framework. The idea is to build up
2538 chunks that are memoized and there is no clear scanner/parser separation,
2539 chunks can be expressions as well as simple tokens.")
2540     (license license:lgpl2.0+)))
2541
2542 (define-public guile-persist
2543   (package
2544     (name "guile-persist")
2545     (version "1.2.3")
2546     (source (origin
2547               (method git-fetch)
2548               (uri (git-reference
2549                     (url "https://gitlab.com/tampe/guile-persist")
2550                     (commit (string-append "v" version))))
2551               (file-name (git-file-name name version))
2552               (sha256
2553                (base32
2554                 "19f8hqcax4v40858kx2j8fy1cvzc2djj99r0n17dy1xxmwa097qi"))))
2555     (build-system gnu-build-system)
2556     (arguments
2557      `(#:phases
2558        (modify-phases %standard-phases
2559          (add-after 'unpack 'patch-prefix
2560            (lambda* (#:key inputs outputs #:allow-other-keys)
2561              (substitute* "src/Makefile.am"
2562                (("/usr/local/lib/guile")
2563                 (string-append (assoc-ref outputs "out") "/lib/guile"))
2564                (("/usr/local/include/guile")
2565                 (string-append (assoc-ref inputs "guile") "/include/guile"))
2566                (("-L/usr/local/lib")
2567                 (string-append "-L" (assoc-ref inputs "guile") "/lib")))
2568              #t))
2569          (add-after 'unpack 'patch-library-reference
2570            (lambda* (#:key outputs #:allow-other-keys)
2571              (let ((out (assoc-ref outputs "out")))
2572                (substitute* "persist/persistance.scm"
2573                  (("\"libguile-persist\"")
2574                   (format #f "\"~a/lib/guile/3.0/extensions/libguile-persist\"" out)))
2575                #t))))))
2576     (inputs
2577      `(("guile" ,guile-3.0)))
2578     (native-inputs
2579      `(("autoconf" ,autoconf)
2580        ("automake" ,automake)
2581        ("libtool" ,libtool)
2582        ("pkg-config" ,pkg-config)))
2583     (home-page "https://gitlab.com/tampe/guile-persist")
2584     (synopsis "Persistence programming framework for Guile")
2585     (description
2586      "This is a serialization library for serializing objects like classes
2587 and objects, closures and structs.  This currently does not support
2588 serializing continuations or delimited continuations.")
2589     (license license:lgpl2.0+)))
2590
2591 (define-public python-on-guile
2592   (package
2593     (name "python-on-guile")
2594     (version "1.2.3.5")
2595     (home-page "https://gitlab.com/python-on-guile/python-on-guile")
2596     (source (origin
2597               (method git-fetch)
2598               (uri (git-reference (url home-page)
2599                                   (commit (string-append "v" version))))
2600               (file-name (git-file-name name version))
2601               (sha256
2602                (base32
2603                 "05xrvcj6a4gzq1ybyin270qz8wamgc7w2skyi9iy6hkpgdhxy8vf"))))
2604     (build-system gnu-build-system)
2605     (arguments
2606      `(#:parallel-build? #f                   ;not supported
2607        #:make-flags '("GUILE_AUTO_COMPILE=0") ;to prevent guild warnings
2608        #:phases
2609        (modify-phases %standard-phases
2610          (add-after 'unpack 'chdir
2611            (lambda _ (chdir "modules") #t))
2612          (add-after 'chdir 'augment-GUILE_LOAD_PATH
2613            (lambda _
2614              ;; TODO: It would be better to patch the Makefile.
2615              (setenv "GUILE_LOAD_PATH"
2616                      (string-append ".:"
2617                                     (getenv "GUILE_LOAD_PATH")))
2618              #t))
2619          (add-after 'install 'wrap
2620            (lambda* (#:key outputs #:allow-other-keys)
2621              ;; Wrap the 'python' executable so it can find its
2622              ;; dependencies and own modules.
2623              (let* ((out (assoc-ref outputs "out"))
2624                     (guile-version ,(version-major+minor
2625                                      (package-version guile-3.0)))
2626                     (scm (string-append out "/share/guile/site/"
2627                                         guile-version))
2628                     (ccache (string-append out "/lib/guile/" guile-version
2629                                            "/site-ccache"))
2630                     (load-path (string-join
2631                                 (cons scm
2632                                       ;; XXX: cdr because we augment it above.
2633                                       (cdr (string-split
2634                                             (getenv "GUILE_LOAD_PATH") #\:)))
2635                                 ":"))
2636                     (compiled-path (string-append
2637                                     ccache ":"
2638                                     (getenv "GUILE_LOAD_COMPILED_PATH"))))
2639                (wrap-program (string-append out "/bin/python")
2640                  `("GUILE_LOAD_PATH" ":" prefix
2641                    (,load-path))
2642                  `("GUILE_LOAD_COMPILED_PATH" ":" prefix
2643                    (,compiled-path)))
2644                #t))))))
2645     (inputs
2646      `(("guile" ,guile-3.0)
2647        ("guile-persist" ,guile-persist)
2648        ("guile-readline" ,guile-readline)
2649        ("guile-stis-parser" ,guile-stis-parser)))
2650     (native-inputs
2651      `(("autoconf" ,autoconf)
2652        ("automake" ,automake)
2653        ("libtool" ,libtool)
2654        ("pkg-config" ,pkg-config)))
2655     (synopsis "Python implementation in Guile")
2656     (description
2657      "This package allows you to compile a Guile Python file to any target
2658 from @code{tree-il}.")
2659     (license license:lgpl2.0+)))
2660
2661 (define-public guile-file-names
2662   (package
2663     (name "guile-file-names")
2664     (version "0.3")
2665     (source (origin
2666               (method url-fetch)
2667               (uri (string-append "http://brandon.invergo.net/software/download/"
2668                                   "guile-file-names/guile-file-names-"
2669                                   version ".tar.gz"))
2670               (sha256
2671                (base32
2672                 "01chizdxkhw6aqv629vxka9f5x3534ij7r0jqndawsg2vxm1r9sz"))))
2673     (build-system gnu-build-system)
2674     (arguments
2675      `(#:phases
2676        (modify-phases %standard-phases
2677          (add-after 'unpack 'fix-target-directory
2678            (lambda _
2679              (substitute* "src/Makefile.in"
2680                (("guilemoddir = \\$\\(GUILE_SITE\\)")
2681                 "guilemoddir = $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
2682              #t)))))
2683     (inputs
2684      `(("guile" ,guile-2.2)))
2685     (native-inputs
2686      `(("pkg-config" ,pkg-config)))
2687     (home-page "https://gitlab.com/brandoninvergo/guile-file-names")
2688     (synopsis "Manipulate file names")
2689     (description
2690      "The @code{(file-names)} module provides tools for manipulating file
2691 names.  The module was built on the idea that doing anything more than a
2692 non-trivial modification of a file name string is a pain (making sure all
2693 slashes are present and accounted for, resolving @code{.} and @code{..}, etc).
2694 Inevitably, you have to break the string up into chunks and operate on that
2695 list of components.  This module takes care of that for you.")
2696     (license license:lgpl3+)))
2697
2698 (define-public guile-gi
2699   (package
2700     (name "guile-gi")
2701     (version "0.3.0")
2702     (source (origin
2703               (method url-fetch)
2704               (uri (string-append "http://lonelycactus.com/tarball/guile_gi-"
2705                                   version ".tar.gz"))
2706               (sha256
2707                (base32
2708                 "05xbwrk50h4f9fh8la8fk2wsxbnm0jcyb9phnpkkjq4sqkhkxlbj"))))
2709     (build-system gnu-build-system)
2710     (arguments
2711      `(#:configure-flags '("--with-gnu-filesystem-hierarchy")
2712        #:modules ((guix build gnu-build-system)
2713                   (guix build utils)
2714                   (ice-9 popen)
2715                   (ice-9 rdelim))
2716        #:phases
2717        (modify-phases %standard-phases
2718          (add-after 'unpack 'patch-references-to-extension
2719            (lambda* (#:key outputs #:allow-other-keys)
2720              (let ((effective (read-line
2721                                (open-pipe* OPEN_READ
2722                                            "guile" "-c"
2723                                            "(display (effective-version))"))))
2724                (substitute* '("module/gi.scm"
2725                               "module/gi/oop.scm"
2726                               "module/gi/documentation.scm"
2727                               "module/gi/types.scm"
2728                               "module/gi/repository.scm")
2729                  (("\\(load-extension \"libguile-gi\" \"(.*)\"\\)" m arg)
2730                   (format #f "~s"
2731                           `(load-extension
2732                             (format #f "~alibguile-gi"
2733                                     (if (getenv "GUILE_GI_UNINSTALLED")
2734                                         ""
2735                                         ,(format #f "~a/lib/guile/~a/"
2736                                                  (assoc-ref outputs "out")
2737                                                  effective)))
2738                             ,arg)))))
2739              (setenv "GUILE_GI_UNINSTALLED" "1")
2740              #t))
2741          (add-before 'check 'start-xorg-server
2742            (lambda* (#:key inputs #:allow-other-keys)
2743              ;; The init_check test requires a running X server.
2744              (system (format #f "~a/bin/Xvfb :1 &"
2745                              (assoc-ref inputs "xorg-server")))
2746              (setenv "DISPLAY" ":1")
2747              #t)))))
2748     (native-inputs
2749      `(("gettext" ,gettext-minimal)
2750        ("glib:bin" ,glib "bin") ; for glib-compile-resources
2751        ("libtool" ,libtool)
2752        ("pkg-config" ,pkg-config)
2753        ("xorg-server" ,xorg-server)))
2754     (propagated-inputs
2755      `(("glib" ,glib)
2756        ("gobject-introspection" ,gobject-introspection)
2757        ("gssettings-desktop-schemas" ,gsettings-desktop-schemas)
2758        ("gtk+" ,gtk+)
2759        ("guile-lib" ,guile-lib)
2760        ("webkitgtk" ,webkitgtk)))
2761     (inputs `(("guile" ,guile-3.0)))
2762     (home-page "https://github.com/spk121/guile-gi")
2763     (synopsis "GObject bindings for Guile")
2764     (description
2765      "Guile-GI is a library for Guile that allows using GObject-based
2766 libraries, such as GTK+3.  Its README comes with the disclaimer: This is
2767 pre-alpha code.")
2768     (license license:gpl3+)))
2769
2770 (define-public guile2.2-gi
2771   (package
2772     (inherit guile-gi)
2773     (name "guile2.2-gi")
2774     (native-inputs
2775      `(("guile" ,guile-2.2)
2776        ,@(package-native-inputs guile-gi)))))
2777
2778 (define-public guile3.0-gi
2779   (deprecated-package "guile3.0-gi" guile-gi))
2780
2781 (define-public guile-srfi-159
2782   (let ((commit "1bd98abda2ae4ef8f36761a167903e55c6bda7bb")
2783         (revision "0"))
2784     (package
2785       (name "guile-srfi-159")
2786       (version (git-version "0" revision commit))
2787       (home-page "https://bitbucket.org/bjoli/guile-srfi-159")
2788       (source (origin
2789                 (method hg-fetch)
2790                 (uri (hg-reference (changeset commit)
2791                                    (url home-page)))
2792                 (sha256
2793                  (base32
2794                   "1zw6cmcy7xdbfiz3nz9arqnn7l2daidaps6ixkcrc9b6k51fdv3p"))
2795                 (file-name (git-file-name name version))))
2796       (build-system guile-build-system)
2797       (arguments
2798        ;; The *-impl.scm files are actually included from module files; they
2799        ;; should not be compiled separately, but they must be installed.
2800        '(#:not-compiled-file-regexp "-impl\\.scm$"))
2801       (inputs
2802        `(("guile" ,guile-2.2)))
2803       (synopsis "Formatting combinators for Guile")
2804       (description
2805        "The @code{(srfi-159)} module and its sub-modules implement the
2806 formatting combinators specified by
2807 @uref{https://srfi.schemers.org/srfi-159/srfi-159.html, SRFI-159}.  These are
2808 more expressive and flexible than the traditional @code{format} procedure.")
2809       (license license:bsd-3))))
2810
2811 (define-public emacsy
2812   (package
2813     (name "emacsy")
2814     (version "0.4.1")
2815     (source (origin
2816               (method url-fetch)
2817               (uri (string-append
2818                     "https://download.savannah.nongnu.org/releases/"
2819                     name "/" name "-" version ".tar.gz"))
2820               (sha256
2821                (base32
2822                 "1cpb85dl1nibd34c2x2h7vfmjpkgh353p5b1w20v6cs6gmvgg4np"))))
2823     (build-system gnu-build-system)
2824     (native-inputs
2825      `(("autoconf" ,autoconf)
2826        ("automake" ,automake)
2827        ("bzip2" ,bzip2)
2828        ("guile" ,guile-2.2)
2829        ("gettext" ,gettext-minimal)
2830        ("libtool" ,libtool)
2831        ("perl" ,perl)
2832        ("pkg-config" ,pkg-config)
2833        ("texinfo" ,texinfo)
2834        ("texlive" ,(texlive-union (list texlive-generic-epsf)))))
2835     (inputs
2836      `(("dbus-glib" ,dbus-glib)
2837        ("guile" ,guile-2.2)
2838        ("guile-lib" ,guile-lib)
2839        ("guile-readline" ,guile-readline)
2840        ("freeglut" ,freeglut)
2841        ("webkitgtk" ,webkitgtk)))
2842     (propagated-inputs
2843      `(("glib-networking" ,glib-networking)
2844        ("gssettings-desktop-schemas" ,gsettings-desktop-schemas)))
2845     (arguments
2846      `(#:modules ((guix build gnu-build-system)
2847                   (guix build utils)
2848                   (ice-9 popen)
2849                   (ice-9 rdelim)
2850                   (ice-9 regex)
2851                   (ice-9 ftw)
2852                   (srfi srfi-26))
2853        #:phases
2854        (modify-phases %standard-phases
2855          (add-before 'configure 'setenv
2856            (lambda _
2857              (setenv "GUILE_AUTO_COMPILE" "0")
2858              #t))
2859          (add-after 'install 'wrap-binaries
2860            (lambda* (#:key inputs outputs #:allow-other-keys)
2861              (let* ((out (assoc-ref outputs "out"))
2862                     (effective (read-line
2863                                 (open-pipe* OPEN_READ
2864                                             "guile" "-c"
2865                                             "(display (effective-version))")))
2866                     (deps (map (cut assoc-ref inputs <>)
2867                                '("guile-lib" "guile-readline")))
2868                     (scm-path (map (cut string-append <> "/share/guile/site/"
2869                                         effective) `(,out ,@deps)))
2870                     (go-path (map (cut string-append <> "/lib/guile/" effective
2871                                        "/site-ccache/") `(,out ,@deps)))
2872                     (examples (filter (cut string-match "emacsy" <>)
2873                                       (scandir (string-append out "/bin/"))))
2874                     (progs (map (cut string-append out "/bin/" <>)
2875                                 examples)))
2876                (map (cut wrap-program <>
2877                          `("GUILE_LOAD_PATH" ":" prefix ,scm-path)
2878                          `("GUILE_LOAD_COMPILED_PATH" ":" prefix ,go-path))
2879                     progs)
2880                #t))))))
2881     (home-page "https://savannah.nongnu.org/projects/emacsy")
2882     (synopsis "Embeddable GNU Emacs-like library using Guile")
2883     (description
2884      "Emacsy is an embeddable Emacs-like library that uses GNU Guile
2885 as extension language.  Emacsy can give a C program an Emacsy feel with
2886 keymaps, minibuffer, recordable macros, history, tab completion, major
2887 and minor modes, etc., and can also be used as a pure Guile library.  It
2888 comes with a simple counter example using FreeGLUT and browser examples
2889 in C using Gtk+-3 and WebKitGtk.")
2890     (license license:gpl3+)))
2891
2892 (define-public emacsy-minimal
2893   (let ((commit "v0.4.1-28-gd459ca1"))
2894     (package
2895       (inherit emacsy)
2896       (name "emacsy-minimal")
2897       (version (string-drop commit 1))
2898       (source (origin
2899                 (method git-fetch)
2900                 (uri (git-reference
2901                       (url "https://git.savannah.gnu.org/git/emacsy.git")
2902                       (commit commit)))
2903                 (file-name (git-file-name name version))
2904                 (sha256
2905                  (base32
2906                   "1ps15w8cxj9kc18gmvys9jv9xa1qqa7m43ismv34l3cmhddrn0sr"))))
2907       (build-system gnu-build-system)
2908       (inputs
2909        `(("guile" ,guile-2.2)
2910          ("guile-lib" ,guile2.2-lib)
2911          ("guile-readline" ,guile2.2-readline)))
2912       (propagated-inputs '())
2913       (arguments
2914        `(#:configure-flags '("--without-examples")
2915          #:phases
2916          (modify-phases %standard-phases
2917          (add-before 'configure 'setenv
2918            (lambda _
2919              (setenv "GUILE_AUTO_COMPILE" "0")
2920              #t))))))))
2921
2922 (define-public guile-jpeg
2923   (let ((commit "6a1673578b297c2c1b28e44a76bd5c49e76a5046")
2924         (revision "0"))
2925     (package
2926       (name "guile-jpeg")
2927       (version (git-version "0.0" revision commit))
2928       (home-page "https://gitlab.com/wingo/guile-jpeg")
2929       (source (origin
2930                 (method git-fetch)
2931                 (uri (git-reference (url home-page)
2932                                     (commit commit)))
2933                 (sha256
2934                  (base32
2935                   "05z9m408w3h6aqb5k3r3qa7khir0k10rxwvsrzhkcq1hr5vbmr4m"))
2936                 (file-name (git-file-name name version))
2937                 (modules '((guix build utils)))
2938                 (snippet
2939                  '(begin
2940                     ;; Install .go files in the right place.
2941                     (substitute* "Makefile.am"
2942                       (("/ccache") "/site-ccache"))
2943                     #t))))
2944       (build-system gnu-build-system)
2945       (native-inputs
2946        `(("autoconf" ,autoconf)
2947          ("automake" ,automake)
2948          ("pkg-config" ,pkg-config)
2949          ("guile" ,guile-2.2)))
2950       (synopsis "JPEG file parsing library for Guile")
2951       (description
2952        "Guile-JPEG is a Scheme library to parse JPEG image files and to
2953 perform geometrical transforms on JPEG images.")
2954       (license license:gpl3+))))
2955
2956 (define-public nomad
2957   (package
2958     (name "nomad")
2959     (version "0.2.0-alpha")
2960     (source (origin
2961               (method git-fetch)
2962               (uri (git-reference
2963                     (url "https://git.savannah.gnu.org/git/nomad.git")
2964                     (commit version)))
2965               (file-name (git-file-name name version))
2966               (sha256
2967                (base32
2968                 "1z2z5x37v1qrk2vb8qlz2yj030iirzzd0maa9fjxzlqkrg6krbaj"))))
2969     (build-system gnu-build-system)
2970     (native-inputs
2971      `(("autoconf" ,autoconf)
2972        ("automake" ,automake)
2973        ("bash" ,bash)
2974        ("pkg-config" ,pkg-config)
2975        ("libtool" ,libtool)
2976        ("guile" ,guile-2.2)
2977        ("glib:bin" ,glib "bin")
2978        ("texinfo" ,texinfo)
2979        ("perl" ,perl)))
2980     (inputs
2981      `(("guile" ,guile-2.2)
2982        ("guile-lib" ,guile2.2-lib)
2983        ("guile-readline" ,guile2.2-readline)
2984        ("guile-gcrypt" ,guile2.2-gcrypt)
2985        ("gnutls" ,gnutls)
2986        ("shroud" ,shroud)
2987        ("emacsy" ,emacsy-minimal)
2988        ("glib" ,glib)
2989        ("dbus-glib" ,dbus-glib)
2990        ("gtk+" ,gtk+)
2991        ("gtk+:bin" ,gtk+ "bin")
2992        ("gtksourceview" ,gtksourceview)
2993        ("webkitgtk" ,webkitgtk)
2994        ("g-golf" ,g-golf)
2995        ("xorg-server" ,xorg-server)))
2996     (propagated-inputs
2997      `(("glib" ,glib)
2998        ("glib-networking" ,glib-networking)
2999        ("gstreamer" ,gstreamer)
3000        ("gst-plugins-base" ,gst-plugins-base)
3001        ("gst-plugins-good" ,gst-plugins-good)
3002        ("gst-plugins-bad" ,gst-plugins-bad)
3003        ("gst-plugins-ugly" ,gst-plugins-ugly)
3004        ("gtk+" ,gtk+)
3005        ("gtksourceview" ,gtksourceview)
3006        ("vte" ,vte)
3007        ("webkitgtk" ,webkitgtk)
3008        ("gsettings-desktop-schemas" ,gsettings-desktop-schemas)))
3009     (arguments
3010      `(#:modules ((guix build gnu-build-system)
3011                   (guix build utils)
3012                   (ice-9 popen)
3013                   (ice-9 rdelim)
3014                   (srfi srfi-26))
3015        #:phases
3016        (modify-phases %standard-phases
3017          (add-before 'check 'start-xorg-server
3018            (lambda* (#:key inputs #:allow-other-keys)
3019              ;; The test suite requires a running X server.
3020              (system (format #f "~a/bin/Xvfb :1 &"
3021                              (assoc-ref inputs "xorg-server")))
3022              (setenv "DISPLAY" ":1")
3023              #t))
3024          (add-after 'install 'wrap-binaries
3025            (lambda* (#:key inputs outputs #:allow-other-keys)
3026              (let* ((out (assoc-ref outputs "out"))
3027                     (gio-deps (map (cut assoc-ref inputs <>)
3028                                    '("glib-networking"
3029                                      "glib"
3030                                      "gstreamer"
3031                                      "gst-plugins-base"
3032                                      "gst-plugins-good"
3033                                      "gst-plugins-bad"
3034                                      "gst-plugins-ugly")))
3035                     (gio-mod-path (map (cut string-append <>
3036                                             "/lib/gio/modules")
3037                                        gio-deps))
3038                     (effective (read-line (open-pipe*
3039                                            OPEN_READ
3040                                            "guile" "-c"
3041                                            "(display (effective-version))")))
3042                     (deps (map (cut assoc-ref inputs <>)
3043                                '("emacsy" "guile-lib" "guile-readline"
3044                                  "g-golf" "shroud")))
3045                     (scm-path (map (cut string-append <>
3046                                         "/share/guile/site/" effective)
3047                                    `(,out ,@deps)))
3048                     (go-path (map (cut string-append <>
3049                                        "/lib/guile/" effective "/site-ccache")
3050                                   `(,out ,@deps)))
3051                     (progs (map (cut string-append out "/bin/" <>)
3052                                 '("nomad"))))
3053                (map (cut wrap-program <>
3054                          `("GIO_EXTRA_MODULES" ":" prefix ,gio-mod-path)
3055                          `("GUILE_LOAD_PATH" ":" prefix ,scm-path)
3056                          `("GUILE_LOAD_COMPILED_PATH" ":"
3057                            prefix ,go-path))
3058                     progs)
3059                #t))))))
3060     (native-search-paths
3061      (list (search-path-specification
3062             (variable "GI_TYPELIB_PATH")
3063             (separator ":")
3064             (files '("lib/girepository-1.0")))
3065            (search-path-specification
3066             (variable "NOMAD_WEB_EXTENSION_DIR")
3067             (separator ":")
3068             (files '("libexec/nomad")))))
3069     (home-page "https://savannah.nongnu.org/projects/nomad/")
3070     (synopsis "Extensible Web Browser in Guile Scheme")
3071     (description "Nomad is a Emacs-like web browser that consists of a modular
3072 feature-set, fully programmable in Guile Scheme.")
3073     (license license:gpl3+)))
3074
3075 (define-public guile-cv
3076   (package
3077     (name "guile-cv")
3078     (version "0.2.1")
3079     (source (origin
3080               (method url-fetch)
3081               (uri (string-append "mirror://gnu/guile-cv/guile-cv-"
3082                                   version ".tar.gz"))
3083               (sha256
3084                (base32
3085                 "0qdf0s2h1xj5lbhnc1pfw69i3zg08pqy2y6869b92ydfis8r82j9"))))
3086     (build-system gnu-build-system)
3087     (arguments
3088      `(#:phases
3089        (modify-phases %standard-phases
3090          (add-after 'unpack 'prepare-build
3091            (lambda* (#:key inputs outputs #:allow-other-keys)
3092              (substitute* "configure"
3093                (("SITEDIR=\"\\$datadir/guile-cv\"")
3094                 "SITEDIR=\"$datadir/guile/site/$GUILE_EFFECTIVE_VERSION\"")
3095                (("SITECCACHEDIR=\"\\$libdir/guile-cv/")
3096                 "SITECCACHEDIR=\"$libdir/"))
3097              (substitute* "cv/init.scm"
3098                (("\\(dynamic-link \"libvigra_c\"\\)")
3099                 (string-append "(dynamic-link \""
3100                                (assoc-ref inputs "vigra-c")
3101                                "/lib/libvigra_c\")"))
3102                (("\\(dynamic-link \"libguile-cv\"\\)")
3103                 (format #f "~s"
3104                         `(dynamic-link
3105                           (format #f "~alibguile-cv"
3106                                   (if (getenv "GUILE_CV_UNINSTALLED")
3107                                       ""
3108                                       ,(format #f "~a/lib/"
3109                                                (assoc-ref outputs "out"))))))))
3110              (setenv "GUILE_CV_UNINSTALLED" "1")
3111              ;; Only needed to satisfy the configure script.
3112              (setenv "LD_LIBRARY_PATH"
3113                      (string-append (assoc-ref inputs "vigra-c") "/lib"))
3114              #t)))))
3115     (inputs
3116      `(("vigra" ,vigra)
3117        ("vigra-c" ,vigra-c)
3118        ("guile" ,guile-2.2)))
3119     (native-inputs
3120      `(("texlive" ,(texlive-union (list texlive-booktabs
3121                                         texlive-lm
3122                                         texlive-siunitx
3123                                         texlive-standalone
3124                                         texlive-xcolor
3125                                         texlive-fonts-iwona)))
3126        ("pkg-config" ,pkg-config)))
3127     (propagated-inputs
3128      `(("guile-lib" ,guile-lib)))
3129     (home-page "https://www.gnu.org/software/guile-cv/")
3130     (synopsis "Computer vision library for Guile")
3131     (description "Guile-CV is a Computer Vision functional programming library
3132 for the Guile Scheme language.  It is based on Vigra (Vision with Generic
3133 Algorithms), a C++ image processing and analysis library.  Guile-CV contains
3134 bindings to Vigra C (a C wrapper to most of the Vigra functionality) and is
3135 enriched with pure Guile Scheme algorithms, all accessible through a nice,
3136 clean and easy to use high level API.")
3137     (license license:gpl3+)))
3138
3139 (define-public guile-ffi-fftw
3140   (let ((commit "294ad9e7491dcb40026d2fec9be2af05263be1c0")
3141         (revision "2"))
3142     (package
3143       (name "guile-ffi-fftw")
3144       (version (git-version "0" revision commit))
3145       (source (origin
3146                 (method git-fetch)
3147                 (uri (git-reference
3148                       (url "https://github.com/lloda/guile-ffi-fftw")
3149                       (commit commit)))
3150                 (file-name (git-file-name "guile-ffi-fftw" version))
3151                 (sha256
3152                  (base32
3153                   "08j40a5p6a8pgvhffmzb5rfdnrav2mksy3gfjkdqy93jfj1z5afg"))))
3154       (build-system guile-build-system)
3155       (arguments
3156        `(#:source-directory "mod"
3157          #:phases
3158          (modify-phases %standard-phases
3159            (add-after 'unpack 'prepare-build
3160              (lambda* (#:key inputs #:allow-other-keys)
3161                (substitute* "mod/ffi/fftw.scm"
3162                  (("\\(getenv \"GUILE_FFI_FFTW_LIBFFTW3_PATH\"\\)")
3163                   (format #f "\"~a/lib\"" (assoc-ref inputs "fftw"))))
3164                #t))
3165            (add-after 'build 'check
3166              (lambda _
3167                (invoke "guile" "-L" "mod"
3168                        "-s" "test/test-ffi-fftw.scm"))))))
3169       (inputs
3170        `(("fftw" ,fftw)
3171          ("guile" ,guile-2.2)))
3172       (home-page "https://github.com/lloda/guile-ffi-fftw/")
3173       (synopsis "Access FFTW through Guile's FFI")
3174       (description "This is a minimal set of Guile FFI bindings for the FFTW
3175 library's ‘guru interface’.  It provides two functions: @code{fftw-dft! rank
3176 sign in out} and @code{fftw-dft rank sign in}.  These bindings being minimal,
3177 there is no support for computing & reusing plans, or split r/i transforms, or
3178 anything other than straight complex DFTs.")
3179       (license license:lgpl3+))))
3180
3181 (define-public srfi-64-driver
3182   (package
3183     (name "srfi-64-driver")
3184     (version "0.1")
3185     (source (origin
3186               (method url-fetch)
3187               (uri (string-append "https://files.ngyro.com/srfi-64-driver/"
3188                                   "srfi-64-driver-" version ".tar.gz"))
3189               (sha256
3190                (base32
3191                 "188b6mb7sjjg0a8zldikinglf40ky8mg8rwh5768gjmch6gkk3ph"))))
3192     (build-system gnu-build-system)
3193     (arguments
3194      `(#:tests? #f
3195        #:phases
3196        (modify-phases %standard-phases
3197          (delete 'build))))
3198     (native-inputs
3199      `(("pkg-config" ,pkg-config)))
3200     (inputs
3201      `(("guile" ,guile-2.2)))
3202     (home-page "https://ngyro.com/software/srfi-64-driver.html")
3203     (synopsis "Automake test driver for SRFI 64 test suites")
3204     (description "This package provides an Automake test driver that can
3205 run SRFI 64 test suites.  It gives Automake insight into the individual
3206 tests being run, resulting clearer and more specific output.")
3207     (license license:gpl3+)))
3208
3209 (define-public guile-semver
3210   (package
3211     (name "guile-semver")
3212     (version "0.1.1")
3213     (source (origin
3214               (method url-fetch)
3215               (uri (string-append "https://files.ngyro.com/guile-semver/"
3216                                   "guile-semver-" version ".tar.gz"))
3217               (sha256
3218                (base32
3219                 "109p4n39ln44cxvwdccf9kgb96qx54makvd2ir521ssz6wchjyag"))))
3220     (build-system gnu-build-system)
3221     (native-inputs
3222      `(("pkg-config" ,pkg-config)))
3223     (inputs
3224      `(("guile" ,guile-2.2)))
3225     (home-page "https://ngyro.com/software/guile-semver.html")
3226     (synopsis "Semantic Versioning (SemVer) for Guile")
3227     (description "This Guile library provides tools for reading,
3228 comparing, and writing Semantic Versions.  It also includes ranges in
3229 the style of the Node Package Manager (NPM).")
3230     (license license:gpl3+)))
3231
3232 (define-public guile3.0-semver
3233   (package
3234     (inherit guile-semver)
3235     (name "guile3.0-semver")
3236     (inputs
3237      `(("guile" ,guile-3.0)))))
3238
3239 (define-public guile-hashing
3240   (package
3241     (name "guile-hashing")
3242     (version "1.2.0")
3243     (home-page "https://github.com/weinholt/hashing")
3244     (source (origin
3245               (method git-fetch)
3246               (uri (git-reference
3247                     (url home-page)
3248                     (commit (string-append "v" version))))
3249               (file-name (git-file-name name version))
3250               (sha256
3251                (base32
3252                 "1362d3lmpv7slmv1zmr9wy8panq9sjr9787gc2hagd646mpsfpkl"))))
3253     (build-system guile-build-system)
3254     (arguments
3255      `(#:modules ((guix build guile-build-system)
3256                   (guix build utils)
3257                   (srfi srfi-26)
3258                   (ice-9 ftw))
3259        #:implicit-inputs? #f                      ;needs nothing but Guile
3260        #:phases (modify-phases %standard-phases
3261                   (add-before 'build 'move-sls-files
3262                     (lambda _
3263                       ;; Move the source under hashing/ in order to match
3264                       ;; module names, and rename .sls files to .scm.
3265                       (define (target file)
3266                         (string-append "hashing/" file))
3267
3268                       (define (sls->scm sls)
3269                         (string-append (string-drop-right sls 4)
3270                                        ".scm"))
3271
3272                       (mkdir "hashing")
3273                       (for-each (lambda (file)
3274                                   (rename-file file (sls->scm file)))
3275                                 (find-files "." "\\.sls$"))
3276                       (for-each (lambda (file)
3277                                   (rename-file file (target file)))
3278                                 (scandir "." (cut string-suffix? ".scm" <>)))
3279                       (rename-file "private" "hashing/private")
3280                       #t)))))
3281     (native-inputs
3282      `(("guile" ,guile-3.0)))
3283     (synopsis "Cryprographic hash functions implemented in Scheme")
3284     (description
3285      "The @code{(hashing @dots{})} modules implement cryptographic hash
3286 functions in pure R6RS Scheme: CRC, HMAC, MD5, SHA-1, and SHA-2 (SHA-256,
3287 SHA-512).")
3288     (license license:expat)))
3289
3290 (define-public guile2.2-hashing
3291   (package
3292     (inherit guile-hashing)
3293     (name "guile2.2-hashing")
3294     (native-inputs
3295      `(("guile" ,guile-2.2)))))
3296
3297 (define-public guile3.0-hashing
3298   (deprecated-package "guile3.0-hashing" guile-hashing))
3299
3300 (define-public guile-packrat
3301   (package
3302     (name "guile-packrat")
3303     (version "0.1.1")
3304     (home-page "https://github.com/weinholt/packrat")
3305     (source (origin
3306               (method git-fetch)
3307               (uri (git-reference
3308                     (url home-page)
3309                     (commit (string-append "v" version))))
3310               (file-name (git-file-name name version))
3311               (sha256
3312                (base32
3313                 "1aga17164fkhbgllqc7ni6fk5zl8mkmgkl5zcsy67x7ngpyalbby"))))
3314     (build-system guile-build-system)
3315     (arguments
3316      `(#:implicit-inputs? #f                      ;needs nothing but Guile
3317        #:compile-flags '("--r6rs" "-Wunbound-variable" "-Warity-mismatch")
3318        #:not-compiled-file-regexp "/extensible\\.scm$"
3319        #:phases (modify-phases %standard-phases
3320                   (add-before 'build 'no-srfi-23
3321                     (lambda _
3322                       (substitute* "packrat.sls"
3323                         (("\\(srfi :23 error\\)")
3324                          (object->string '(only (guile) error))))
3325                       #t)))))
3326     (native-inputs
3327      `(("guile" ,guile-3.0)))
3328     (synopsis "Packrat parser library in R6RS Scheme")
3329     (description
3330      "This is an R6RS Scheme adaptation of the
3331 @uref{https://bford.info/packrat/, packrat parsing}.  Packrat parsing is a
3332 memoizing, backtracking, recursive-descent parsing technique that runs in time
3333 and space linear in the size of the input text.")
3334     (license license:expat)))
3335
3336 (define-public guile-ac-d-bus
3337   (package
3338     (name "guile-ac-d-bus")
3339     (version "1.0.0-beta.0")
3340     (home-page "https://gitlab.com/weinholt/ac-d-bus/")
3341     (source (origin
3342               (method git-fetch)
3343               (uri (git-reference
3344                     (url home-page)
3345                     (commit (string-append "v" version))))
3346               (file-name (git-file-name name version))
3347               (sha256
3348                (base32
3349                 "0rl809qimhgz6b0rixakb42r2l4g53jr09a2g0s1hxgab0blz0kb"))))
3350     (build-system guile-build-system)
3351     (arguments
3352      `(#:implicit-inputs? #f                      ;needs nothing but Guile
3353        #:compile-flags '("--r6rs" "-Wunbound-variable" "-Warity-mismatch")
3354        #:phases (modify-phases %standard-phases
3355                   (add-before 'build 'adjust-for-guile
3356                     (lambda _
3357                       ;; Adjust source file names for Guile.
3358                       (define (guile-sls->sls file)
3359                         (string-append (string-drop-right
3360                                         file (string-length ".guile.sls"))
3361                                        ".sls"))
3362
3363                       ;; Remove files targeting other implementations:
3364                       ;; *.mosh.sls, etc.
3365                       (for-each delete-file
3366                                 (find-files
3367                                  "compat"
3368                                  (lambda (file stat)
3369                                    (not (string-contains file ".guile.")))))
3370
3371                       ;; Rename *.guile.sls to *.sls so the ".guile" bit does
3372                       ;; not appear in .go file names.
3373                       (for-each (lambda (file)
3374                                   (rename-file file (guile-sls->sls file)))
3375                                 (find-files "compat" "\\.guile\\.sls"))
3376
3377                       ;; Move directories under d-bus/ to match module names.
3378                       (mkdir "d-bus")
3379                       (for-each (lambda (directory)
3380                                   (rename-file directory
3381                                                (string-append "d-bus/"
3382                                                               directory)))
3383                                 '("compat" "protocol"))
3384
3385                       #t)))))
3386     (native-inputs
3387      `(("guile" ,guile-3.0)))
3388     (propagated-inputs
3389      `(("guile-packrat" ,guile-packrat)))
3390     (synopsis "D-Bus protocol implementation in R6RS Scheme")
3391     (description
3392      "AC/D-Bus is an implementation of the D-Bus wire protocol.  D-Bus is an
3393 interprocess communication protocol popular on GNU/Linux systems to
3394 communicate with a variety of services.  Originally designed for desktop
3395 environments, it is now used by programs like VLC media player, BlueZ,
3396 NetworkManager, Pulseaudio, systemd (including logind and resolved), Polkit,
3397 gnome-keyring, and many more.")
3398     (license license:expat)))
3399
3400 (define-public guile-webutils
3401   (let ((commit "8541904f761066dc9c27b1153e9a838be9a55299")
3402         (revision "0"))
3403     (package
3404       (name "guile-webutils")
3405       (version (git-version "0.1" revision commit))
3406       (source (origin
3407                 (method git-fetch)
3408                 (uri (git-reference
3409                       (url "https://notabug.org/cwebber/guile-webutils.git")
3410                       (commit commit)))
3411                 (file-name (git-file-name name version))
3412                 (sha256
3413                  (base32
3414                   "1s9n3hbxd7lfpdi0x8wr0cfvlsf6g62ird9gbspxdrp5p05rbi64"))
3415                 (modules '((guix build utils)))
3416                 (snippet
3417                  '(begin
3418                     ;; Allow builds with Guile 3.0.
3419                     (substitute* "configure.ac"
3420                       (("2\\.2 2\\.0")
3421                        "3.0 2.2 2.0"))
3422                     #t))))
3423       (build-system gnu-build-system)
3424       (native-inputs
3425        `(("autoconf" ,autoconf)
3426          ("automake" ,automake)
3427          ("pkg-config" ,pkg-config)
3428          ("texinfo" ,texinfo)))
3429       (inputs
3430        `(("guile" ,guile-3.0)))
3431       (propagated-inputs
3432        `(("guile-irregex" ,guile-irregex)
3433          ("guile-gcrypt" ,guile-gcrypt)))
3434       (home-page "https://notabug.org/cwebber/guile-webutils")
3435       (synopsis "Web application authoring utilities for Guile")
3436       (description
3437        "This package provides tooling to write web applications in Guile, such
3438 as signed sessions, multipart message support, etc.")
3439       (license license:gpl3+))))
3440
3441 (define-public guile2.2-webutils
3442   (package
3443     (inherit guile-webutils)
3444     (name "guile2.2-webutils")
3445     (inputs
3446      `(("guile" ,guile-2.2)))
3447     (propagated-inputs
3448      `(("guile-irregex" ,guile2.2-irregex)
3449        ("guile-gcrypt" ,guile2.2-gcrypt)))))
3450
3451 (define-public guile-lens
3452   (let ((commit "14b15d07255f9d3f55d40a3b750d13c9ee3a154f")
3453         (revision "0"))
3454     (package
3455       (name "guile-lens")
3456       (version (git-version "0.1" revision commit))
3457       (source (origin
3458                 (method git-fetch)
3459                 (uri (git-reference
3460                       (url "https://gitlab.com/a-sassmannshausen/guile-lens.git")
3461                       (commit commit)))
3462                 (file-name (git-file-name name version))
3463                 (sha256
3464                  (base32
3465                   "0w8jzqyla56yrgj7acsgd4nspyir6zgp3vgxid4xmwhg9wmf1ida"))))
3466       (build-system gnu-build-system)
3467       (arguments
3468        '(#:phases
3469          (modify-phases %standard-phases
3470            (add-after 'unpack 'run-hall
3471              (lambda _
3472                (setenv "HOME" "/tmp")   ; for ~/.hall
3473                (invoke "hall" "dist" "-x"))))))
3474       (native-inputs
3475        `(("autoconf" ,autoconf)
3476          ("automake" ,automake)
3477          ("guile" ,guile-3.0)
3478          ("guile-hall" ,guile-hall)
3479          ("pkg-config" ,pkg-config)
3480          ("texinfo" ,texinfo)))
3481       (home-page "https://gitlab.com/a-sassmannshausen/guile-lens.git")
3482       (synopsis "Composable lenses for data structures in Guile")
3483       (description
3484        "Guile-Lens is a library implementing lenses in Guile.  The library is
3485 currently a re-implementation of the lentes library for Clojure.  Lenses
3486 provide composable procedures, which can be used to focus, apply functions
3487 over, or update a value in arbitrary data structures.")
3488       (license license:gpl3+))))
3489
3490 (define-public guile2.2-lens
3491   (package
3492     (inherit guile-lens)
3493     (name "guile2.2-lens")
3494     (native-inputs
3495      `(("guile" ,guile-2.2)
3496        ,@(alist-delete "guile" (package-native-inputs guile-lens))))))
3497
3498 (define-public guile-xapian
3499   (package
3500     (name "guile-xapian")
3501     (version "0.1.0")
3502     (home-page "https://git.systemreboot.net/guile-xapian")
3503     (source
3504      (origin
3505        (method git-fetch)
3506        (uri (git-reference (url home-page)
3507                            (commit (string-append "v" version))))
3508        (file-name (git-file-name name version))
3509        (sha256
3510         (base32
3511          "16k61f1jn3g48jaf3730b9l0izr5j933jzyri73nmcnjd09gm35i"))))
3512     (build-system gnu-build-system)
3513     (arguments
3514      '(#:make-flags '("GUILE_AUTO_COMPILE=0"))) ; to prevent guild warnings
3515     (inputs
3516      `(("guile" ,guile-3.0)
3517        ("xapian" ,xapian)
3518        ("zlib" ,zlib)))
3519     (native-inputs
3520      `(("autoconf" ,autoconf)
3521        ("autoconf-archive" ,autoconf-archive)
3522        ("automake" ,automake)
3523        ("libtool" ,libtool)
3524        ("pkg-config" ,pkg-config)
3525        ("swig" ,swig)))
3526     (synopsis "Guile bindings for Xapian")
3527     (description "@code{guile-xapian} provides Guile bindings for Xapian, a
3528 search engine library.  Xapian is a highly adaptable toolkit which allows
3529 developers to easily add advanced indexing and search facilities to their own
3530 applications.  It has built-in support for several families of weighting
3531 models and also supports a rich set of boolean query operators.")
3532     (license license:gpl2+)))
3533
3534 (define-public guile2.2-xapian
3535   (package
3536     (inherit guile-xapian)
3537     (name "guile2.2-xapian")
3538     (inputs
3539      `(("guile" ,guile-2.2)
3540        ,@(alist-delete "guile" (package-inputs guile-xapian))))))
3541
3542 (define-public guile3.0-xapian
3543   (deprecated-package "guile3.0-xapian" guile-xapian))
3544
3545 (define-public guile-torrent
3546   (package
3547     (name "guile-torrent")
3548     (version "0.1.3")
3549     (source (origin (method git-fetch)
3550                     (uri (git-reference
3551                           (url
3552                            "https://github.com/o-nly/torrent.git")
3553                           (commit version)))
3554                     (file-name (git-file-name name version))
3555                     (sha256
3556                      (base32
3557                       "1yiagi55ncq1x7s9n7salzywjm4l96y3n7y3s47a9anvz87mrmim"))))
3558     (build-system gnu-build-system)
3559     (native-inputs
3560      `(("autoconf" ,autoconf)
3561        ("automake" ,automake)
3562        ("guile" ,guile-2.2)
3563        ("texinfo" ,texinfo)
3564        ("perl" ,perl)
3565        ("pkg-config" ,pkg-config)))
3566     (propagated-inputs
3567      `(("guile-gcrypt" ,guile-gcrypt)))
3568     (home-page "https://github.com/o-nly/torrent")
3569     (synopsis "Torrent library for GNU Guile")
3570     (description "This package provides facilities for working with
3571 @code{.torrent} or metainfo files.  Implements a bencode reader and writer
3572 according to Bitorrent BEP003.")
3573     (license license:gpl3+)))
3574
3575 (define-public guile-irc
3576   (let ((commit "375d3bde9c6ae7ccc9d7cc65817966b6fda8f26a")
3577         (revision "0"))
3578     (package
3579       (name "guile-irc")
3580       (version (git-version "0.3.0" revision commit))
3581       (source (origin
3582                 (method git-fetch)
3583                 (uri (git-reference
3584                       (url "https://github.com/rekado/guile-irc")
3585                       (commit commit)))
3586                 (file-name (git-file-name name version))
3587                 (sha256
3588                  (base32
3589                   "113lcckcywrz9060w1c3fnvr8d7crdsjgsv4h47hgmr1slgadl4y"))))
3590       (build-system gnu-build-system)
3591       (arguments
3592        `(#:configure-flags '("--enable-gnutls=yes")))
3593       (native-inputs
3594        `(("autoconf" ,autoconf)
3595          ("automake" ,automake)
3596          ("texinfo" ,texinfo)))
3597       (inputs
3598        `(("gnutls" ,gnutls)
3599          ("guile" ,guile-3.0)))
3600       (home-page "https://github.com/rekado/guile-irc")
3601       (synopsis "IRC library for Guile")
3602       (description "This package provides a Guile library for @dfn{Internet
3603 Relay Chat} (IRC).")
3604       ;; Some file headers incorrectly say LGPLv2+.
3605       (license license:lgpl2.1+))))
3606
3607 (define-public guile-websocket
3608   (let ((commit "c854e0f84a40d972cbd532bbb89c97ca0126a7cf"))
3609     (package
3610       (name "guile-websocket")
3611       (version "0.1")
3612       (source
3613        (origin
3614          (method git-fetch)
3615          (uri (git-reference
3616                (url "git://dthompson.us/guile-websocket.git")
3617                (commit commit)))
3618          (file-name (git-file-name name version))
3619          (sha256
3620           (base32
3621            "1hymvsfrmq9qxr5cxnsgdz7y757yp1cpsgxmdp3f5wxxxpqgsmzx"))))
3622       (build-system gnu-build-system)
3623       (arguments
3624        '(#:make-flags
3625          '("GUILE_AUTO_COMPILE=0")
3626          #:phases
3627          (modify-phases %standard-phases
3628            ;; The package was developed for Guile 2.0 and has this version
3629            ;; hardcoded in the configure.ac and Makefile.am files. Substitute
3630            ;; 3.0 instead so it can support Guile 3.0.
3631            (add-after 'unpack 'update-guile-version
3632              (lambda _
3633                (substitute* "configure.ac"
3634                  (("2.0.9") "3.0.0"))
3635                (substitute* "Makefile.am"
3636                  (("2.0") "3.0")
3637
3638                  ;; Install .go files where they belong.
3639                  (("/ccache") "/site-ccache"))
3640                #t)))))
3641       (native-inputs
3642        `(("autoconf" ,autoconf)
3643          ("automake" ,automake)))
3644       (inputs
3645        `(("guile" ,guile-3.0)))
3646       (synopsis "Websocket server/client for Guile")
3647       (description "Guile-websocket provides an implementation of the
3648 WebSocket protocol as defined by RFC 6455.")
3649       (home-page "https://git.dthompson.us/guile-websocket.git")
3650       (license license:lgpl3+))))
3651
3652 (define-public guile3.0-websocket
3653   (deprecated-package "guile3.0-websocket" guile-websocket))
3654
3655 (define-public guile-rdf
3656   (package
3657     (name "guile-rdf")
3658     (version "1.0")
3659     (source
3660       (origin
3661         (method git-fetch)
3662         (uri (git-reference
3663                (url "https://framagit.org/tyreunom/guile-rdf")
3664                (commit version)))
3665         (file-name (git-file-name name version))
3666         (sha256
3667          (base32
3668           "0dwn3app1fscbpmpgvjs5jy1y0gwy3j5gdx8br79af6a88zjlnqf"))))
3669     (build-system gnu-build-system)
3670     (arguments
3671      `(#:tests? #f)); tests require network
3672     (inputs
3673      `(("guile" ,guile-3.0)))
3674     (native-inputs
3675      `(("automake" ,automake)
3676        ("autoconf" ,autoconf)
3677        ("pkg-config" ,pkg-config)
3678        ("texinfo" ,texinfo)))
3679     (home-page "https://framagit.org/tyreunom/guile-rdf")
3680     (synopsis "Guile implementation of the RDF abstract and concrete syntaxes")
3681     (description "Guile RDF is an implementation of the RDF (Resource Description
3682 Framework) format defined by the W3C for GNU Guile.  RDF structures include
3683 triples (facts with a subject, a predicate and an object), graphs which are
3684 sets of triples, and datasets, which are collections of graphs.
3685
3686 RDF specifications include the specification of concrete syntaxes and of
3687 operations on graphs.  This library implements some basic functionalities,
3688 such as parsing and producing turtle and nquads syntax, as well as
3689 manipulating graphs and datasets.")
3690     (license license:gpl3+)))
3691
3692 (define-public guile-jsonld
3693   (package
3694     (name "guile-jsonld")
3695     (version "1.0.1")
3696     (source
3697       (origin
3698         (method git-fetch)
3699         (uri (git-reference
3700                (url "https://framagit.org/tyreunom/guile-jsonld")
3701                (commit version)))
3702         (file-name (git-file-name name version))
3703         (sha256
3704          (base32
3705           "0zfn3nwlz6xzip1j8xbj768dc299r037cfc81bk6kwl9xhzkjbrg"))))
3706     (build-system gnu-build-system)
3707     (arguments
3708      `(#:tests? #f)); require network
3709     (propagated-inputs
3710      `(("guile-gnutls" ,gnutls)
3711        ("guile-json" ,guile-json-3)
3712        ("guile-rdf" ,guile-rdf)))
3713     (inputs
3714      `(("guile" ,guile-3.0)))
3715     (native-inputs
3716      `(("automake" ,automake)
3717        ("autoconf" ,autoconf)
3718        ("pkg-config" ,pkg-config)
3719        ("texinfo" ,texinfo)))
3720     (home-page "https://framagit.org/tyreunom/guile-jsonld")
3721     (synopsis "Guile implementation of the JsonLD API specification")
3722     (description "Guile JsonLD is an implementation of the JsonLD (Json for
3723 Linked Data) API defined by the W3C for GNU Guile.  It allows you to express links
3724 between data, in a way that is very similar to WikiData or RDF for instance.
3725 An object can have relations (in the form of an IRI) that relates it to one or
3726 more objects or strings, represented by a Json object or an IRI.")
3727     (license license:gpl3+)))