gnu/packages/guile-xyz.scm

   1 ;;; GNU Guix --- Functional package management for GNU
   2 ;;; Copyright © 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019 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 Ricardo Wurmus <rekado@elephly.net>
   7 ;;; Copyright © 2016 Erik Edrosa <erik.edrosa@gmail.com>
   8 ;;; Copyright © 2016 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 Mathieu Othacehe <m.othacehe@gmail.com>
  16 ;;; Copyright © 2017 Theodoros Foradis <theodoros@foradis.org>
  17 ;;; Copyright © 2017 ng0 <ng0@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 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 ;;;
  25 ;;; This file is part of GNU Guix.
  26 ;;;
  27 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  28 ;;; under the terms of the GNU General Public License as published by
  29 ;;; the Free Software Foundation; either version 3 of the License, or (at
  30 ;;; your option) any later version.
  31 ;;;
  32 ;;; GNU Guix is distributed in the hope that it will be useful, but
  33 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  34 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  35 ;;; GNU General Public License for more details.
  36 ;;;
  37 ;;; You should have received a copy of the GNU General Public License
  38 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  39
  40 (define-module (gnu packages guile-xyz)
  41   #:use-module ((guix licenses) #:prefix license:)
  42   #:use-module (gnu packages)
  43   #:use-module (gnu packages aspell)
  44   #:use-module (gnu packages autotools)
  45   #:use-module (gnu packages base)
  46   #:use-module (gnu packages bash)
  47   #:use-module (gnu packages compression)
  48   #:use-module (gnu packages databases)
  49   #:use-module (gnu packages disk)
  50   #:use-module (gnu packages ed)
  51   #:use-module (gnu packages emacs)
  52   #:use-module (gnu packages emacs-xyz)
  53   #:use-module (gnu packages gawk)
  54   #:use-module (gnu packages gettext)
  55   #:use-module (gnu packages gl)
  56   #:use-module (gnu packages glib)
  57   #:use-module (gnu packages gnome)
  58   #:use-module (gnu packages gperf)
  59   #:use-module (gnu packages gtk)
  60   #:use-module (gnu packages guile)
  61   #:use-module (gnu packages hurd)
  62   #:use-module (gnu packages image)
  63   #:use-module (gnu packages libffi)
  64   #:use-module (gnu packages libunistring)
  65   #:use-module (gnu packages linux)
  66   #:use-module (gnu packages man)
  67   #:use-module (gnu packages maths)
  68   #:use-module (gnu packages multiprecision)
  69   #:use-module (gnu packages ncurses)
  70   #:use-module (gnu packages networking)
  71   #:use-module (gnu packages perl)
  72   #:use-module (gnu packages pkg-config)
  73   #:use-module (gnu packages python)
  74   #:use-module (gnu packages readline)
  75   #:use-module (gnu packages sdl)
  76   #:use-module (gnu packages slang)
  77   #:use-module (gnu packages sqlite)
  78   #:use-module (gnu packages texinfo)
  79   #:use-module (gnu packages tls)
  80   #:use-module (gnu packages version-control)
  81   #:use-module (gnu packages webkit)
  82   #:use-module (gnu packages xdisorg)
  83   #:use-module (gnu packages xorg)
  84   #:use-module (guix packages)
  85   #:use-module (guix download)
  86   #:use-module (guix git-download)
  87   #:use-module (guix hg-download)
  88   #:use-module (guix build-system gnu)
  89   #:use-module (guix build-system guile)
  90   #:use-module (guix utils)
  91   #:use-module (ice-9 match)
  92   #:use-module ((srfi srfi-1) #:select (alist-delete)))
  93
  94 (define-public artanis
  95   (let ((release "0.3.1")
  96         (revision 0))
  97     (package
  98       (name "artanis")
  99       (version (if (zero? revision)
 100                    release
 101                    (string-append release "-"
 102                                   (number->string revision))))
 103       (source (origin
 104                 (method url-fetch)
 105                 (uri (string-append "mirror://gnu/artanis/artanis-"
 106                                     release ".tar.gz"))
 107                 (file-name (string-append name "-" version ".tar.gz"))
 108                 (sha256
 109                  (base32
 110                   "0hqr5m3mb558bdhkc2sadmd9cbrhp3y525wx7cwirgy6i0zmay68"))
 111                 (modules '((guix build utils)))
 112                 (snippet
 113                  '(begin
 114                     ;; Unbundle guile-redis and guile-json
 115                     (delete-file-recursively "artanis/third-party/json.scm")
 116                     (delete-file-recursively "artanis/third-party/json")
 117                     (delete-file-recursively "artanis/third-party/redis.scm")
 118                     (delete-file-recursively "artanis/third-party/redis")
 119                     (substitute* '("artanis/artanis.scm"
 120                                    "artanis/lpc.scm"
 121                                    "artanis/oht.scm")
 122                       (("(#:use-module \\()artanis third-party (json\\))" _
 123                         use-module json)
 124                        (string-append use-module json)))
 125                     (substitute* '("artanis/lpc.scm"
 126                                    "artanis/session.scm")
 127                       (("(#:use-module \\()artanis third-party (redis\\))" _
 128                         use-module redis)
 129                        (string-append use-module redis)))
 130                     (substitute* "artanis/oht.scm"
 131                       (("([[:punct:][:space:]]+)(->json-string)([[:punct:][:space:]]+)"
 132                         _ pre json-string post)
 133                        (string-append pre
 134                                       "scm" json-string
 135                                       post)))
 136                     (substitute* "artanis/artanis.scm"
 137                       (("[[:punct:][:space:]]+->json-string[[:punct:][:space:]]+")
 138                        ""))
 139                     #t))))
 140       (build-system gnu-build-system)
 141       ;; FIXME the bundled csv contains one more exported procedure
 142       ;; (sxml->csv-string) than guile-csv. The author is maintainer of both
 143       ;; projects.
 144       ;; TODO: Add guile-dbi and guile-dbd optional dependencies.
 145       (inputs `(("guile" ,guile-2.2)
 146                 ("guile-json" ,guile-json)
 147                 ("guile-redis" ,guile-redis)))
 148       (native-inputs `(("bash"       ,bash)         ;for the `source' builtin
 149                        ("pkgconfig"  ,pkg-config)
 150                        ("util-linux" ,util-linux))) ;for the `script' command
 151       (arguments
 152        '(#:make-flags
 153          ;; TODO: The documentation must be built with the `docs' target.
 154          (let* ((out (assoc-ref %outputs "out"))
 155                 (scm (string-append out "/share/guile/site/2.2"))
 156                 (go  (string-append out "/lib/guile/2.2/site-ccache")))
 157            ;; Don't use (%site-dir) for site paths.
 158            (list (string-append "MOD_PATH=" scm)
 159                  (string-append "MOD_COMPILED_PATH=" go)))
 160          #:test-target "test"
 161          #:phases
 162          (modify-phases %standard-phases
 163            (add-after 'unpack 'patch-site-dir
 164              (lambda* (#:key outputs #:allow-other-keys)
 165                (substitute* "artanis/commands/help.scm"
 166                  (("\\(%site-dir\\)")
 167                   (string-append "\""
 168                                  (assoc-ref outputs "out")
 169                                  "/share/guile/site/2.2\"")))))
 170            (add-before 'install 'substitute-root-dir
 171              (lambda* (#:key outputs #:allow-other-keys)
 172                (let ((out  (assoc-ref outputs "out")))
 173                  (substitute* "Makefile"   ;ignore the execution of bash.bashrc
 174                    ((" /etc/bash.bashrc") " /dev/null"))
 175                  (substitute* "Makefile"   ;set the root of config files to OUT
 176                    ((" /etc") (string-append " " out "/etc")))
 177                  (mkdir-p (string-append out "/bin")) ;for the `art' executable
 178                  #t)))
 179            (add-after 'install 'wrap-art
 180              (lambda* (#:key inputs outputs #:allow-other-keys)
 181                (let* ((out (assoc-ref outputs "out"))
 182                       (bin (string-append out "/bin"))
 183                       (scm (string-append out "/share/guile/site/2.2"))
 184                       (go  (string-append out "/lib/guile/2.2/site-ccache")))
 185                  (wrap-program (string-append bin "/art")
 186                    `("GUILE_LOAD_PATH" ":" prefix
 187                      (,scm ,(getenv "GUILE_LOAD_PATH")))
 188                    `("GUILE_LOAD_COMPILED_PATH" ":" prefix
 189                      (,go ,(getenv "GUILE_LOAD_COMPILED_PATH"))))
 190                  #t))))))
 191       (synopsis "Web application framework written in Guile")
 192       (description "GNU Artanis is a web application framework written in Guile
 193 Scheme.  A web application framework (WAF) is a software framework that is
 194 designed to support the development of dynamic websites, web applications, web
 195 services and web resources.  The framework aims to alleviate the overhead
 196 associated with common activities performed in web development.  Artanis
 197 provides several tools for web development: database access, templating
 198 frameworks, session management, URL-remapping for RESTful, page caching, and
 199 more.")
 200       (home-page "https://www.gnu.org/software/artanis/")
 201       (license (list license:gpl3+ license:lgpl3+))))) ;dual license
 202
 203 ;; There has not been any release yet.
 204 (define-public guildhall
 205   (let ((commit "2fe2cc539f4b811bbcd69e58738db03eb5a2b778")
 206         (revision "1"))
 207     (package
 208       (name "guildhall")
 209       (version (string-append "0-" revision "." (string-take commit 9)))
 210       (source (origin
 211                 (method git-fetch)
 212                 (uri (git-reference
 213                       (url "https://github.com/ijp/guildhall.git")
 214                       (commit commit)))
 215                 (file-name (string-append name "-" version "-checkout"))
 216                 (sha256
 217                  (base32
 218                   "115bym7bg66h3gs399yb2vkzc2ygriaqsn4zbrg8f054mgy8wzn1"))))
 219       (build-system gnu-build-system)
 220       (arguments
 221        `(#:phases
 222          (modify-phases %standard-phases
 223            ;; Tests fail without this fix because they try to load the bash
 224            ;; executable as a Scheme file.  See bug report at
 225            ;; https://github.com/ijp/guildhall/issues/22
 226            (add-after 'unpack 'fix-bug-22
 227              (lambda _
 228                (substitute* "Makefile.am"
 229                  (("TESTS_ENVIRONMENT=.*")
 230                   "AM_TESTS_ENVIRONMENT=srcdir=$(abs_top_srcdir)/tests/
 231 TEST_EXTENSIONS = .scm
 232 SCM_LOG_COMPILER= $(top_builddir)/env $(GUILE)
 233 AM_SCM_LOG_FLAGS =  --no-auto-compile -s")
 234                  ;; FIXME: one of the database tests fails for unknown
 235                  ;; reasons.  It does not fail when run outside of Guix.
 236                  (("tests/database.scm") ""))
 237                #t)))))
 238       (inputs
 239        `(("guile" ,guile-2.0)))
 240       (native-inputs
 241        `(("zip" ,zip) ; for tests
 242          ("autoconf" ,autoconf)
 243          ("automake" ,automake)
 244          ("texinfo" ,texinfo)))
 245       (synopsis "Package manager for Guile")
 246       (description
 247        "Guildhall is a package manager written for Guile Scheme.  A guild is
 248 an association of independent craftspeople.  A guildhall is where they meet.
 249 This Guildhall aims to make a virtual space for Guile wizards and journeyfolk
 250 to share code.
 251
 252 On a practical level, Guildhall lets you share Scheme modules and programs
 253 over the internet, and install code that has been shared by others.  Guildhall
 254 can handle dependencies, so when a program requires several libraries, and
 255 each of those has further dependencies, all of the prerequisites for the
 256 program can be installed in one go.")
 257       (home-page "https://github.com/ijp/guildhall")
 258       (license license:gpl3+))))
 259
 260 (define-public guile-aspell
 261   (package
 262     (name "guile-aspell")
 263     (version "0.4")
 264     (source (origin
 265               (method url-fetch)
 266               (uri (string-append
 267                     "http://lonelycactus.com/tarball/guile_aspell-"
 268                     version ".tar.gz"))
 269               (sha256
 270                (base32
 271                 "0vpk5xj9m9qc702z3khmkwhgpb949qbsyz8kw2qycda6qnxk0077"))))
 272     (build-system gnu-build-system)
 273     (arguments
 274      '(#:phases (modify-phases %standard-phases
 275                   (add-before 'configure 'set-guilesitedir
 276                     (lambda _
 277                       (substitute* "Makefile.in"
 278                         (("^guilesitedir =.*$")
 279                          "guilesitedir = \
 280 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 281                       #t))
 282                   (add-before 'build 'set-libaspell-file-name
 283                     (lambda* (#:key inputs #:allow-other-keys)
 284                       (let ((aspell (assoc-ref inputs "aspell")))
 285                         (substitute* "aspell.scm"
 286                           (("\"libaspell\\.so\"")
 287                            (string-append "\"" aspell
 288                                           "/lib/libaspell\"")))
 289                         #t))))))
 290     (native-inputs `(("pkg-config" ,pkg-config)))
 291     (inputs `(("guile" ,guile-2.2)
 292               ("aspell" ,aspell)))
 293     (home-page "https://github.com/spk121/guile-aspell")
 294     (synopsis "Spell-checking from Guile")
 295     (description
 296      "guile-aspell is a Guile Scheme library for comparing a string against a
 297 dictionary and suggesting spelling corrections.")
 298     (license license:gpl3+)))
 299
 300 (define-public guile-bash
 301   ;; This project is currently retired.  It was initially announced here:
 302   ;; <https://lists.gnu.org/archive/html/guile-user/2015-02/msg00003.html>.
 303   (let ((commit "1eabc563ca5692b3e08d84f1f0e6fd2283284469")
 304         (revision "0"))
 305     (package
 306       (name "guile-bash")
 307       (version (string-append "0.1.6-" revision "." (string-take commit 7)))
 308       (home-page
 309        "https://anonscm.debian.org/cgit/users/kaction-guest/retired/dev.guile-bash.git")
 310       (source (origin
 311                 (method git-fetch)
 312                 (uri (git-reference
 313                       (commit commit)
 314                       (url home-page)))
 315                 (sha256
 316                  (base32
 317                   "097vny990wp2qpjij6a5a5gwc6fxzg5wk56inhy18iki5v6pif1p"))
 318                 (file-name (string-append name "-" version "-checkout"))))
 319       (build-system gnu-build-system)
 320       (arguments
 321        '(#:configure-flags
 322          ;; Add -I to match 'bash.pc' of Bash 4.4.
 323          (list (string-append "CPPFLAGS=-I"
 324                               (assoc-ref %build-inputs "bash:include")
 325                               "/include/bash/include")
 326
 327                ;; The '.a' file is useless.
 328                "--disable-static"
 329
 330                ;; Install 'lib/bash' as Bash 4.4 expects.
 331                (string-append "--libdir=" (assoc-ref %outputs "out")
 332                               "/lib/bash"))))
 333       (native-inputs `(("pkg-config" ,pkg-config)
 334                        ("autoconf" ,autoconf-wrapper)
 335                        ("automake" ,automake)
 336                        ("libtool" ,libtool)
 337                        ;; Gettext brings 'AC_LIB_LINKFLAGS_FROM_LIBS'.
 338                        ("gettext" ,gettext-minimal)
 339
 340                        ;; Bash with loadable module support, for the test
 341                        ;; suite.
 342                        ("bash-full" ,bash)))
 343       (inputs `(("guile" ,guile-2.0)
 344                 ("bash:include" ,bash "include")))
 345       (synopsis "Extend Bash using Guile")
 346       (description
 347        "Guile-Bash provides a shared library and set of Guile modules,
 348 allowing you to extend Bash in Scheme.  Scheme interfaces allow you to access
 349 the following aspects of Bash:
 350
 351 @itemize
 352 @item aliases;
 353 @item setting and getting Bash variables;
 354 @item creating dynamic variables;
 355 @item creating Bash functions with a Scheme implementation;
 356 @item reader macro for output capturing;
 357 @item reader macro for evaluating raw Bash commands.
 358 @end itemize
 359
 360 To enable it, run:
 361
 362 @example
 363 enable -f ~/.guix-profile/lib/bash/libguile-bash.so scm
 364 @end example
 365
 366 and then run @command{scm example.scm}.")
 367       (license license:gpl3+))))
 368
 369 (define-public guile-8sync
 370   (package
 371     (name "guile-8sync")
 372     (version "0.4.2")
 373     (source (origin
 374               (method url-fetch)
 375               (uri (string-append "mirror://gnu/8sync/8sync-" version
 376                                   ".tar.gz"))
 377               (sha256
 378                (base32
 379                 "031wm13srak3wsnll7j2mbbi29g1pcm4swdb71ds9yn567pn20qw"))))
 380     (build-system gnu-build-system)
 381     (native-inputs `(("autoconf" ,autoconf)
 382                      ("automake" ,automake)
 383                      ("guile" ,guile-2.2)
 384                      ("pkg-config" ,pkg-config)
 385                      ("texinfo" ,texinfo)))
 386     (arguments
 387      `(#:phases (modify-phases %standard-phases
 388                   (add-before 'configure 'setenv
 389                     (lambda _
 390                       ;; quiet warnings
 391                       (setenv "GUILE_AUTO_COMPILE" "0")
 392                       #t)))))
 393     (home-page "https://gnu.org/s/8sync/")
 394     (synopsis "Asynchronous actor model library for Guile")
 395     (description
 396      "GNU 8sync (pronounced \"eight-sync\") is an asynchronous programming
 397 library for GNU Guile based on the actor model.
 398
 399 Note that 8sync is only available for Guile 2.2.")
 400     (license license:lgpl3+)))
 401
 402 (define-public guile-daemon
 403   (package
 404     (name "guile-daemon")
 405     (version "0.1.2")
 406     (source (origin
 407               (method url-fetch)
 408               (uri (string-append "https://github.com/alezost/" name
 409                                   "/releases/download/v" version
 410                                   "/" name "-" version ".tar.gz"))
 411               (sha256
 412                (base32
 413                 "0hh6gq6b6phpxm0b1dkxyzj3f4sxdf7dji63609lzypa5v1ad2gv"))))
 414     (build-system gnu-build-system)
 415     (native-inputs
 416      `(("pkg-config" ,pkg-config)))
 417     (inputs
 418      `(("guile" ,guile-2.2)))
 419     (home-page "https://github.com/alezost/guile-daemon")
 420     (synopsis "Evaluate code in a running Guile process")
 421     (description
 422      "Guile-Daemon is a small Guile program that loads your initial
 423 configuration file, and then reads and evaluates Guile expressions that
 424 you send to a FIFO file.")
 425     (license license:gpl3+)))
 426
 427 (define-public guile-dsv
 428   (package
 429     (name "guile-dsv")
 430     (version "0.2.1")
 431     (source (origin
 432               (method git-fetch)
 433               (uri (git-reference
 434                     (url "https://github.com/artyom-poptsov/guile-dsv")
 435                     (commit "bdc5267d007478abc20ea96d7c459b7dd9560b3d")))
 436               (file-name (string-append name "-" version "-checkout"))
 437               (sha256
 438                (base32
 439                 "1irw6mz8998nwyhzrw9g94jcz60b9zljgqfmipaz1ybn8579qjx0"))))
 440     (build-system gnu-build-system)
 441     (native-inputs
 442      `(("autoconf" ,autoconf)
 443        ("automake" ,automake)
 444        ("pkg-config" ,pkg-config)
 445        ("texinfo" ,texinfo)))
 446     (inputs `(("guile" ,guile-2.2)))
 447     (propagated-inputs `(("guile-lib" ,guile-lib)))
 448     (arguments
 449      '(#:phases (modify-phases %standard-phases
 450                   (add-before 'configure 'set-guilesitedir
 451                     (lambda _
 452                       (substitute* "Makefile.in"
 453                         (("^guilesitedir =.*$")
 454                          "guilesitedir = \
 455 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 456                       (substitute* "modules/Makefile.in"
 457                         (("^guilesitedir =.*$")
 458                          "guilesitedir = \
 459 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 460                       (substitute* "modules/dsv/Makefile.in"
 461                         (("^guilesitedir =.*$")
 462                          "guilesitedir = \
 463 $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
 464                       #t)))))
 465     (home-page "https://github.com/artyom-poptsov/guile-dsv")
 466     (synopsis "DSV module for Guile")
 467     (description
 468      "Guile-DSV is a GNU Guile module for working with the
 469 delimiter-separated values (DSV) data format.  Guile-DSV supports the
 470 Unix-style DSV format and RFC 4180 format.")
 471     (license license:gpl3+)))
 472
 473 (define-public guile-fibers
 474   (package
 475     (name "guile-fibers")
 476     (version "1.0.0")
 477     (source (origin
 478               (method url-fetch)
 479               (uri (string-append "https://wingolog.org/pub/fibers/fibers-"
 480                                   version ".tar.gz"))
 481               (sha256
 482                (base32
 483                 "0vjkg72ghgdgphzbjz9ig8al8271rq8974viknb2r1rg4lz92ld0"))))
 484     (build-system gnu-build-system)
 485     (arguments
 486      '(#:phases (modify-phases %standard-phases
 487                   (add-after 'install 'mode-guile-objects
 488                     (lambda* (#:key outputs #:allow-other-keys)
 489                       ;; .go files are installed to "lib/guile/X.Y/cache".
 490                       ;; This phase moves them to "…/site-ccache".
 491                       (let* ((out (assoc-ref outputs "out"))
 492                              (lib (string-append out "/lib/guile"))
 493                              (old (car (find-files lib "^ccache$"
 494                                                    #:directories? #t)))
 495                              (new (string-append (dirname old)
 496                                                  "/site-ccache")))
 497                         (rename-file old new)
 498                         #t))))))
 499     (native-inputs
 500      `(("texinfo" ,texinfo)
 501        ("pkg-config" ,pkg-config)))
 502     (inputs
 503      `(("guile" ,guile-2.2)))
 504     (synopsis "Lightweight concurrency facility for Guile")
 505     (description
 506      "Fibers is a Guile library that implements a a lightweight concurrency
 507 facility, inspired by systems like Concurrent ML, Go, and Erlang.  A fiber is
 508 like a \"goroutine\" from the Go language: a lightweight thread-like
 509 abstraction.  Systems built with Fibers can scale up to millions of concurrent
 510 fibers, tens of thousands of concurrent socket connections, and many parallel
 511 cores.  The Fibers library also provides Concurrent ML-like channels for
 512 communication between fibers.
 513
 514 Note that Fibers makes use of some Guile 2.1/2.2-specific features and
 515 is not available for Guile 2.0.")
 516     (home-page "https://github.com/wingo/fibers")
 517     (license license:lgpl3+)))
 518
 519 (define-public guile-syntax-highlight
 520   (package
 521     (name "guile-syntax-highlight")
 522     (version "0.1")
 523     (source (origin
 524               (method url-fetch)
 525               (uri (string-append "https://files.dthompson.us/"
 526                                   "guile-syntax-highlight/"
 527                                   "guile-syntax-highlight-"
 528                                   version ".tar.gz"))
 529               (sha256
 530                (base32
 531                 "1p771kq15x83483m23bhah1sz6vkalg3drm7x279f4j1cxligkzi"))))
 532     (build-system gnu-build-system)
 533     (native-inputs
 534      `(("pkg-config" ,pkg-config)))
 535     (inputs
 536      `(("guile" ,guile-2.2)))
 537     (synopsis "General-purpose syntax highlighter for GNU Guile")
 538     (description "Guile-syntax-highlight is a general-purpose syntax
 539 highlighting library for GNU Guile.  It can parse code written in various
 540 programming languages into a simple s-expression that can be converted to
 541 HTML (via SXML) or any other format for rendering.")
 542     (home-page "http://dthompson.us/projects/guile-syntax-highlight.html")
 543     (license license:lgpl3+)))
 544
 545 (define-public guile-sjson
 546   (package
 547     (name "guile-sjson")
 548     (version "0.2.1")
 549     (source (origin
 550               (method url-fetch)
 551               (uri (string-append "https://dustycloud.org/misc/sjson-" version
 552                                   ".tar.gz"))
 553               (sha256
 554                (base32
 555                 "1mzmapln79vv10qxaggz9qwcdbag3jnrj19xx8bgkmxss8h03sv3"))))
 556     (build-system gnu-build-system)
 557     (native-inputs
 558      `(("autoconf" ,autoconf)
 559        ("automake" ,automake)
 560        ("pkg-config" ,pkg-config)))
 561     (inputs
 562      `(("guile" ,guile-2.2)))
 563     (home-page "https://gitlab.com/dustyweb/guile-sjson")
 564     (synopsis "S-expression based json reader/writer for Guile")
 565     (description "guile-sjson is a json reader/writer for Guile.
 566 It has a nice, simple s-expression based syntax.")
 567     (license license:lgpl3+)))
 568
 569 (define-public guile-squee
 570   (let ((commit "a85902a92bf6f58a1d35fd974a01ade163deda8d")
 571         (revision "0"))
 572     (package
 573       (name "guile-squee")
 574       (version (string-append "0-" revision "." (string-take commit 7)))
 575       (source (origin
 576                 (method git-fetch)
 577                 (uri (git-reference
 578                       (url "https://notabug.org/cwebber/guile-squee.git")
 579                       (commit commit)))
 580                 (file-name (git-file-name name version))
 581                 (sha256
 582                  (base32
 583                   "0p1lpsp4kx57j3ai1dkxilm4ziavzzx8wbbc42m3hpziq0a7qz5z"))))
 584       (build-system guile-build-system)
 585       (arguments
 586        '(#:phases
 587          (modify-phases %standard-phases
 588            (add-after 'unpack 'patch
 589              (lambda* (#:key inputs #:allow-other-keys)
 590                (substitute* "squee.scm"
 591                  (("dynamic-link \"libpq\"")
 592                   (string-append
 593                    "dynamic-link \""
 594                    (assoc-ref inputs "postgresql") "/lib/libpq.so"
 595                    "\"")))
 596                #t)))))
 597       (inputs
 598        `(("postgresql" ,postgresql)))
 599       (native-inputs
 600        `(("guile" ,guile-2.2)))
 601       (home-page "https://notabug.org/cwebber/guile-squee")
 602       (synopsis "Connect to PostgreSQL using Guile")
 603       (description
 604        "@code{squee} is a Guile library for connecting to PostgreSQL databases
 605 using Guile's foreign function interface.")
 606       (license license:lgpl3+))))
 607
 608 (define-public guile-colorized
 609   (package
 610     (name "guile-colorized")
 611     (version "0.1")
 612     (source
 613      (origin
 614        (method git-fetch)
 615        (uri (git-reference
 616              (url "https://gitlab.com/NalaGinrut/guile-colorized.git")
 617              (commit (string-append "v" version))))
 618        (file-name (git-file-name name version))
 619        (sha256
 620         (base32 "10mv8c63159r3qvwwdvsgnsvdg7nc2ghak85zapwqpv4ywrqp9zc"))))
 621     (build-system guile-build-system)
 622     (native-inputs
 623      `(("guile" ,guile-2.2)))
 624     (home-page "https://gitlab.com/NalaGinrut/guile-colorized")
 625     (synopsis "Colorized REPL for Guile")
 626     (description
 627      "Guile-colorized provides you with a colorized REPL for GNU Guile.")
 628     (license license:gpl3+)))
 629
 630 (define-public guile-pfds
 631   (package
 632     (name "guile-pfds")
 633     (version "0.3")
 634     (home-page "https://github.com/ijp/pfds")
 635     (source (origin
 636               (method git-fetch)
 637               (uri (git-reference
 638                     (url home-page)
 639                     (commit (string-append "v" version))))
 640               (sha256
 641                (base32
 642                 "19y33wg94pf0n98dkfqd1zbw93fgky4sawxsxl6s3vyqwl0yi5vh"))
 643               (file-name (string-append name "-" version "-checkout"))))
 644     (build-system guile-build-system)
 645     (arguments
 646      '(#:source-directory "src"
 647        #:phases (modify-phases %standard-phases
 648                   (add-after 'unpack 'move-files-around
 649                     (lambda _
 650                       ;; Move files under a pfds/ directory to reflect the
 651                       ;; module hierarchy.
 652                       (mkdir-p "src/pfds")
 653                       (for-each (lambda (file)
 654                                   (rename-file file
 655                                                (string-append "src/pfds/"
 656                                                               file)))
 657                                 '("bbtrees.sls"
 658                                   "deques"
 659                                   "deques.sls"
 660                                   "dlists.sls"
 661                                   "fingertrees.sls"
 662                                   "hamts.sls"
 663                                   "heaps.sls"
 664                                   "private"
 665                                   "psqs.sls"
 666                                   "queues"
 667                                   "queues.sls"
 668                                   "sequences.sls"
 669                                   "sets.sls"))
 670
 671                       ;; In Guile <= 2.2.4, there's no way to tell 'guild
 672                       ;; compile' to accept the ".sls" extension.  So...
 673                       (for-each (lambda (file)
 674                                   (rename-file file
 675                                                (string-append
 676                                                 (string-drop-right file 4)
 677                                                 ".scm")))
 678                                 (find-files "." "\\.sls$"))
 679                       #t)))))
 680     (native-inputs
 681      `(("guile" ,guile-2.2)))
 682     (synopsis "Purely functional data structures for Guile")
 683     (description
 684      "This package provides purely functional data structures written in R6RS
 685 Scheme and compiled for Guile.  It has been tested with Racket, Guile 2,
 686 Vicare Scheme and IronScheme.  Right now it contains:
 687
 688 @itemize
 689 @item queues
 690 @item deques
 691 @item bbtrees
 692 @item sets
 693 @item dlists
 694 @item priority search queues (PSQs)
 695 @item finger trees
 696 @item sequences
 697 @item heaps
 698 @item hash array mapped tries (HAMTs).
 699 @end itemize\n")
 700     (license license:bsd-3)))
 701
 702 (define-public guile-aa-tree
 703   (package
 704     (name "guile-aa-tree")
 705     (version "3.1.1")
 706     (source (origin
 707               (method url-fetch)
 708               (uri (string-append "mirror://savannah/guile-aa-tree/guile-aa-tree-"
 709                                   version ".tar.gz"))
 710               (sha256
 711                (base32
 712                 "0044c105r3q9vpl17pv3phl1b79kjm1llhkakqgiasixyav01blh"))))
 713     (build-system guile-build-system)
 714     (native-inputs `(("guile" ,guile-2.2)))
 715     ;; https://savannah.nongnu.org/projects/guile-aa-tree
 716     (home-page "https://qlfiles.net/guile-aa-tree/")
 717     (synopsis "AA tree data structure for Guile")
 718     (description
 719      "This package provides an implementation of @dfn{AA trees}, a
 720 self-balancing binary tree data structure, for Guile.  It ensure @math{O(log
 721 n)} worst case performance for core operations.  The module provides
 722 non-mutating insert, delete, and search operations, with support for
 723 convenient nested tree operations.")
 724     (license license:gpl3+)))
 725
 726 (define-public guile-simple-zmq
 727   (let ((commit "68bedb6679716214fb9d3472da57544526f7a618")
 728         (revision "3"))
 729     (package
 730       (name "guile-simple-zmq")
 731       (version (git-version "0.0.0" revision commit))
 732       (source
 733        (origin
 734          (method git-fetch)
 735          (uri (git-reference
 736                (url "https://github.com/jerry40/guile-simple-zmq")
 737                (commit commit)))
 738          (sha256
 739           (base32
 740            "1ad3xg69qqviy1f6dnlw0ysmfdbmp1jq65rfqb8nfd8dsrq2syli"))
 741          (file-name (git-file-name name version))))
 742       (build-system guile-build-system)
 743       (arguments
 744        `(#:source-directory "src"
 745          #:phases (modify-phases %standard-phases
 746                     (add-after 'unpack 'set-libzmq-file-name
 747                       (lambda* (#:key inputs #:allow-other-keys)
 748                         (substitute* "src/simple-zmq.scm"
 749                           (("\\(dynamic-link \"libzmq\"\\)")
 750                            (format #f "(dynamic-link \"~a/lib/libzmq.so\")"
 751                                    (assoc-ref inputs "zeromq"))))
 752                         #t)))))
 753       (native-inputs
 754        `(("guile" ,guile-2.2)))
 755       (inputs
 756        `(("zeromq" ,zeromq)))
 757       (home-page "https://github.com/jerry40/guile-simple-zmq")
 758       (synopsis "Guile wrapper over ZeroMQ library")
 759       (description
 760        "This package provides a Guile programming interface to the ZeroMQ
 761 messaging library.")
 762       (license license:gpl3+))))
 763
 764 (define-public jupyter-guile-kernel
 765   (let ((commit "a7db9245a886e104138474df46c3e88b95cff629")
 766         (revision "1"))
 767     (package
 768       (name "jupyter-guile-kernel")
 769       (version (git-version "0.0.0" revision commit))
 770       (source
 771        (origin
 772          (method git-fetch)
 773          (uri (git-reference
 774                (url "https://github.com/jerry40/guile-kernel")
 775                (commit commit)))
 776          (sha256
 777           (base32
 778            "0aj04853bqm47ivfcmrgpb7w3wkis847kc7qrwsa5zcn9h38qh2f"))))
 779       (build-system guile-build-system)
 780       (arguments
 781        '(#:phases (modify-phases %standard-phases
 782                     (add-after 'unpack 'set-openssl-file-name
 783                       (lambda* (#:key inputs #:allow-other-keys)
 784                         ;; Record the absolute file name of the 'openssl'
 785                         ;; command.
 786                         (substitute* "src/hmac.scm"
 787                           (("openssl")
 788                            (string-append (assoc-ref inputs "openssl")
 789                                           "/bin/openssl")))
 790                         #t))
 791
 792                     ;; XXX: The code uses 'include' to include its own source
 793                     ;; files, and "-L src" isn't enough in this case.
 794                     (add-before 'build 'chdir
 795                       (lambda _ (chdir "src") #t))
 796                     (add-after 'build 'chdir-back
 797                       (lambda _ (chdir "..") #t))
 798
 799                     (add-after 'install 'install-kernel
 800                       (lambda* (#:key inputs outputs #:allow-other-keys)
 801                         (let* ((out   (assoc-ref outputs "out"))
 802                                (json  (assoc-ref inputs "guile-json"))
 803                                (zmq   (assoc-ref inputs "guile-simple-zmq"))
 804                                (deps  (list json zmq))
 805                                (dir   (string-append
 806                                        out "/share/jupyter/kernels/guile"))
 807                                (effective (target-guile-effective-version)))
 808                           ;; Install kernel.
 809                           (install-file "src/kernel.json" dir)
 810
 811                           ;; Fix hard-coded file name in the kernel.
 812                           (substitute* (string-append dir "/kernel.json")
 813                             (("/home/.*/guile-jupyter-kernel.scm")
 814                              (string-append out "/share/guile/site/"
 815                                             (target-guile-effective-version)
 816                                             "/guile-jupyter-kernel.scm"))
 817                             (("\"guile\"")
 818                              (string-append "\"" (assoc-ref inputs "guile")
 819                                             "/bin/guile\""))
 820                             (("-s")
 821                              ;; Add '-L' and '-C' flags so that the kernel
 822                              ;; finds its dependencies.
 823                              (let ((-L (map (lambda (item)
 824                                               (string-append "\"" item
 825                                                              "/share/guile/site/"
 826                                                              effective "\""))
 827                                             deps))
 828                                    (-C (map (lambda (item)
 829                                               (string-append "\"" item
 830                                                              "/lib/guile/"
 831                                                              effective
 832                                                              "/site-ccache\""))
 833                                             deps)))
 834                               (string-append "--no-auto-compile\""
 835                                              (string-join -L ", \"-L\", "
 836                                                           'prefix)
 837                                              (string-join -C ", \"-C\", "
 838                                                           'prefix)
 839                                              ", \"-s"))))
 840                           #t))))))
 841       (inputs
 842        `(("openssl" ,openssl)
 843          ("guile" ,guile-2.2)
 844          ("guile-json" ,guile-json)
 845          ("guile-simple-zmq" ,guile-simple-zmq)))
 846       (synopsis "Guile kernel for the Jupyter Notebook")
 847       (description
 848        "This package provides a Guile 2.x kernel for the Jupyter Notebook.  It
 849 allows users to interact with the Guile REPL through Jupyter.")
 850       (home-page "https://github.com/jerry40/guile-kernel")
 851       (license license:gpl3+))))
 852
 853 (define-public guile-sparql
 854   (package
 855    (name "guile-sparql")
 856    (version "0.0.7")
 857    (source (origin
 858             (method url-fetch)
 859             (uri (string-append
 860                   "https://github.com/roelj/guile-sparql/releases/download/"
 861                   version "/guile-sparql-" version ".tar.gz"))
 862             (sha256
 863              (base32 "1drnvhsgl0gc5crmb16yyw1j98nkhwwcgssv9vgm36ng43nnzffd"))))
 864    (build-system gnu-build-system)
 865    (arguments `(#:tests? #f)) ; There are no tests.
 866    (native-inputs
 867     `(("pkg-config" ,pkg-config)))
 868    (inputs
 869     `(("guile" ,guile-2.2)))
 870    (home-page "https://github.com/roelj/guile-sparql")
 871    (synopsis "SPARQL module for Guile")
 872    (description "This package provides the functionality to query a SPARQL
 873 endpoint.  Additionally, it provides an interface to write SPARQL queries
 874 using S-expressions.")
 875    (license license:gpl3+)))
 876
 877 (define-public guile-debbugs
 878   (package
 879     (name "guile-debbugs")
 880     (version "0.0.2")
 881     (source (origin
 882               (method url-fetch)
 883               (uri (string-append "mirror://gnu/guile-debbugs/guile-debbugs-"
 884                                   version ".tar.gz"))
 885               (sha256
 886                (base32
 887                 "16l8910p57im6s3j93xhdaqvgfy6ms5n97177mrch3y961z5hy0i"))
 888               (modules '((guix build utils)))
 889               (snippet
 890                '(substitute* "Makefile.in"
 891                   (("^godir = (.*)/ccache" _ prefix)
 892                    (string-append "godir = " prefix "/site-ccache"))))))
 893     (build-system gnu-build-system)
 894     (native-inputs
 895      `(("guile" ,guile-2.2)
 896        ("pkg-config" ,pkg-config)))
 897     (home-page "https://savannah.gnu.org/projects/guile-debbugs/")
 898     (synopsis "Guile interface to the Debbugs bug tracking service")
 899     (description
 900      "This package provides a Guile library to communicate with a Debbugs bug
 901 tracker's SOAP service, such as @url{https://bugs.gnu.org}.")
 902     (license license:gpl3+)))
 903
 904 (define-public guile-email
 905   (package
 906     (name "guile-email")
 907     (version "0.1.0")
 908     (source
 909      (origin
 910        (method url-fetch)
 911        (uri (string-append
 912              "https://git.systemreboot.net/guile-email/snapshot/guile-email-"
 913              version ".tar.xz"))
 914        (sha256
 915         (base32
 916          "0p2v8q2kkz8m6vf2rsjvz3dj1mvnx7dxakjf72dwkndbgk3rp79f"))))
 917     (build-system gnu-build-system)
 918     (native-inputs
 919      `(("pkg-config" ,pkg-config)
 920        ("autoconf" ,autoconf)
 921        ("automake" ,automake)))
 922     (inputs
 923      `(("guile" ,guile-2.2)))
 924     (home-page "https://git.systemreboot.net/guile-email")
 925     (synopsis "Guile email parser")
 926     (description "This package provides an email parser written in pure
 927 Guile.")
 928     (license license:agpl3+)))
 929
 930 (define-public guile-debbugs-next
 931   (let ((commit "75a331d561c8b6f8efcf16216dab961c17759efe")
 932         (revision "1"))
 933     (package (inherit guile-debbugs)
 934       (name "guile-debbugs")
 935       (version (git-version "0.0.3" revision commit))
 936       (source (origin
 937                 (method git-fetch)
 938                 (uri (git-reference
 939                       (url "https://git.savannah.gnu.org/git/guile-debbugs.git")
 940                       (commit commit)))
 941                 (file-name (git-file-name name version))
 942                 (sha256
 943                  (base32
 944                   "0br3mgbw41bpc9x57jlghl0i8dz9nl63r4wzs5l47aqszf84870y"))))
 945       (build-system gnu-build-system)
 946       (native-inputs
 947        `(("pkg-config" ,pkg-config)
 948          ("autoconf" ,autoconf)
 949          ("automake" ,automake)
 950          ("texinfo" ,texinfo)))
 951       (inputs
 952        `(("guile" ,guile-2.2)
 953          ("guile-email" ,guile-email))))))
 954
 955 (define-public guile-newt
 956   (package
 957     (name "guile-newt")
 958     (version "0.0.1")
 959     (source (origin
 960               (method git-fetch)
 961               (uri (git-reference
 962                     (url "https://gitlab.com/mothacehe/guile-newt")
 963                     (commit version)))
 964               (file-name (git-file-name name version))
 965               (sha256
 966                (base32
 967                 "1w7qy4dw1f4bx622l6hw8mv49sf1ha8kch8j4nganyk8fj0wn695"))))
 968     (build-system gnu-build-system)
 969     (arguments
 970      '(#:make-flags
 971        '("GUILE_AUTO_COMPILE=0"))) ;to prevent guild warnings
 972     (inputs
 973      `(("guile" ,guile-2.2)
 974        ("newt" ,newt)))
 975     (native-inputs
 976      `(("autoconf" ,autoconf)
 977        ("automake" ,automake)
 978        ("pkg-config" ,pkg-config)))
 979     (synopsis "Guile bindings to Newt")
 980     (description
 981      "This package provides bindings for Newt, a programming library for
 982 color text mode, widget based user interfaces.  The bindings are written in pure
 983 Scheme by using Guile’s foreign function interface.")
 984     (home-page "https://gitlab.com/mothacehe/guile-newt")
 985     (license license:gpl3+)))
 986
 987 (define-public guile-mastodon
 988   (package
 989     (name "guile-mastodon")
 990     (version "0.0.1")
 991     (source (origin
 992               (method git-fetch)
 993               (uri (git-reference
 994                     (url "https://framagit.org/prouby/guile-mastodon.git")
 995                     (commit (string-append "v" version))))
 996               (file-name (git-file-name name version))
 997               (sha256
 998                (base32
 999                 "1vblf3d1bbwna3l09p2ap5y8ycvl549bz6whgk78imyfmn28ygry"))))
1000     (build-system gnu-build-system)
1001     (native-inputs
1002      `(("autoconf" ,autoconf)
1003        ("automake" ,automake)
1004        ("pkg-config" ,pkg-config)))
1005     (inputs
1006      `(("guile" ,guile-2.2)
1007        ("gnutls" ,gnutls)
1008        ("guile-json" ,guile-json)))
1009     (home-page "https://framagit.org/prouby/guile-mastodon")
1010     (synopsis "Guile Mastodon REST API module")
1011     (description "This package provides Guile modules to access the
1012 @uref{https://docs.joinmastodon.org/api/, REST API of Mastodon}, a federated
1013 microblogging service.")
1014     (license license:gpl3+)))
1015
1016 (define-public guile-parted
1017   (package
1018     (name "guile-parted")
1019     (version "0.0.1")
1020     (source (origin
1021               (method git-fetch)
1022               (uri (git-reference
1023                     (url "https://gitlab.com/mothacehe/guile-parted")
1024                     (commit version)))
1025               (file-name (git-file-name name version))
1026               (sha256
1027                (base32
1028                 "1q7425gpjlwi2wvhzq7kw046yyx7v6j6jyzkd1cr861iz34mjwiq"))))
1029     (build-system gnu-build-system)
1030     (arguments
1031      '(#:make-flags
1032        '("GUILE_AUTO_COMPILE=0"))) ;to prevent guild warnings
1033     (inputs
1034      `(("guile" ,guile-2.2)
1035        ("parted" ,parted)))
1036     (propagated-inputs
1037      `(("guile-bytestructures" ,guile-bytestructures)))
1038     (native-inputs
1039      `(("autoconf" ,autoconf)
1040        ("automake" ,automake)
1041        ("pkg-config" ,pkg-config)))
1042     (synopsis "Guile bindings to GNU Parted")
1043     (description
1044      "This package provides bindings for GNU Parted library, a C library
1045 allowing disk partition tables creation and manipulation.  The bindings are
1046 written in pure Scheme by using Guile's foreign function interface.")
1047     (home-page "https://gitlab.com/mothacehe/guile-parted")
1048     (license license:gpl3+)))
1049
1050 (define-public guile-xosd
1051   (package
1052     (name "guile-xosd")
1053     (version "0.2.1")
1054     (source (origin
1055               (method url-fetch)
1056               (uri (string-append "https://github.com/alezost/" name
1057                                   "/releases/download/v" version
1058                                   "/" name "-" version ".tar.gz"))
1059               (sha256
1060                (base32
1061                 "1ri5065c16kmgrf2pysn2ymxjqi5302lhpb07wkl1jr75ym8fn8p"))))
1062     (build-system gnu-build-system)
1063     (native-inputs
1064      `(("pkg-config" ,pkg-config)))
1065     (inputs
1066      `(("guile" ,guile-2.2)
1067        ("libx11" ,libx11)
1068        ("libxext" ,libxext)
1069        ("libxinerama" ,libxinerama)
1070        ("xosd" ,xosd)))
1071     (home-page "https://github.com/alezost/guile-xosd")
1072     (synopsis "XOSD bindings for Guile")
1073     (description
1074      "Guile-XOSD provides Guile bindings for @code{libxosd},
1075 @uref{http://sourceforge.net/projects/libxosd/, the X On Screen Display
1076 library}.")
1077     (license license:gpl3+)))
1078
1079 (define-public guile-dbi
1080   (package
1081     (name "guile-dbi")
1082     (version "2.1.6")
1083     (source (origin
1084               (method url-fetch)
1085               (uri (string-append
1086                     "http://download.gna.org/guile-dbi/guile-dbi-"
1087                     version ".tar.gz"))
1088               (sha256
1089                (base32
1090                 "116njrprhgrsv1qm904sp3b02rq01fx639r433d657gyhw3x159n"))))
1091     (build-system gnu-build-system)
1092     (arguments
1093      '(#:configure-flags
1094        (list (string-append
1095               "--with-guile-site-dir=" %output "/share/guile/site/2.2"))
1096        #:make-flags
1097        (list (string-append
1098               "LDFLAGS=-Wl,-rpath=" %output "/lib:"
1099               (assoc-ref %build-inputs "guile-dbd-sqlite3") "/lib" ":"
1100               (assoc-ref %build-inputs "guile-dbd-postgresql") "/lib"))
1101        #:phases
1102        (modify-phases %standard-phases
1103          (add-after 'install 'patch-extension-path
1104            (lambda* (#:key outputs #:allow-other-keys)
1105              (let* ((out     (assoc-ref outputs "out"))
1106                     (dbi.scm (string-append
1107                               out "/share/guile/site/2.2/dbi/dbi.scm"))
1108                     (ext     (string-append out "/lib/libguile-dbi")))
1109                (substitute* dbi.scm (("libguile-dbi") ext))
1110                #t))))))
1111     (inputs
1112      `(("guile-dbd-sqlite3" ,guile-dbd-sqlite3)
1113        ("guile-dbd-postgresql" ,guile-dbd-postgresql))) ; only shared library, no scheme files
1114     (propagated-inputs
1115      `(("guile" ,guile-2.2)))
1116     (synopsis "Guile database abstraction layer")
1117     (home-page "http://home.gna.org/guile-dbi/guile-dbi.html")
1118     (description
1119      "guile-dbi is a library for Guile that provides a convenient interface to
1120 SQL databases.  Database programming with guile-dbi is generic in that the same
1121 programming interface is presented regardless of which database system is used.
1122 It currently supports MySQL, Postgres and SQLite3.")
1123     (license license:gpl2+)))
1124
1125 (define guile-dbi-bootstrap
1126   (package
1127     (inherit guile-dbi)
1128     (name "guile-dbi-bootstrap")
1129     (inputs '())
1130     (arguments
1131      (substitute-keyword-arguments (package-arguments guile-dbi)
1132        ((#:make-flags _) '(list))))))
1133
1134 (define-public guile-dbd-sqlite3
1135   (package
1136     (name "guile-dbd-sqlite3")
1137     (version "2.1.6")
1138     (source (origin
1139               (method url-fetch)
1140               (uri (string-append
1141                     "http://download.gna.org/guile-dbi/guile-dbd-sqlite3-"
1142                     version ".tar.gz"))
1143               (sha256
1144                (base32
1145                 "0rg71jchxd2y8x496s8zmfmikr5g8zxi8zv2ar3f7a23pph92iw2"))))
1146     (build-system gnu-build-system)
1147     (native-inputs
1148      `(("pkg-config" ,pkg-config)
1149        ("guile-dbi-bootstrap" ,guile-dbi-bootstrap))) ; only required for headers
1150     (inputs
1151      `(("sqlite" ,sqlite)
1152        ("zlib" ,(@ (gnu packages compression) zlib))))
1153     (synopsis "Guile DBI driver for SQLite")
1154     (home-page "https://github.com/jkalbhenn/guile-dbd-sqlite3")
1155     (description
1156      "guile-dbi is a library for Guile that provides a convenient interface to
1157 SQL databases.  This package implements the interface for SQLite.")
1158     (license license:gpl2+)))
1159
1160 (define-public guile-dbd-postgresql
1161   (let ((commit "e97589b6b018b206c901e4cc24db463407a4036b")
1162         (revision 0))
1163     (package
1164       (name "guile-dbd-postgresql")
1165       (version (string-append
1166                 "2.1.6-" (number->string revision) "." (string-take commit 7)))
1167       (source
1168        (origin
1169          (method git-fetch)
1170          (uri (git-reference
1171                (url "https://github.com/opencog/guile-dbi.git")
1172                (commit commit)))
1173          (file-name (git-file-name name version))
1174          (sha256
1175           (base32 "0n1gv9a0kdys10a4qmnrwvg5sydwb03880asri4gqdchcj3fimni"))))
1176       (build-system gnu-build-system)
1177       (arguments
1178        '(#:phases
1179          (modify-phases %standard-phases
1180            (add-after 'unpack 'chdir
1181              (lambda _
1182                ;; The upstream Git repository contains all the code, so change
1183                ;; to the relevant directory.
1184                (chdir "guile-dbd-postgresql")
1185                #t))
1186            (add-after 'chdir 'patch-src/Makefile.am
1187              (lambda* (#:key inputs #:allow-other-keys)
1188                (substitute* "src/Makefile.am"
1189                  (("/usr/include")
1190                   (string-append (assoc-ref inputs "postgresql") "/include")))
1191                #t))
1192            (add-after 'patch-src/Makefile.am 'patch-src
1193              (lambda _
1194                (substitute* "src/guile-dbd-postgresql.c"
1195                  (("postgresql/libpq-fe\\.h") "libpq-fe.h"))
1196                #t)))))
1197       (native-inputs
1198        `(("pkg-config" ,pkg-config)
1199          ("automake" ,automake)
1200          ("autoconf" ,autoconf)
1201          ("perl" ,perl)
1202          ("libtool" ,libtool)
1203          ("guile-dbi-bootstrap" ,guile-dbi-bootstrap)))
1204       (inputs
1205        `(("postgresql" ,postgresql)
1206          ("zlib" ,zlib)))
1207       (synopsis "Guile DBI driver for PostgreSQL")
1208       (home-page
1209        "https://github.com/opencog/guile-dbi/tree/master/guile-dbd-postgresql")
1210       (description
1211        "@code{guile-dbi} is a library for Guile that provides a convenient
1212 interface to SQL databases.  This package implements the interface for
1213 PostgreSQL.")
1214       (license license:gpl2+))))
1215
1216 (define-public guile-config
1217   (package
1218     (name "guile-config")
1219     (version "0.3")
1220     (source
1221      (origin
1222        (method git-fetch)
1223        (uri (git-reference
1224              (url "https://gitlab.com/a-sassmannshausen/guile-config")
1225              (commit "ce12de3f438c6b2b59c43ee21bcd58251835fdf3")))
1226        (file-name "guile-config-0.3-checkout")
1227        (sha256 (base32 "02zbpin0r9m2vxmr7mv68v3xdn247dcck56kbzjn0gj4c2rhih85"))))
1228     (build-system gnu-build-system)
1229     (native-inputs
1230      `(("autoconf" ,autoconf)
1231        ("automake" ,automake)
1232        ("pkg-config" ,pkg-config)
1233        ("texinfo" ,texinfo)))
1234     (inputs `(("guile" ,guile-2.2)))
1235     (synopsis
1236      "Guile application configuration parsing library.")
1237     (description
1238      "Guile Config is a library providing a declarative approach to
1239 application configuration specification.  The library provides clean
1240 configuration declaration forms, and processors that take care of:
1241 configuration file creation; configuration file parsing; command-line
1242 parameter parsing using getopt-long; basic GNU command-line parameter
1243 generation (--help, --usage, --version); automatic output generation for the
1244 above command-line parameters.")
1245     (home-page
1246      "https://gitlab.com/a-sassmannshausen/guile-config")
1247     (license license:gpl3+)))
1248
1249 (define-public guile-hall
1250   (package
1251     (name "guile-hall")
1252     (version "0.2")
1253     (source
1254      (origin
1255        (method git-fetch)
1256        (uri (git-reference
1257              (url "https://gitlab.com/a-sassmannshausen/guile-hall")
1258              (commit (string-append "v" version))))
1259        (file-name (git-file-name name version))
1260        (sha256 (base32
1261                 "1bkbqgj24xh5b65sw2m98iggpi67b72szx1dsiq3cpzlcxplmgaz"))))
1262     (build-system gnu-build-system)
1263     (arguments
1264       `(#:modules
1265         ((ice-9 match)
1266          (ice-9 ftw)
1267          ,@%gnu-build-system-modules)
1268         #:phases
1269         (modify-phases
1270           %standard-phases
1271           (add-after 'install 'hall-wrap-binaries
1272             (lambda* (#:key inputs outputs #:allow-other-keys)
1273               (let* ((compiled-dir
1274                        (lambda (out version)
1275                          (string-append
1276                            out "/lib/guile/" version "/site-ccache")))
1277                      (uncompiled-dir
1278                        (lambda (out version)
1279                          (string-append
1280                           out "/share/guile/site"
1281                           (if (string-null? version) "" "/") version)))
1282                      (dep-path
1283                        (lambda (env modules path)
1284                          (list env ":" 'prefix
1285                                (cons modules
1286                                      (map (lambda (input)
1287                                             (string-append
1288                                               (assoc-ref inputs input)
1289                                               path))
1290                                           ,''("guile-config"))))))
1291                      (out (assoc-ref outputs "out"))
1292                      (bin (string-append out "/bin/"))
1293                      (site (uncompiled-dir out "")))
1294                 (match (scandir site)
1295                        (("." ".." version)
1296                         (for-each
1297                           (lambda (file)
1298                             (wrap-program
1299                               (string-append bin file)
1300                               (dep-path
1301                                 "GUILE_LOAD_PATH"
1302                                 (uncompiled-dir out version)
1303                                 (uncompiled-dir "" version))
1304                               (dep-path
1305                                 "GUILE_LOAD_COMPILED_PATH"
1306                                 (compiled-dir out version)
1307                                 (compiled-dir "" version))))
1308                           ,''("hall"))
1309                         #t))))))))
1310     (native-inputs
1311       `(("autoconf" ,autoconf)
1312         ("automake" ,automake)
1313         ("pkg-config" ,pkg-config)
1314         ("texinfo" ,texinfo)))
1315     (inputs `(("guile" ,guile-2.2)))
1316     (propagated-inputs
1317      `(("guile-config" ,guile-config)))
1318     (synopsis "Guile project tooling")
1319     (description
1320      "Hall is a command-line application and a set of Guile libraries that
1321 allow you to quickly create and publish Guile projects.  It allows you to
1322 transparently support the GNU build system, manage a project hierarchy &
1323 provides tight coupling to Guix.")
1324     (home-page "https://gitlab.com/a-sassmannshausen/guile-hall")
1325     (license license:gpl3+)))
1326
1327 (define-public guile-ics
1328   (package
1329     (name "guile-ics")
1330     (version "0.2.0")
1331     (source (origin
1332               (method git-fetch)
1333               (uri (git-reference
1334                     (url "https://github.com/artyom-poptsov/guile-ics")
1335                     (commit (string-append "v" version))))
1336               (file-name (string-append name "-" version "-checkout"))
1337               (sha256
1338                (base32
1339                 "0qjjvadr7gibdq9jvwkmlkb4afsw9n2shfj9phpiadinxk3p4m2g"))))
1340     (build-system gnu-build-system)
1341     (native-inputs
1342      `(("autoconf" ,autoconf-wrapper)
1343        ("automake" ,automake)
1344        ("texinfo" ,texinfo)
1345        ;; Gettext brings 'AC_LIB_LINKFLAGS_FROM_LIBS'.
1346        ("gettext" ,gettext-minimal)
1347        ("pkg-config" ,pkg-config)))
1348     (inputs `(("guile" ,guile-2.2) ("which" ,which)))
1349     (propagated-inputs `(("guile-lib" ,guile-lib)))
1350     (home-page "https://github.com/artyom-poptsov/guile-ics")
1351     (synopsis "Guile parser library for the iCalendar format")
1352     (description
1353      "Guile-ICS is an iCalendar (RFC5545) format parser library written in
1354 pure Scheme.  The library can be used to read and write iCalendar data.
1355
1356 The library is shipped with documentation in Info format and usage examples.")
1357     (license license:gpl3+)))
1358
1359 (define-public guile-wisp
1360   (package
1361     (name "guile-wisp")
1362     (version "0.9.9.1")
1363     (source (origin
1364               (method url-fetch)
1365               (uri (string-append "https://bitbucket.org/ArneBab/"
1366                                   "wisp/downloads/wisp-"
1367                                   version ".tar.gz"))
1368               (sha256
1369                (base32
1370                 "1ii14qz1lx7ffhb8i9q7dgaiwbif8g2q182skx17j11skp65c8r3"))))
1371     (build-system gnu-build-system)
1372     (arguments
1373      `(#:modules ((guix build gnu-build-system)
1374                   ((guix build emacs-build-system) #:prefix emacs:)
1375                   (guix build utils)
1376                   (guix build emacs-utils)
1377                   (ice-9 rdelim)
1378                   (ice-9 popen))
1379        #:imported-modules (,@%gnu-build-system-modules
1380                            (guix build emacs-build-system)
1381                            (guix build emacs-utils))
1382        #:phases
1383        (modify-phases %standard-phases
1384          (add-before 'configure 'patch-/usr/bin/env
1385            (lambda _
1386              (substitute* "Makefile.in"
1387                (("/usr/bin/env bash") (which "bash"))
1388                (("\\$\\(GUILE_EFFECTIVE_VERSION\\)/site")
1389                 "site/$(GUILE_EFFECTIVE_VERSION)")) ;use the right order
1390              #t))
1391          ;; auto compilation breaks, but if we set HOME to /tmp,
1392          ;; that works ok
1393          (add-before 'check 'auto-compile-hacky-workaround
1394            (lambda _ (setenv "HOME" "/tmp") #t))
1395          (add-after 'install 'install-go-files
1396            (lambda* (#:key outputs inputs #:allow-other-keys)
1397              (let* ((out (assoc-ref outputs "out"))
1398                     (effective (read-line
1399                                 (open-pipe* OPEN_READ
1400                                             "guile" "-c"
1401                                             "(display (effective-version))")))
1402                     (module-dir (string-append out "/share/guile/site/"
1403                                                effective))
1404                     (object-dir (string-append out "/lib/guile/" effective
1405                                                "/site-ccache"))
1406                     (prefix     (string-length module-dir)))
1407                ;; compile to the destination
1408                (for-each (lambda (file)
1409                            (let* ((base (string-drop (string-drop-right file 4)
1410                                                      prefix))
1411                                   (go   (string-append object-dir base ".go")))
1412                              (invoke "guild" "compile" "-L" module-dir
1413                                      file "-o" go)))
1414                          (find-files module-dir "\\.scm$"))
1415                #t)))
1416          (add-after 'install 'install-emacs-files
1417            (assoc-ref emacs:%standard-phases 'install))
1418          (add-after 'install-emacs-files 'compile-emacs-files
1419            (assoc-ref emacs:%standard-phases 'build))
1420          (add-after 'compile-emacs-files 'make-autoloads
1421            (assoc-ref emacs:%standard-phases 'make-autoloads)))))
1422     (home-page "https://draketo.de/english/wisp")
1423     (inputs
1424      `(("guile" ,guile-2.2)))
1425     (native-inputs
1426      `(("emacs" ,emacs-minimal)
1427        ("python" ,python)
1428        ("pkg-config" ,pkg-config)))
1429     (synopsis "Whitespace to lisp syntax for Guile")
1430     (description "Wisp is a syntax for Guile which provides a Python-like
1431 whitespace-significant language.  It may be easier on the eyes for some
1432 users and in some situations.")
1433     (license license:gpl3+)))
1434
1435 (define-public guile-sly
1436   (package
1437     (name "guile-sly")
1438     (version "0.1")
1439     (source (origin
1440               (method url-fetch)
1441               (uri (string-append "https://files.dthompson.us/sly/sly-"
1442                                   version ".tar.gz"))
1443               (sha256
1444                (base32
1445                 "1svzlbz2vripmyq2kjh0rig16bsrnbkwbsm558pjln9l65mcl4qq"))
1446               (modules '((guix build utils)))
1447               (snippet
1448                '(begin
1449                   (substitute* "configure"
1450                     (("_guile_required_version=\"2.0.11\"")
1451                      "_guile_required_version=\"2\"")
1452                     (("ac_subst_vars='")
1453                      "ac_subst_vars='GUILE_EFFECTIVE_VERSION\n"))
1454                   (substitute* (find-files "." "Makefile.in")
1455                     (("moddir = .*$")
1456                      (string-append
1457                       "moddir = "
1458                       "$(prefix)/share/guile/site/@GUILE_EFFECTIVE_VERSION@\n"))
1459                     (("godir = .*$")
1460                      (string-append
1461                       "godir = "
1462                       "$(prefix)/lib/guile/@GUILE_EFFECTIVE_VERSION@/site-ccache\n")))
1463                   #t))))
1464     (build-system gnu-build-system)
1465     (arguments
1466      '(#:configure-flags
1467        (list (string-append "--with-libfreeimage-prefix="
1468                             (assoc-ref %build-inputs "freeimage"))
1469              (string-append "--with-libgslcblas-prefix="
1470                             (assoc-ref %build-inputs "gsl")))))
1471     (native-inputs
1472      `(("pkg-config" ,pkg-config)))
1473     (propagated-inputs
1474      `(("guile-sdl" ,guile-sdl)
1475        ("guile-opengl" ,guile-opengl)))
1476     (inputs
1477      `(("guile" ,guile-2.2)
1478        ("gsl" ,gsl)
1479        ("freeimage" ,freeimage)
1480        ("mesa" ,mesa)))
1481     (synopsis "2D/3D game engine for GNU Guile")
1482     (description "Sly is a 2D/3D game engine written in Guile Scheme.  Sly
1483 features a functional reactive programming interface and live coding
1484 capabilities.")
1485     (home-page "https://dthompson.us/projects/sly.html")
1486     (license license:gpl3+)))
1487
1488 (define-public g-wrap
1489   (package
1490     (name "g-wrap")
1491     (version "1.9.15")
1492     (source (origin
1493               (method url-fetch)
1494               (uri (string-append "mirror://savannah/g-wrap/g-wrap-"
1495                                   version ".tar.gz"))
1496               (sha256
1497                (base32
1498                 "0ak0bha37dfpj9kmyw1r8fj8nva639aw5xr66wr5gd3l1rqf5xhg"))))
1499     (build-system gnu-build-system)
1500     (native-inputs
1501      `(("pkg-config" ,pkg-config)))
1502     (propagated-inputs
1503      `(("guile" ,guile-2.2)
1504        ("guile-lib" ,guile-lib)))
1505     (inputs
1506      `(("libffi" ,libffi)))
1507     (arguments
1508      `(#:configure-flags '("--disable-Werror")
1509        #:phases
1510        (modify-phases %standard-phases
1511          (add-before 'configure 'pre-configure
1512            (lambda* (#:key outputs #:allow-other-keys)
1513              (let ((out (assoc-ref outputs "out")))
1514                (substitute* (find-files "." "^Makefile.in$")
1515                  (("guilemoduledir =.*guile/site" all)
1516                   (string-append all "/@GUILE_EFFECTIVE_VERSION@")))
1517                #t))))))
1518     (synopsis "Generate C bindings for Guile")
1519     (description "G-Wrap is a tool and Guile library for generating function
1520 wrappers for inter-language calls.  It currently only supports generating Guile
1521 wrappers for C functions.  Given a definition of the types and prototypes for
1522 a given C interface, G-Wrap will automatically generate the C code that
1523 provides access to that interface and its types from the Scheme level.")
1524     (home-page "https://www.nongnu.org/g-wrap/index.html")
1525     (license license:lgpl2.1+)))
1526
1527 (define-public guile-miniadapton
1528   (let ((commit "1b5749422304567c96ac5367f2221dda9eff5880")
1529         (revision "1"))
1530     (package
1531       (name "guile-miniadapton")
1532       (version (string-append "0-" revision "." (string-take commit 9)))
1533       (source (origin
1534                 (method git-fetch)
1535                 (uri (git-reference
1536                       (url "https://github.com/fisherdj/miniAdapton.git")
1537                       (commit commit)))
1538                 (file-name (string-append name "-" version "-checkout"))
1539                 (sha256
1540                  (base32
1541                   "09q51zkw2fypad5xixskfzw2cjhjgs5cswdp3i7cpp651rb3zndh"))))
1542       (build-system guile-build-system)
1543       (native-inputs
1544        `(("guile" ,guile-2.2)))
1545       (home-page "https://github.com/fisherdj/miniAdapton")
1546       (synopsis "Minimal implementation of incremental computation in Guile
1547 Scheme")
1548       (description "This package provides a complete Scheme implementation of
1549 miniAdapton, which implements the core functionality of the Adapton system for
1550 incremental computation (also known as self-adjusting computation).  Like
1551 Adapton, miniAdapton allows programmers to safely combine mutation and
1552 memoization.  miniAdapton is built on top of an even simpler system,
1553 microAdapton.  Both miniAdapton and microAdapton are designed to be easy to
1554 understand, extend, and port to host languages other than Scheme.")
1555       (license license:expat))))
1556
1557 (define-public guile-reader
1558   (package
1559     (name "guile-reader")
1560     (version "0.6.2")
1561     (source  (origin
1562                (method url-fetch)
1563                (uri (string-append "mirror://savannah/guile-reader/guile-reader-"
1564                                    version ".tar.gz"))
1565                (sha256
1566                 (base32
1567                  "0592s2s8ampqmqwilc4fvcild6rb9gy79di6vxv5kcdmv23abkgx"))))
1568     (build-system gnu-build-system)
1569     (native-inputs `(("pkgconfig" ,pkg-config)
1570                      ("gperf" ,gperf-3.0)))
1571     (inputs `(("guile" ,guile-2.2)))
1572     (synopsis "Framework for building readers for GNU Guile")
1573     (description
1574      "Guile-Reader is a simple framework for building readers for GNU Guile.
1575
1576 The idea is to make it easy to build procedures that extend Guile’s read
1577 procedure.  Readers supporting various syntax variants can easily be written,
1578 possibly by re-using existing “token readers” of a standard Scheme
1579 readers.  For example, it is used to implement Skribilo’s R5RS-derived
1580 document syntax.
1581
1582 Guile-Reader’s approach is similar to Common Lisp’s “read table”, but
1583 hopefully more powerful and flexible (for instance, one may instantiate as
1584 many readers as needed).")
1585     (home-page "https://www.nongnu.org/guile-reader/")
1586     (license license:gpl3+)))
1587
1588 (define-public guile2.2-reader
1589   (deprecated-package "guile2.2-reader" guile-reader))
1590
1591 (define-public guile-ncurses
1592   (package
1593     (name "guile-ncurses")
1594     (version "2.2")
1595     (source (origin
1596              (method url-fetch)
1597              (uri (string-append "mirror://gnu/guile-ncurses/guile-ncurses-"
1598                                  version ".tar.gz"))
1599              (sha256
1600               (base32
1601                "1wvggbr4xv8idh1hzd8caj4xfp4pln78a7w1wqzd4zgzwmnzxr2f"))))
1602     (build-system gnu-build-system)
1603     (inputs `(("ncurses" ,ncurses)
1604               ("guile" ,guile-2.2)))
1605     (native-inputs `(("pkg-config" ,pkg-config)))
1606     (arguments
1607      '(#:configure-flags (list "--with-ncursesw"  ; Unicode support
1608                                "--with-gnu-filesystem-hierarchy")
1609        #:phases
1610        (modify-phases %standard-phases
1611          (add-before 'build 'fix-libguile-ncurses-file-name
1612            (lambda* (#:key outputs #:allow-other-keys)
1613              (invoke "make" "install"
1614                      "-C" "src/ncurses"
1615                      "-j" (number->string
1616                            (parallel-job-count)))
1617              (let* ((out   (assoc-ref outputs "out"))
1618                     (dir   "src/ncurses")
1619                     (files (find-files dir ".scm")))
1620                (substitute* files
1621                  (("\"libguile-ncurses\"")
1622                   (format #f "\"~a/lib/guile/2.2/libguile-ncurses\""
1623                           out)))
1624                #t))))))
1625     (home-page "https://www.gnu.org/software/guile-ncurses/")
1626     (synopsis "Guile bindings to ncurses")
1627     (description
1628      "guile-ncurses provides Guile language bindings for the ncurses
1629 library.")
1630     (license license:lgpl3+)))
1631
1632 (define-public guile-ncurses/gpm
1633   (package
1634     (inherit guile-ncurses)
1635     (name "guile-ncurses-with-gpm")
1636     (inputs `(("ncurses" ,ncurses/gpm)
1637               ("guile" ,guile-2.2)))))
1638
1639 (define-public guile-lib
1640   (package
1641     (name "guile-lib")
1642     (version "0.2.6.1")
1643     (source (origin
1644               (method url-fetch)
1645               (uri (string-append "mirror://savannah/guile-lib/guile-lib-"
1646                                   version ".tar.gz"))
1647               (sha256
1648                (base32
1649                 "0aizxdif5dpch9cvs8zz5g8ds5s4xhfnwza2il5ji7fv2h7ks7bd"))))
1650     (build-system gnu-build-system)
1651     (arguments
1652      '(#:make-flags
1653        '("GUILE_AUTO_COMPILE=0")        ; to prevent guild errors
1654        #:phases
1655        (modify-phases %standard-phases
1656          (add-before 'configure 'patch-module-dir
1657            (lambda _
1658              (substitute* "src/Makefile.in"
1659                (("^moddir = ([[:graph:]]+)")
1660                 "moddir = $(datadir)/guile/site/@GUILE_EFFECTIVE_VERSION@\n")
1661                (("^godir = ([[:graph:]]+)")
1662                 "godir = \
1663 $(libdir)/guile/@GUILE_EFFECTIVE_VERSION@/site-ccache\n"))
1664              #t)))))
1665     (native-inputs `(("pkg-config" ,pkg-config)))
1666     (inputs `(("guile" ,guile-2.2)))
1667     (home-page "https://www.nongnu.org/guile-lib/")
1668     (synopsis "Collection of useful Guile Scheme modules")
1669     (description
1670      "Guile-Lib is intended as an accumulation place for pure-scheme Guile
1671 modules, allowing for people to cooperate integrating their generic Guile
1672 modules into a coherent library.  Think \"a down-scaled, limited-scope CPAN
1673 for Guile\".")
1674
1675     ;; The whole is under GPLv3+, but some modules are under laxer
1676     ;; distribution terms such as LGPL and public domain.  See `COPYING' for
1677     ;; details.
1678     (license license:gpl3+)))
1679
1680 (define-public guile2.0-lib
1681   (package
1682     (inherit guile-lib)
1683     (name "guile2.0-lib")
1684     (inputs `(("guile" ,guile-2.0)))))
1685
1686 (define-public guile2.2-lib
1687   (deprecated-package "guile2.2-lib" guile-lib))
1688
1689 (define-public guile-minikanren
1690   (package
1691     (name "guile-minikanren")
1692     (version "20150424.e844d85")
1693     (source (origin
1694               (method git-fetch)
1695               (uri (git-reference
1696                     (url "https://github.com/ijp/minikanren.git")
1697                     (commit "e844d85512f8c055d3f96143ee506007389a25e3")))
1698               (file-name (string-append name "-" version "-checkout"))
1699               (sha256
1700                (base32
1701                 "0r50jlpzi940jlmxyy3ddqqwmj5r12gb4bcv0ssini9v8km13xz6"))))
1702     (build-system guile-build-system)
1703     (native-inputs
1704      `(("guile" ,guile-2.2)))
1705     (home-page "https://github.com/ijp/minikanren")
1706     (synopsis "MiniKanren declarative logic system, packaged for Guile")
1707     (description
1708      "MiniKanren is a relational programming extension to the Scheme
1709 programming Language, written as a smaller version of Kanren suitable for
1710 pedagogical purposes.  It is featured in the book, The Reasoned Schemer,
1711 written by Dan Friedman, William Byrd, and Oleg Kiselyov.
1712
1713 This is Ian Price's r6rs packaged version of miniKanren, which deviates
1714 slightly from miniKanren mainline.
1715
1716 See http://minikanren.org/ for more on miniKanren generally.")
1717     (license license:expat)))
1718
1719 (define-public guile2.0-minikanren
1720   (package
1721     (inherit guile-minikanren)
1722     (name "guile2.0-minikanren")
1723     (native-inputs `(("guile" ,guile-2.0)))))
1724
1725 (define-public guile2.2-minikanren
1726   (deprecated-package "guile2.2-minikanren" guile-minikanren))
1727
1728 (define-public guile-irregex
1729   (package
1730     (name "guile-irregex")
1731     (version "0.9.6")
1732     (source (origin
1733               (method url-fetch)
1734               (uri (string-append
1735                     "http://synthcode.com/scheme/irregex/irregex-"
1736                     version ".tar.gz"))
1737               (sha256
1738                (base32
1739                 "1ia3m7dp3lcxa048q0gqbiwwsyvn99baw6xkhb4bhhzn4k7bwyqq"))))
1740     (build-system guile-build-system)
1741     (arguments
1742      '(#:phases (modify-phases %standard-phases
1743                   (add-after 'unpack 'move-files-around
1744                     (lambda _
1745                       ;; Move the relevant source files to src/ and create the
1746                       ;; rx/ directory to match the expected module hierarchy.
1747                       (mkdir-p "src/rx/source")
1748                       (rename-file "irregex-guile.scm"
1749                                    "src/rx/irregex.scm")
1750                       (rename-file "irregex.scm"
1751                                    "src/rx/source/irregex.scm")
1752                       ;; Not really reachable via guile's packaging system,
1753                       ;; but nice to have around.
1754                       (rename-file "irregex-utils.scm"
1755                                    "src/rx/source/irregex-utils.scm")
1756                       #t)))
1757        #:source-directory "src"))
1758     (native-inputs
1759      `(("guile" ,guile-2.2)))
1760     (home-page "http://synthcode.com/scheme/irregex")
1761     (synopsis "S-expression based regular expressions")
1762     (description
1763      "Irregex is an s-expression based alternative to your classic
1764 string-based regular expressions.  It implements SRFI 115 and is deeply
1765 inspired by the SCSH regular expression system.")
1766     (license license:bsd-3)))
1767
1768 (define-public guile2.0-irregex
1769   (package
1770     (inherit guile-irregex)
1771     (name "guile2.0-irregex")
1772     (native-inputs `(("guile" ,guile-2.0)))))
1773
1774 (define-public guile2.2-irregex
1775   (deprecated-package "guile2.2-irregex" guile-irregex))
1776
1777 (define-public haunt
1778   (package
1779     (name "haunt")
1780     (version "0.2.4")
1781     (source (origin
1782               (method url-fetch)
1783               (uri (string-append "https://files.dthompson.us/haunt/haunt-"
1784                                   version ".tar.gz"))
1785               (sha256
1786                (base32
1787                 "056z4znikk83nr5mr0x2ac3iinqbywa2bvb37mhr566a1q50isfc"))))
1788     (build-system gnu-build-system)
1789     (arguments
1790      `(#:modules ((ice-9 match) (ice-9 ftw)
1791                   ,@%gnu-build-system-modules)
1792        #:tests? #f ; test suite is non-deterministic :(
1793        #:phases (modify-phases %standard-phases
1794                   (add-after 'install 'wrap-haunt
1795                     (lambda* (#:key inputs outputs #:allow-other-keys)
1796                       ;; Wrap the 'haunt' command to refer to the right
1797                       ;; modules.
1798                       (let* ((out  (assoc-ref outputs "out"))
1799                              (bin  (string-append out "/bin"))
1800                              (site (string-append
1801                                     out "/share/guile/site"))
1802                              (deps (list (assoc-ref inputs "guile-reader")
1803                                          (assoc-ref inputs "guile-commonmark"))))
1804                         (match (scandir site)
1805                           (("." ".." version)
1806                            (let ((modules (string-append site "/" version))
1807                                  (compiled-modules (string-append
1808                                                     out "/lib/guile/" version
1809                                                     "/site-ccache")))
1810                              (wrap-program (string-append bin "/haunt")
1811                                `("GUILE_LOAD_PATH" ":" prefix
1812                                  (,modules
1813                                   ,@(map (lambda (dep)
1814                                            (string-append dep
1815                                                           "/share/guile/site/"
1816                                                           version))
1817                                          deps)))
1818                                `("GUILE_LOAD_COMPILED_PATH" ":" prefix
1819                                  (,compiled-modules
1820                                   ,@(map (lambda (dep)
1821                                            (string-append dep "/lib/guile/"
1822                                                           version
1823                                                           "/site-ccache"))
1824                                          deps))))
1825                              #t)))))))))
1826     (native-inputs
1827      `(("pkg-config" ,pkg-config)
1828        ("texinfo" ,texinfo)))
1829     (inputs
1830      `(("guile" ,guile-2.2)))
1831     (propagated-inputs
1832      `(("guile-reader" ,guile-reader)
1833        ("guile-commonmark" ,guile-commonmark)))
1834     (synopsis "Functional static site generator")
1835     (description "Haunt is a static site generator written in Guile
1836 Scheme.  Haunt features a functional build system and an extensible
1837 interface for reading articles in any format.")
1838     (home-page "http://haunt.dthompson.us")
1839     (license license:gpl3+)))
1840
1841 (define-public guile2.0-haunt
1842   (package
1843     (inherit haunt)
1844     (name "guile2.0-haunt")
1845     (inputs `(("guile" ,guile-2.0)))))
1846
1847 (define-public guile2.2-haunt
1848   (deprecated-package "guile2.2-haunt" haunt))
1849
1850 (define-public guile-redis
1851   (package
1852     (name "guile-redis")
1853     (version "1.3.0")
1854     (home-page "https://github.com/aconchillo/guile-redis")
1855     (source (origin
1856               (method url-fetch)
1857               (uri (string-append home-page "/archive/" version ".tar.gz"))
1858               (sha256
1859                (base32
1860                 "1li70a2716my9q9zfq0qn2x5d1cir9k2vx0jm9glm464yaf1vj39"))))
1861     (build-system gnu-build-system)
1862     (native-inputs
1863      `(("autoconf" ,autoconf)
1864        ("automake" ,automake)
1865        ("pkg-config" ,pkg-config)
1866        ("guile" ,guile-2.2)))
1867     (synopsis "Redis client library for Guile")
1868     (description "Guile-redis provides a Scheme interface to the Redis
1869 key-value cache and store.")
1870     (license license:lgpl3+)))
1871
1872 (define-public guile2.0-redis
1873   (package
1874     (inherit guile-redis)
1875     (name "guile2.0-redis")
1876     (native-inputs `(("guile" ,guile-2.0)
1877                      ,@(alist-delete "guile"
1878                                      (package-native-inputs guile-redis))))))
1879
1880 (define-public guile2.2-redis
1881   (deprecated-package "guile2.2-redis" guile-redis))
1882
1883 (define-public guile-commonmark
1884   (package
1885     (name "guile-commonmark")
1886     (version "0.1.2")
1887     (source (origin
1888               (method url-fetch)
1889               (uri (string-append "https://github.com/OrangeShark/" name
1890                                   "/releases/download/v" version
1891                                   "/" name "-" version ".tar.gz"))
1892               (sha256
1893                (base32
1894                 "17lrsdisa3kckh24q114vfmzdc4wkqa6ccwl4hdlrng5wpn1iman"))))
1895     (build-system gnu-build-system)
1896     (inputs
1897      `(("guile" ,guile-2.2)))
1898     (native-inputs
1899      `(("pkg-config" ,pkg-config)))
1900     (synopsis "CommonMark parser for Guile")
1901     (description
1902      "guile-commonmark is a library for parsing CommonMark, a fully specified
1903 variant of Markdown.  The library is written in Guile Scheme and is designed
1904 to transform a CommonMark document to SXML.  guile-commonmark tries to closely
1905 follow the @uref{http://commonmark.org/, CommonMark spec}, the main difference
1906 is no support for parsing block and inline level HTML.")
1907     (home-page "https://github.com/OrangeShark/guile-commonmark")
1908     (license license:lgpl3+)))
1909
1910 (define-public guile2.0-commonmark
1911   (package
1912     (inherit guile-commonmark)
1913     (name "guile2.0-commonmark")
1914     (inputs `(("guile" ,guile-2.0)))))
1915
1916 (define-public guile2.2-commonmark
1917   (deprecated-package "guile2.2-commonmark" guile-commonmark))
1918
1919 (define-public mcron
1920   (package
1921     (name "mcron")
1922     (version "1.1.1")
1923     (source (origin
1924               (method url-fetch)
1925               (uri (string-append "mirror://gnu/mcron/mcron-"
1926                                   version ".tar.gz"))
1927               (sha256
1928                (base32
1929                 "1i9mcp6r6my61zfiydsm3n6my41mwvl7dfala4q29qx0zn1ynlm4"))))
1930     (build-system gnu-build-system)
1931     (arguments
1932      '(#:phases (modify-phases %standard-phases
1933                   (add-before 'check 'set-timezone
1934                     (lambda* (#:key inputs #:allow-other-keys)
1935                       ;; 'tests/job-specifier.scm' expects to be running in
1936                       ;; UTC-2 or something.
1937                       ;; FIXME: This issue is being investigated upstream, for
1938                       ;; now we'll just skip the tests (see below):
1939                       ;; <https://lists.gnu.org/archive/html/bug-mcron/2018-04/msg00005.html>.
1940                       (let ((tzdata (assoc-ref inputs "tzdata")))
1941                         (setenv "TZDIR"
1942                                 (string-append tzdata
1943                                                "/share/zoneinfo"))
1944                         (setenv "TZ" "UTC-2")
1945                         #t)))
1946                   (add-before 'check 'adjust-tests
1947                     (lambda _
1948                       (substitute* "tests/job-specifier.scm"
1949                         ;; (getpw) fails with "entry not found" in the build
1950                         ;; environment, so pass an argument.
1951                         (("\\(getpw\\)")
1952                          "(getpwnam (getuid))")
1953                         ;; The build environment lacks an entry for root in
1954                         ;; /etc/passwd.
1955                         (("\\(getpw 0\\)")
1956                          "(getpwnam \"nobody\")")
1957
1958                         ;; FIXME: Skip the 4 faulty tests (see above).
1959                         (("\\(test-equal \"next-year\"" all)
1960                          (string-append "(test-skip 4)\n" all)))
1961                       #t)))))
1962     (native-inputs `(("pkg-config" ,pkg-config)
1963                      ("tzdata" ,tzdata-for-tests)))
1964     (inputs `(("ed" ,ed) ("which" ,which) ("guile" ,guile-2.2)))
1965     (home-page "https://www.gnu.org/software/mcron/")
1966     (synopsis "Run jobs at scheduled times")
1967     (description
1968      "GNU Mcron is a complete replacement for Vixie cron.  It is used to run
1969 tasks on a schedule, such as every hour or every Monday.  Mcron is written in
1970 Guile, so its configuration can be written in Scheme; the original cron
1971 format is also supported.")
1972     (license license:gpl3+)))
1973
1974 (define-public mcron2
1975   ;; This was mthl's mcron development branch, and it became mcron 1.1.
1976   (deprecated-package "mcron2" mcron))
1977
1978 (define-public guile-picture-language
1979   (let ((commit "1ea8b78a8bceb4f7e5eaeb3e76987072267f99bb")
1980         (revision "2"))
1981     (package
1982       (name "guile-picture-language")
1983       (version (git-version "0" revision commit))
1984       (source (origin
1985                 (method git-fetch)
1986                 (uri (git-reference
1987                       (url "https://git.elephly.net/software/guile-picture-language.git")
1988                       (commit commit)))
1989                 (sha256
1990                  (base32
1991                   "1rvq6q2zq21x7dx0qq1hn568wglsl4bkd8gacbarcx1fs0rrxcqw"))))
1992       (build-system guile-build-system)
1993       (inputs
1994        `(("guile" ,guile-2.2)))
1995       (home-page "https://git.elephly.net/software/guile-picture-language.git")
1996       (synopsis "Picture language for Guile")
1997       (description
1998        "This package provides a simple SVG-based picture language for Guile.
1999 The picture values can directly be displayed in Geiser.")
2000       (license license:lgpl3+))))
2001
2002 (define-public guile-studio
2003   (let ((commit "e2da64f014942a73996286c4abe3c3b1f8bd220c")
2004         (revision "1"))
2005     (package
2006       (name "guile-studio")
2007       (version (git-version "0" revision commit))
2008       (source (origin
2009                 (method git-fetch)
2010                 (uri (git-reference
2011                       (url "https://git.elephly.net/software/guile-studio.git")
2012                       (commit commit)))
2013                 (sha256
2014                  (base32
2015                   "10v3kw41bzd8c2a6vxgrwbvl216d0k8f5s9h6pm8hahpd03jl7lm"))))
2016       (build-system gnu-build-system)
2017       (arguments
2018        `(#:tests? #f                      ; there are none
2019          #:phases
2020          (modify-phases %standard-phases
2021            (delete 'configure)
2022            (replace 'build
2023              (lambda* (#:key source inputs outputs #:allow-other-keys)
2024                (let* ((out   (assoc-ref outputs "out"))
2025                       (bin   (string-append out "/bin/"))
2026                       (share (string-append out "/share/")))
2027                  (mkdir-p share)
2028                  (mkdir-p bin)
2029                  (apply invoke "guile" "-s" "guile-studio-configure.scm"
2030                         out
2031                         (assoc-ref inputs "emacs")
2032                         (assoc-ref inputs "guile-picture-language")
2033                         (string-append (assoc-ref inputs "adwaita-icon-theme")
2034                                        "/share/icons/Adwaita/")
2035                         (map cdr inputs))
2036                  #t)))
2037            (delete 'install))))
2038       (inputs
2039        `(("guile" ,guile-2.2)
2040          ("guile-picture-language" ,guile-picture-language)
2041          ("emacs" ,emacs)
2042          ("emacs-geiser" ,emacs-geiser)
2043          ("emacs-company" ,emacs-company)
2044          ("emacs-flycheck" ,emacs-flycheck)
2045          ("emacs-smart-mode-line" ,emacs-smart-mode-line)
2046          ("emacs-paren-face" ,emacs-paren-face)
2047          ("adwaita-icon-theme" ,adwaita-icon-theme)))
2048       (home-page "https://gnu.org/software/guile")
2049       (synopsis "IDE for Guile")
2050       (description
2051        "This is Emacs with a few settings that make working with Guile easier
2052 for people new to Emacs.  Features include: CUA mode, Geiser, tool bar icons
2053 to evaluate Guile buffers, support for Guile's very own picture language, code
2054 completion, a simple mode line, etc.")
2055       (license license:gpl3+))))
2056
2057 (define-public guile-stis-parser
2058   (let ((commit "6e85d37ffc333b722f4413a6c648263701eb75bd")
2059         (revision "1"))
2060     (package
2061       (name "guile-stis-parser")
2062       (version (git-version "0" revision commit))
2063       (source (origin
2064                 (method git-fetch)
2065                 (uri (git-reference
2066                       (url "https://gitlab.com/tampe/stis-parser")
2067                       (commit commit)))
2068                 (file-name (git-file-name name version))
2069                 (sha256
2070                  (base32
2071                   "0v4hvq7rlpbra1ni73lf8k6sdmjlflr50yi3p1f24g85h77pc7c0"))))
2072       (build-system gnu-build-system)
2073       (arguments
2074        `(#:parallel-build? #f ; not supported
2075          #:phases
2076          (modify-phases %standard-phases
2077            (add-after 'unpack 'chdir
2078              (lambda _ (chdir "modules") #t))
2079            (add-after 'chdir 'use-canonical-directory-for-go-files
2080              (lambda _
2081                (substitute* "Makefile.am"
2082                  (("/ccache") "/site-ccache"))
2083                #t))
2084            (add-after 'chdir 'delete-broken-symlink
2085              (lambda _
2086                (delete-file "parser/stis-parser/lang/.#calc.scm")
2087                #t)))))
2088       (inputs
2089        `(("guile" ,guile-2.2)))
2090       (native-inputs
2091        `(("autoconf" ,autoconf)
2092          ("automake" ,automake)
2093          ("pkg-config" ,pkg-config)))
2094       (home-page "https://gitlab.com/tampe/stis-parser")
2095       (synopsis "Parser combinator framework")
2096       (description
2097        "This package provides a functional parser combinator library that
2098 supports backtracking and a small logical framework. The idea is to build up
2099 chunks that are memoized and there is no clear scanner/parser separation,
2100 chunks can be expressions as well as simple tokens.")
2101       (license license:lgpl2.0+))))
2102
2103 (define-public guile-persist
2104   (let ((commit "b14927b0368af51c024560aee5f55724aee35233")
2105         (revision "1"))
2106     (package
2107       (name "guile-persist")
2108       (version (git-version "0" revision commit))
2109       (source (origin
2110                 (method git-fetch)
2111                 (uri (git-reference
2112                       (url "https://gitlab.com/tampe/guile-persist")
2113                       (commit commit)))
2114                 (file-name (git-file-name name version))
2115                 (sha256
2116                  (base32
2117                   "0z5nf377wh8yj6n3sx2ddn4bdx1qrqnw899dlqjhg0q69qzil522"))))
2118       (build-system gnu-build-system)
2119       (arguments
2120        `(#:phases
2121          (modify-phases %standard-phases
2122            (add-after 'unpack 'patch-prefix
2123              (lambda* (#:key inputs outputs #:allow-other-keys)
2124                (substitute* "src/Makefile.am"
2125                  (("/usr/local/lib/guile")
2126                   (string-append (assoc-ref outputs "out") "/lib/guile"))
2127                  (("/usr/local/include/guile")
2128                   (string-append (assoc-ref inputs "guile") "/include/guile"))
2129                  (("-L/usr/local/lib")
2130                   (string-append "-L" (assoc-ref inputs "guile") "/lib"))
2131                  ;; Use canonical directory for go files.
2132                  (("/ccache") "/site-ccache"))
2133                #t))
2134            (add-after 'unpack 'patch-library-reference
2135              (lambda* (#:key outputs #:allow-other-keys)
2136                (let ((out (assoc-ref outputs "out")))
2137                  (substitute* "persist/persistance.scm"
2138                    (("\"libguile-persist\"")
2139                     (format #f "\"~a/lib/guile/2.2/extensions/libguile-persist\"" out)))
2140                  #t))))))
2141       (inputs
2142        `(("guile" ,guile-2.2)))
2143       (native-inputs
2144        `(("autoconf" ,autoconf)
2145          ("automake" ,automake)
2146          ("libtool" ,libtool)
2147          ("pkg-config" ,pkg-config)))
2148       (home-page "https://gitlab.com/tampe/guile-persist")
2149       (synopsis "Persistance programming framework for Guile")
2150       (description
2151        "This is a serialization library for serializing objects like classes
2152 and objects, closures and structs.  This currently does not support
2153 serializing continuations or delimited continuations.")
2154       (license license:lgpl2.0+))))
2155
2156 (define-public python-on-guile
2157   (let ((commit "0cb7c2b2fff4338ca6153473f3f5c409a818f293")
2158         (revision "1"))
2159     (package
2160       (name "python-on-guile")
2161       (version (git-version "0.1.0" revision commit))
2162       (source (origin
2163                 (method git-fetch)
2164                 (uri (git-reference
2165                       (url "https://gitlab.com/python-on-guile/python-on-guile.git")
2166                       (commit commit)))
2167                 (file-name (git-file-name name version))
2168                 (sha256
2169                  (base32
2170                   "0kpz08rrp5mwcf5ksc4flgrw992syham9x49dn9wq9w31bpcpnby"))))
2171       (build-system gnu-build-system)
2172       (arguments
2173        `(#:parallel-build? #f ; not supported
2174          #:make-flags
2175          '("GUILE_AUTO_COMPILE=0")        ; to prevent guild errors
2176          #:phases
2177          (modify-phases %standard-phases
2178            (add-after 'unpack 'chdir
2179              (lambda _ (chdir "modules") #t))
2180            (add-after 'chdir 'use-canonical-directory-for-go-files
2181              (lambda _
2182                (substitute* "Makefile.am"
2183                  (("/ccache") "/site-ccache"))
2184                #t)))))
2185       (inputs
2186        `(("guile" ,guile-2.2)))
2187       (propagated-inputs
2188        `(("guile-persist" ,guile-persist)
2189          ("guile-readline" ,guile-readline)
2190          ("guile-stis-parser" ,guile-stis-parser)))
2191       (native-inputs
2192        `(("autoconf" ,autoconf)
2193          ("automake" ,automake)
2194          ("libtool" ,libtool)
2195          ("pkg-config" ,pkg-config)))
2196       (home-page "https://gitlab.com/python-on-guile/python-on-guile/")
2197       (synopsis "Python implementation in Guile")
2198       (description
2199        "This package allows you to compile a Guile Python file to any target
2200 from @code{tree-il}.")
2201       (license license:lgpl2.0+))))
2202
2203 (define-public guile-file-names
2204   (package
2205     (name "guile-file-names")
2206     (version "0.2")
2207     (source (origin
2208               (method url-fetch)
2209               (uri (string-append "http://brandon.invergo.net/software/download/"
2210                                   "guile-file-names/guile-file-names-"
2211                                   version ".tar.gz"))
2212               (sha256
2213                (base32
2214                 "1kwx5hanl40960w2nhyga7ry4l6c3c57zdrihk4yajj87vn3pmi8"))))
2215     (build-system gnu-build-system)
2216     (arguments
2217      `(#:phases
2218        (modify-phases %standard-phases
2219          (add-after 'unpack 'fix-target-directory
2220            (lambda _
2221              (substitute* "src/Makefile.in"
2222                (("guilemoddir = \\$\\(GUILE_SITE\\)")
2223                 "guilemoddir = $(datadir)/guile/site/$(GUILE_EFFECTIVE_VERSION)\n"))
2224              #t)))))
2225     (inputs
2226      `(("guile" ,guile-2.2)))
2227     (native-inputs
2228      `(("pkg-config" ,pkg-config)))
2229     (home-page "https://gitlab.com/brandoninvergo/guile-file-names")
2230     (synopsis "Manipulate file names")
2231     (description
2232      "The @code{(file-names)} module provides tools for manipulating file
2233 names.  The module was built on the idea that doing anything more than a
2234 non-trivial modification of a file name string is a pain (making sure all
2235 slashes are present and accounted for, resolving @code{.} and @code{..}, etc).
2236 Inevitably, you have to break the string up into chunks and operate on that
2237 list of components.  This module takes care of that for you.")
2238     (license license:lgpl3+)))
2239
2240 (define-public guile-gi
2241   (let ((commit "26e885219ae6b31a83766564a2ecfe8c4532346f")
2242         (revision "1"))
2243     (package
2244       (name "guile-gi")
2245       (version (string-append "0.0.1-" revision "." (string-take commit 7)))
2246       (source (origin
2247                 (method git-fetch)
2248                 (uri (git-reference
2249                       (url "https://github.com/spk121/guile-gi.git")
2250                       (commit commit)))
2251                 (file-name (string-append name "-" version))
2252                 (sha256
2253                  (base32
2254                   "1prbzhr4sqqihb34l6yfrz6sd8nghwd3q9wvbm36jnl2n3z2nxj8"))))
2255       (build-system gnu-build-system)
2256       (native-inputs `(("autoconf" ,autoconf)
2257                        ("automake" ,automake)
2258                        ("gettext" ,gnu-gettext)
2259                        ("libtool" ,libtool)
2260                        ("pkg-config" ,pkg-config)
2261                        ("texinfo" ,texinfo)))
2262       (propagated-inputs `(("glib" ,glib)
2263                            ("gobject-introspection" ,gobject-introspection)
2264                            ("gssettings-desktop-schemas" ,gsettings-desktop-schemas)
2265                            ("gtk+" ,gtk+)
2266                            ("guile-lib" ,guile-lib)
2267                            ("webkitgtk" ,webkitgtk)))
2268       (inputs `(("guile" ,guile-2.2)))
2269       (arguments
2270        `(#:configure-flags '("--with-gnu-filesystem-hierarchy")))
2271       (home-page "https://github.com/spk121/guile-gi")
2272       (synopsis "GObject bindings for Guile")
2273       (description
2274        "Guile-GI is a library for Guile that allows using GObject-based
2275 libraries, such as GTK+3.  Its README comes with the disclaimer: This is
2276 pre-alpha code.")
2277       (license license:gpl3+))))
2278
2279 (define-public guile-srfi-159
2280   (let ((commit "1bd98abda2ae4ef8f36761a167903e55c6bda7bb")
2281         (revision "0"))
2282     (package
2283       (name "guile-srfi-159")
2284       (version (git-version "0" revision commit))
2285       (home-page "https://bitbucket.org/bjoli/guile-srfi-159")
2286       (source (origin
2287                 (method hg-fetch)
2288                 (uri (hg-reference (changeset commit)
2289                                    (url home-page)))
2290                 (sha256
2291                  (base32
2292                   "1zw6cmcy7xdbfiz3nz9arqnn7l2daidaps6ixkcrc9b6k51fdv3p"))
2293                 (file-name (git-file-name name version))))
2294       (build-system guile-build-system)
2295       (arguments
2296        ;; The *-impl.scm files are actually included from module files; they
2297        ;; should not be compiled separately, but they must be installed.
2298        '(#:not-compiled-file-regexp "-impl\\.scm$"))
2299       (inputs
2300        `(("guile" ,guile-2.2)))
2301       (synopsis "Formatting combinators for Guile")
2302       (description
2303        "The @code{(srfi-159)} module and its sub-modules implement the
2304 formatting combinators specified by
2305 @uref{https://srfi.schemers.org/srfi-159/srfi-159.html, SRFI-159}.  These are
2306 more expressive and flexible than the traditional @code{format} procedure.")
2307       (license license:bsd-3))))