gnu/packages/guile.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 Cyril Roelandt <tipecaml@gmail.com>
   4 ;;; Copyright © 2014, 2016, 2018 David Thompson <davet@gnu.org>
   5 ;;; Copyright © 2014, 2017, 2018 Mark H Weaver <mhw@netris.org>
   6 ;;; Copyright © 2015, 2017 Christopher Allan Webber <cwebber@dustycloud.org>
   7 ;;; Copyright © 2016 Jan Nieuwenhuizen <janneke@gnu.org>
   8 ;;; Copyright © 2016, 2017 Leo Famulari <leo@famulari.name>
   9 ;;; Copyright © 2016, 2019 Ricardo Wurmus <rekado@elephly.net>
  10 ;;; Copyright © 2017 Andy Wingo <wingo@igalia.com>
  11 ;;; Copyright © 2017 Marius Bakke <mbakke@fastmail.com>
  12 ;;; Copyright © 2017 Mathieu Othacehe <m.othacehe@gmail.com>
  13 ;;; Copyright © 2017 Tobias Geerinckx-Rice <me@tobias.gr>
  14 ;;; Copyright © 2017, 2018 Amirouche <amirouche@hypermove.net>
  15 ;;; Copyright © 2018 Danny Milosavljevic <dannym@scratchpost.org>
  16 ;;; Copyright © 2018 Eric Bavier <bavier@member.fsf.org>
  17 ;;; Copyright © 2019 Taylan Kammer <taylan.kammer@gmail.com>
  18 ;;;
  19 ;;; This file is part of GNU Guix.
  20 ;;;
  21 ;;; GNU Guix is free software; you can redistribute it and/or modify it
  22 ;;; under the terms of the GNU General Public License as published by
  23 ;;; the Free Software Foundation; either version 3 of the License, or (at
  24 ;;; your option) any later version.
  25 ;;;
  26 ;;; GNU Guix is distributed in the hope that it will be useful, but
  27 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
  28 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29 ;;; GNU General Public License for more details.
  30 ;;;
  31 ;;; You should have received a copy of the GNU General Public License
  32 ;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.
  33
  34 (define-module (gnu packages guile)
  35   #:use-module ((guix licenses) #:prefix license:)
  36   #:use-module (gnu packages)
  37   #:use-module (gnu packages autotools)
  38   #:use-module (gnu packages base)
  39   #:use-module (gnu packages bash)
  40   #:use-module (gnu packages bdw-gc)
  41   #:use-module (gnu packages compression)
  42   #:use-module (gnu packages dbm)
  43   #:use-module (gnu packages flex)
  44   #:use-module (gnu packages gawk)
  45   #:use-module (gnu packages gettext)
  46   #:use-module (gnu packages hurd)
  47   #:use-module (gnu packages libffi)
  48   #:use-module (gnu packages libunistring)
  49   #:use-module (gnu packages linux)
  50   #:use-module (gnu packages m4)
  51   #:use-module (gnu packages multiprecision)
  52   #:use-module (gnu packages pkg-config)
  53   #:use-module (gnu packages readline)
  54   #:use-module (gnu packages sqlite)
  55   #:use-module (gnu packages texinfo)
  56   #:use-module (gnu packages version-control)
  57   #:use-module (guix packages)
  58   #:use-module (guix download)
  59   #:use-module (guix git-download)
  60   #:use-module (guix build-system gnu)
  61   #:use-module (guix build-system guile)
  62   #:use-module (guix utils)
  63   #:use-module (ice-9 match)
  64   #:use-module ((srfi srfi-1) #:prefix srfi-1:))
  65
  66 ;;; Commentary:
  67 ;;;
  68 ;;; GNU Guile, and modules and extensions.
  69 ;;;
  70 ;;; Code:
  71
  72 (define-public guile-1.8
  73   (package
  74    (name "guile")
  75    (version "1.8.8")
  76    (source (origin
  77             (method url-fetch)
  78             (uri (string-append "mirror://gnu/guile/guile-" version
  79                                 ".tar.gz"))
  80             (sha256
  81              (base32
  82               "0l200a0v7h8bh0cwz6v7hc13ds39cgqsmfrks55b1rbj5vniyiy3"))
  83             (patches (search-patches "guile-1.8-cpp-4.5.patch"))))
  84    (build-system gnu-build-system)
  85    (arguments '(#:configure-flags '("--disable-error-on-warning")
  86
  87                 ;; Insert a phase before `configure' to patch things up.
  88                 #:phases
  89                 (modify-phases %standard-phases
  90                   (add-before 'configure 'patch-stuff
  91                     (lambda* (#:key outputs #:allow-other-keys)
  92                       ;; Add a call to `lt_dladdsearchdir' so that
  93                       ;; `libguile-readline.so' & co. are in the
  94                       ;; loader's search path.
  95                       (substitute* "libguile/dynl.c"
  96                         (("lt_dlinit.*$" match)
  97                          (format #f
  98                                  "  ~a~%  lt_dladdsearchdir(\"~a/lib\");~%"
  99                                  match
 100                                  (assoc-ref outputs "out"))))
 101
 102                       ;; The usual /bin/sh...
 103                       (substitute* "ice-9/popen.scm"
 104                         (("/bin/sh") (which "sh")))
 105                       #t)))))
 106
 107    ;; When cross-compiling, a native version of Guile itself is needed.
 108    (native-inputs (if (%current-target-system)
 109                       `(("self" ,this-package))
 110                       '()))
 111
 112    (inputs `(("gawk" ,gawk)
 113              ("readline" ,readline)))
 114
 115    ;; Since `guile-1.8.pc' has "Libs: ... -lgmp -lltdl", these must be
 116    ;; propagated.
 117    (propagated-inputs `(("gmp" ,gmp)
 118                         ("libltdl" ,libltdl)))
 119
 120    (native-search-paths
 121     (list (search-path-specification
 122            (variable "GUILE_LOAD_PATH")
 123            (files '("share/guile/site")))))
 124
 125    (synopsis "Scheme implementation intended especially for extensions")
 126    (description
 127     "Guile is the GNU Ubiquitous Intelligent Language for Extensions, the
 128 official extension language of the GNU system.  It is an implementation of
 129 the Scheme language which can be easily embedded in other applications to
 130 provide a convenient means of extending the functionality of the application
 131 without requiring the source code to be rewritten.")
 132    (home-page "https://www.gnu.org/software/guile/")
 133    (license license:lgpl2.0+)))
 134
 135 (define-public guile-2.0
 136   (package
 137    (name "guile")
 138    (version "2.0.14")
 139    (source (origin
 140             (method url-fetch)
 141             (uri (string-append "mirror://gnu/guile/guile-" version
 142                                 ".tar.xz"))
 143             (sha256
 144              (base32
 145               "10lxc6l5alf3lzbs3ihnbfy6dfcrsyf8667wa57f26vf4mk2ai78"))))
 146    (build-system gnu-build-system)
 147
 148    ;; When cross-compiling, a native version of Guile itself is needed.
 149    (native-inputs `(,@(if (%current-target-system)
 150                           `(("self" ,this-package))
 151                           '())
 152                     ("pkgconfig" ,pkg-config)))
 153    (inputs `(("libffi" ,libffi)
 154              ,@(libiconv-if-needed)
 155
 156              ;; We need Bash when cross-compiling because some of the scripts
 157              ;; in bin/ refer to it.  Use 'bash-minimal' because we don't need
 158              ;; an interactive Bash with Readline and all.
 159              ,@(if (target-mingw?) '() `(("bash" ,bash-minimal)))))
 160    (propagated-inputs
 161     `( ;; These ones aren't normally needed here, but since `libguile-2.0.la'
 162        ;; reads `-lltdl -lunistring', adding them here will add the needed
 163        ;; `-L' flags.  As for why the `.la' file lacks the `-L' flags, see
 164        ;; <http://thread.gmane.org/gmane.comp.lib.gnulib.bugs/18903>.
 165       ("libunistring" ,libunistring)
 166
 167       ;; Depend on LIBLTDL, not LIBTOOL.  That way, we avoid some the extra
 168       ;; dependencies that LIBTOOL has, which is helpful during bootstrap.
 169       ("libltdl" ,libltdl)
 170
 171       ;; The headers and/or `guile-2.0.pc' refer to these packages, so they
 172       ;; must be propagated.
 173       ("bdw-gc" ,libgc)
 174       ("gmp" ,gmp)))
 175
 176    (outputs '("out" "debug"))
 177
 178    (arguments
 179     `(#:configure-flags '("--disable-static") ; saves 3 MiB
 180       #:phases
 181       (modify-phases %standard-phases
 182         (add-before 'configure 'pre-configure
 183           (lambda* (#:key inputs #:allow-other-keys)
 184             ;; Tell (ice-9 popen) the file name of Bash.
 185             (let ((bash (assoc-ref inputs "bash")))
 186               (substitute* "module/ice-9/popen.scm"
 187                 ;; If bash is #f allow fallback for user to provide
 188                 ;; "bash" in PATH.  This happens when cross-building to
 189                 ;; MinGW for which we do not have Bash yet.
 190                 (("/bin/sh")
 191                  ,@(if (target-mingw?)
 192                        '((if bash
 193                              (string-append bash "/bin/bash")
 194                              "bash"))
 195                        '((string-append bash "/bin/bash")))))
 196               #t))))))
 197
 198    (native-search-paths
 199     (list (search-path-specification
 200            (variable "GUILE_LOAD_PATH")
 201            (files '("share/guile/site/2.0")))
 202           (search-path-specification
 203            (variable "GUILE_LOAD_COMPILED_PATH")
 204            (files '("lib/guile/2.0/site-ccache")))))
 205
 206    (synopsis "Scheme implementation intended especially for extensions")
 207    (description
 208     "Guile is the GNU Ubiquitous Intelligent Language for Extensions, the
 209 official extension language of the GNU system.  It is an implementation of
 210 the Scheme language which can be easily embedded in other applications to
 211 provide a convenient means of extending the functionality of the application
 212 without requiring the source code to be rewritten.")
 213    (home-page "https://www.gnu.org/software/guile/")
 214    (license license:lgpl3+)))
 215
 216 (define-public guile-2.2
 217   (package (inherit guile-2.0)
 218     (name "guile")
 219     (version "2.2.4")
 220     (source (origin
 221               (method url-fetch)
 222
 223               ;; Note: we are limited to one of the compression formats
 224               ;; supported by the bootstrap binaries, so no lzip here.
 225               (uri (string-append "mirror://gnu/guile/guile-" version
 226                                   ".tar.xz"))
 227               (sha256
 228                (base32
 229                 "07p3g0v2ba2vlfbfidqzlgbhnzdx46wh2rgc5gszq1mjyx5bks6r"))
 230               (modules '((guix build utils)))
 231
 232               ;; Remove the pre-built object files.  Instead, build everything
 233               ;; from source, at the expense of significantly longer build
 234               ;; times (almost 3 hours on a 4-core Intel i5).
 235               (snippet '(begin
 236                           (for-each delete-file
 237                                     (find-files "prebuilt" "\\.go$"))
 238                           #t))))
 239     (properties '((timeout . 72000)               ;20 hours
 240                   (max-silent-time . 36000)))     ;10 hours (needed on ARM
 241                                                   ;  when heavily loaded)
 242     (native-search-paths
 243      (list (search-path-specification
 244             (variable "GUILE_LOAD_PATH")
 245             (files '("share/guile/site/2.2")))
 246            (search-path-specification
 247             (variable "GUILE_LOAD_COMPILED_PATH")
 248             (files '("lib/guile/2.2/site-ccache")))))
 249
 250     (arguments
 251      (if (%current-target-system)
 252          (substitute-keyword-arguments (package-arguments guile-2.0)
 253            ((#:phases phases '%standard-phases)
 254             `(modify-phases ,phases
 255                (add-after 'unpack 'sacrifice-elisp-support
 256                  (lambda _
 257                    ;; Cross-compiling language/elisp/boot.el fails, so
 258                    ;; sacrifice it.  See
 259                    ;; <https://git.savannah.gnu.org/cgit/guile.git/commit/?h=stable-2.2&id=988aa29238fca862c7e2cb55f15762a69b4c16ce>
 260                    ;; for the upstream fix.
 261                    (substitute* "module/Makefile.in"
 262                      (("language/elisp/boot\\.el")
 263                       "\n"))
 264                    #t))
 265                ,@(if (hurd-target?)
 266                      `((add-after 'unpack 'allow-madvise-ENOSYS
 267                          (lambda _
 268                            ;; Do not warn about ENOSYS on 'madvise'.  This is
 269                            ;; what Guile commit
 270                            ;; 45e4ace6603e00b297e6542362273041aebe7305 does.
 271                            ;; TODO: Remove for Guile >= 2.2.5.
 272                            (substitute* "libguile/vm.c"
 273                              (("perror \\(\"madvise failed\"\\)")
 274                               "if (errno != ENOSYS) perror (\"madvised failed\");"))
 275                            #t)))
 276                      '()))))
 277          (package-arguments guile-2.0)))))
 278
 279 (define-public guile-2.2/fixed
 280   ;; A package of Guile 2.2 that's rarely changed.  It is the one used
 281   ;; in the `base' module, and thus changing it entails a full rebuild.
 282   (package
 283     (inherit guile-2.2)
 284     (properties '((hidden? . #t)            ;people should install 'guile-2.2'
 285                   (timeout . 72000)             ;20 hours
 286                   (max-silent-time . 36000))))) ;10 hours (needed on ARM
 287                                                 ;  when heavily loaded)
 288
 289 (define-public guile-next
 290   ;; This is the upcoming Guile 3.0, with JIT support.
 291   (let ((commit "6f3357b0df64c4be17e72079864c09a542f1c779")
 292         (revision "1"))
 293     (package
 294       (inherit guile-2.2)
 295       (name "guile-next")
 296       (version "2.9.1")
 297       (source (origin
 298                 (inherit (package-source guile-2.2))
 299                 (uri (string-append "https://alpha.gnu.org/gnu/guile/guile-"
 300                                     version ".tar.xz"))
 301                 (sha256
 302                  (base32
 303                   "0iba93yqn6mvgid0rfsrg4amym36pg9m8cqdplxsy222blrj9gh1"))))
 304       (native-search-paths
 305        (list (search-path-specification
 306               (variable "GUILE_LOAD_PATH")
 307               (files '("share/guile/site/3.0")))
 308              (search-path-specification
 309               (variable "GUILE_LOAD_COMPILED_PATH")
 310               (files '("lib/guile/3.0/site-ccache"
 311                        "share/guile/site/3.0")))))
 312       (properties '((ftp-server . "alpha.gnu.org")
 313                     (upstream-name . "guile"))))))
 314
 315 (define (make-guile-readline guile)
 316   (package
 317     (name "guile-readline")
 318     (version (package-version guile))
 319     (source (package-source guile))
 320     (build-system gnu-build-system)
 321     (arguments
 322      '(#:configure-flags '("--disable-silent-rules")
 323        #:phases (modify-phases %standard-phases
 324                   (add-before 'build 'chdir
 325                     (lambda* (#:key outputs #:allow-other-keys)
 326                       (invoke "make" "-C" "libguile" "scmconfig.h")
 327                       (invoke "make" "-C" "lib")
 328                       (chdir "guile-readline")
 329
 330                       (substitute* "Makefile"
 331                         (("../libguile/libguile-[[:graph:]]+\\.la")
 332                          ;; Remove dependency on libguile-X.Y.la.
 333                          "")
 334                         (("^READLINE_LIBS = (.*)$" _ libs)
 335                          ;; Link against the provided libguile.
 336                          (string-append "READLINE_LIBS = "
 337                                         "-lguile-$(GUILE_EFFECTIVE_VERSION) "
 338                                         libs "\n"))
 339                         (("\\$\\(top_builddir\\)/meta/build-env")
 340                          ;; Use the provided Guile, not the one from
 341                          ;; $(builddir).
 342                          "")
 343
 344                         ;; Install modules to the 'site' directories.
 345                         (("^moddir = .*$")
 346                          "moddir = $(pkgdatadir)/site/$(GUILE_EFFECTIVE_VERSION)\n")
 347                         (("^ccachedir = .*$")
 348                          "ccachedir = $(pkglibdir)/$(GUILE_EFFECTIVE_VERSION)/site-ccache\n"))
 349
 350                       ;; Load 'guile-readline.so' from the right place.
 351                       (substitute* "ice-9/readline.scm"
 352                         (("load-extension \"guile-readline\"")
 353                          (format #f "load-extension \
 354  (string-append ~s \"/lib/guile/\" (effective-version) \"/extensions/guile-readline\")"
 355                                  (assoc-ref outputs "out"))))
 356                       #t)))))
 357     (home-page (package-home-page guile))
 358     (native-inputs (package-native-inputs guile))
 359     (inputs
 360      `(,@(package-inputs guile)                   ;to placate 'configure'
 361        ,@(package-propagated-inputs guile)
 362        ("guile" ,guile)
 363        ("readline" ,readline)))
 364     (synopsis "Line editing support for GNU Guile")
 365     (description
 366      "This module provides line editing support via the Readline library for
 367 GNU@tie{}Guile.  Use the @code{(ice-9 readline)} module and call its
 368 @code{activate-readline} procedure to enable it.")
 369     (license license:gpl3+)))
 370
 371 (define-public guile-readline
 372   (make-guile-readline guile-2.2))
 373
 374 (define (guile-variant-package-name prefix)
 375   (lambda (name)
 376     "Return NAME with PREFIX instead of \"guile-\", when applicable."
 377     (if (string-prefix? "guile-" name)
 378         (string-append prefix "-"
 379                        (string-drop name
 380                                     (string-length "guile-")))
 381         name)))
 382
 383 (define package-for-guile-2.0
 384   ;; A procedure that rewrites the dependency tree of the given package to use
 385   ;; GUILE-2.0 instead of GUILE-2.2.
 386   (package-input-rewriting `((,guile-2.2 . ,guile-2.0))
 387                            (guile-variant-package-name "guile2.0")))
 388
 389 (define-public guile-for-guile-emacs
 390   (package (inherit guile-2.2)
 391     (name "guile-for-guile-emacs")
 392     (version "20150510.d8d9a8d")
 393     (source (origin
 394               (method git-fetch)
 395               (uri (git-reference
 396                     (url "git://git.hcoop.net/git/bpt/guile.git")
 397                     (commit "d8d9a8da05ec876acba81a559798eb5eeceb5a17")))
 398               (file-name (string-append name "-" version "-checkout"))
 399               (sha256
 400                (base32
 401                 "00sprsshy16y8pxjy126hr2adqcvvzzz96hjyjwgg8swva1qh6b0"))))
 402     (arguments
 403      `(;; Tests aren't passing for now.
 404        ;; Obviously we should re-enable this!
 405        #:tests? #f
 406        ,@(package-arguments guile-2.2)))
 407     (native-inputs
 408      `(("autoconf" ,autoconf)
 409        ("automake" ,automake)
 410        ("libtool" ,libtool)
 411        ("flex" ,flex)
 412        ("texinfo" ,texinfo)
 413        ("gettext" ,gettext-minimal)
 414        ,@(package-native-inputs guile-2.2)))
 415     ;; Same as in guile-2.0
 416     (native-search-paths
 417      (list (search-path-specification
 418             (variable "GUILE_LOAD_PATH")
 419             (files '("share/guile/site/2.0")))
 420            (search-path-specification
 421             (variable "GUILE_LOAD_COMPILED_PATH")
 422             (files '("lib/guile/2.0/site-ccache"
 423                      "share/guile/site/2.0")))))))
 424
 425 \f
 426 ;;;
 427 ;;; Extensions.
 428 ;;;
 429
 430 (define-public guile-json
 431   (package
 432     (name "guile-json")
 433     (version "1.2.0")
 434     (home-page "https://github.com/aconchillo/guile-json")
 435     (source (origin
 436               (method url-fetch)
 437               (uri (string-append "https://download.savannah.nongnu.org/releases/"
 438                                   name "/" name "-" version ".tar.gz"))
 439               (sha256
 440                (base32
 441                 "15gnb84d7hpazqhskkf3g9z4r6knw54wfj4ch5270kakz1lp70c9"))))
 442     (build-system gnu-build-system)
 443     (native-inputs `(("pkg-config" ,pkg-config)
 444                      ("guile" ,guile-2.2)))
 445     (inputs `(("guile" ,guile-2.2)))
 446     (synopsis "JSON module for Guile")
 447     (description
 448      "Guile-JSON supports parsing and building JSON documents according to the
 449 specification.  These are the main features:
 450
 451 @itemize
 452 @item Strictly complies to @uref{http://json.org, specification}.
 453 @item Build JSON documents programmatically via macros.
 454 @item Unicode support for strings.
 455 @item Allows JSON pretty printing.
 456 @end itemize\n")
 457
 458     ;; Version 1.2.0 switched to GPLv3+ (from LGPLv3+).
 459     (license license:gpl3+)))
 460
 461 (define-public guile2.2-json
 462   (deprecated-package "guile2.2-json" guile-json))
 463
 464 (define-public guile2.0-json
 465   (package-for-guile-2.0 guile-json))
 466
 467 (define-public guile-json-3
 468   ;; This version is incompatible with 1.x; see the 'NEWS' file.
 469   (package
 470     (inherit guile-json)
 471     (name "guile-json")
 472     (version "3.1.0")
 473     (source (origin
 474               (method url-fetch)
 475               (uri (string-append "https://download.savannah.nongnu.org/releases/"
 476                                   name "/" name "-" version ".tar.gz"))
 477               (sha256
 478                (base32
 479                 "1yfqscz74i4vxylabd3s9l0wbdp8bg9qxnv1ixdm3b1l7zdx00z3"))))))
 480
 481 ;; There are two guile-gdbm packages, one using the FFI and one with
 482 ;; direct C bindings, hence the verbose name.
 483
 484 (define-public guile-gdbm-ffi
 485   (package
 486     (name "guile-gdbm-ffi")
 487     (version "20120209.fa1d5b6")
 488     (source (origin
 489               (method git-fetch)
 490               (uri (git-reference
 491                     (url "https://github.com/ijp/guile-gdbm.git")
 492                     (commit "fa1d5b6231d0e4d096687b378c025f2148c5f246")))
 493               (file-name (string-append name "-" version "-checkout"))
 494               (patches (search-patches
 495                         "guile-gdbm-ffi-support-gdbm-1.14.patch"))
 496               (sha256
 497                (base32
 498                 "1j8wrsw7v9w6qkl47xz0rdikg50v16nn6kbs3lgzcymjzpa7babj"))))
 499     (build-system guile-build-system)
 500     (arguments
 501      '(#:phases (modify-phases %standard-phases
 502                   (add-after 'unpack 'move-examples
 503                     (lambda* (#:key outputs #:allow-other-keys)
 504                       ;; Move examples where they belong.
 505                       (let* ((out (assoc-ref outputs "out"))
 506                              (doc (string-append out "/share/doc/"
 507                                                  (strip-store-file-name out)
 508                                                  "/examples")))
 509                         (copy-recursively "examples" doc)
 510                         (delete-file-recursively "examples")
 511                         #t)))
 512                   (add-after 'unpack 'set-libgdbm-file-name
 513                     (lambda* (#:key inputs #:allow-other-keys)
 514                       (substitute* "gdbm.scm"
 515                         (("\\(dynamic-link \"libgdbm\"\\)")
 516                          (format #f "(dynamic-link \"~a/lib/libgdbm.so\")"
 517                                  (assoc-ref inputs "gdbm"))))
 518                       #t)))))
 519     (native-inputs
 520      `(("guile" ,guile-2.2)))
 521     (inputs
 522      `(("gdbm" ,gdbm)))
 523     (home-page "https://github.com/ijp/guile-gdbm")
 524     (synopsis "Guile bindings to the GDBM library via Guile's FFI")
 525     (description
 526      "Guile bindings to the GDBM key-value storage system, using
 527 Guile's foreign function interface.")
 528     (license license:gpl3+)))
 529
 530 (define-public guile2.0-gdbm-ffi
 531   (package-for-guile-2.0 guile-gdbm-ffi))
 532
 533 (define-public guile2.2-gdbm-ffi
 534   (deprecated-package "guile2.2-gdbm-ffi" guile-gdbm-ffi))
 535
 536 (define-public guile-sqlite3
 537   (package
 538     (name "guile-sqlite3")
 539     (version "0.1.0")
 540     (home-page "https://notabug.org/guile-sqlite3/guile-sqlite3.git")
 541     (source (origin
 542               (method git-fetch)
 543               (uri (git-reference
 544                     (url home-page)
 545                     (commit (string-append "v" version))))
 546               (sha256
 547                (base32
 548                 "1nv8j7wk6b5n4p22szyi8lv8fs31rrzxhzz16gyj8r38c1fyp9qp"))
 549               (file-name (string-append name "-" version "-checkout"))))
 550     (build-system gnu-build-system)
 551     (native-inputs
 552      `(("autoconf" ,autoconf)
 553        ("automake" ,automake)
 554        ("pkg-config" ,pkg-config)))
 555     (inputs
 556      `(("guile" ,guile-2.2)
 557        ("sqlite" ,sqlite)))
 558     (synopsis "Access SQLite databases from Guile")
 559     (description
 560      "This package provides Guile bindings to the SQLite database system.")
 561     (license license:gpl3+)))
 562
 563 (define-public guile2.0-sqlite3
 564   (package-for-guile-2.0 guile-sqlite3))
 565
 566 (define-public guile-bytestructures
 567   (package
 568     (name "guile-bytestructures")
 569     (version "1.0.5")
 570     (source (origin
 571               (method url-fetch)
 572               (uri (string-append "https://github.com/TaylanUB/scheme-bytestructures"
 573                                   "/releases/download/v" version
 574                                   "/bytestructures-" version ".tar.gz"))
 575               (sha256
 576                (base32
 577                 "0ibk7fjwpb450lnrva4bx45sgln3pbyb645az4ansvh1spgani43"))))
 578     (build-system gnu-build-system)
 579     (native-inputs
 580      `(("pkg-config" ,pkg-config)))
 581     (inputs
 582      `(("guile" ,guile-2.2)))
 583     (home-page "https://github.com/TaylanUB/scheme-bytestructures")
 584     (synopsis "Structured access to bytevector contents for Guile")
 585     (description
 586      "Guile bytestructures offers a system imitating the type system
 587 of the C programming language, to be used on bytevectors.  C's type
 588 system works on raw memory, and Guile works on bytevectors which are
 589 an abstraction over raw memory.  It's also more powerful than the C
 590 type system, elevating types to first-class status.")
 591     (license license:gpl3+)))
 592
 593 (define-public guile2.0-bytestructures
 594   (package-for-guile-2.0 guile-bytestructures))
 595
 596 (define-public guile-git
 597   (package
 598     (name "guile-git")
 599     (version "0.2.0")
 600     (home-page "https://gitlab.com/guile-git/guile-git.git")
 601     (source (origin
 602               (method git-fetch)
 603               (uri (git-reference (url home-page)
 604                                   (commit (string-append "v" version))))
 605               (sha256
 606                (base32
 607                 "018hmfsh0rjwfvr4h7y10jc6k8a2k9xsirngghy3pjasin4nd2yz"))
 608               (file-name (git-file-name name version))))
 609     (build-system gnu-build-system)
 610     (native-inputs
 611      `(("autoconf" ,autoconf)
 612        ("automake" ,automake)
 613        ("texinfo" ,texinfo)
 614        ("pkg-config" ,pkg-config)))
 615     (inputs
 616      `(("guile" ,guile-2.2)
 617        ("libgit2" ,libgit2)))
 618     (propagated-inputs
 619      `(("guile-bytestructures" ,guile-bytestructures)))
 620     (synopsis "Guile bindings for libgit2")
 621     (description
 622      "This package provides Guile bindings to libgit2, a library to
 623 manipulate repositories of the Git version control system.")
 624     (license license:gpl3+)))
 625
 626 (define-public guile2.0-git
 627   (package-for-guile-2.0 guile-git))
 628
 629 ;;; guile.scm ends here
 630