;;; GNU Guix --- Functional package management for GNU
;;; Copyright © 2016 David Craven <david@craven.ch>
;;; Copyright © 2016 Eric Le Bihan <eric.le.bihan.dev@free.fr>
;;; Copyright © 2016, 2017 ng0 <ng0@libertad.pw>
;;;
;;; This file is part of GNU Guix.
;;;
;;; GNU Guix is free software; you can redistribute it and/or modify it
;;; under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 3 of the License, or (at
;;; your option) any later version.
;;;
;;; GNU Guix is distributed in the hope that it will be useful, but
;;; WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with GNU Guix.  If not, see <http://www.gnu.org/licenses/>.

(define-module (gnu packages rust)
  #:use-module (gnu packages base)
  #:use-module (gnu packages bootstrap)
  #:use-module (gnu packages cmake)
  #:use-module (gnu packages compression)
  #:use-module (gnu packages elf)
  #:use-module (gnu packages gcc)
  #:use-module (gnu packages jemalloc)
  #:use-module (gnu packages llvm)
  #:use-module (gnu packages python)
  #:use-module (gnu packages qt)
  #:use-module (gnu packages tls)
  #:use-module (gnu packages version-control)
  #:use-module (guix build-system gnu)
  #:use-module (guix build-system trivial)
  #:use-module (guix build-system cargo)
  #:use-module (guix download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages)
  #:use-module (ice-9 match)
  #:use-module (srfi srfi-26))

;; Should be one less than the current released version.
(define %rust-bootstrap-binaries-version "1.13.0")

(define %rust-bootstrap-binaries
  (origin
    (method url-fetch)
    (uri (string-append
          "https://static.rust-lang.org/dist/"
          "rust-" %rust-bootstrap-binaries-version
          "-i686-unknown-linux-gnu.tar.gz"))
    (sha256
     (base32
      "0fcl7xgm2m21sjv1f27i3v692aa91lk8r867hl8d6l377w8k95r3"))))

(define (increment-rust-version rust-version major patch)
  (match (string-split rust-version #\.)
    (("1" minor _)
     (string-append (number->string major) "."
                    (number->string (+ (string->number minor) 1)) "."
                    (number->string patch)))))

(define* (cargo-version rustc-version #:optional (patch 0))
  ;; Computes the cargo version that matches the rustc version.
  ;; https://github.com/rust-lang/cargo#Releases
  (increment-rust-version rustc-version 0 patch))

(define* (rustc-version bootstrap-version #:optional (patch 0))
  ;; Computes the rustc version that can be compiled from a given
  ;; other rustc version. The patch argument is for selecting
  ;; a stability or security fix. 1.11.0 -> 1.12.1 -> 1.13.0
  (increment-rust-version bootstrap-version 1 patch))

(define rustc-bootstrap
  (package
    (name "rustc-bootstrap")
    (version %rust-bootstrap-binaries-version)
    (source %rust-bootstrap-binaries)
    (build-system gnu-build-system)
    (native-inputs
     `(("patchelf" ,patchelf)))
    (inputs
     `(("gcc:lib" ,(canonical-package gcc) "lib")
       ("zlib" ,zlib)))
    (arguments
     `(#:tests? #f
       #:strip-binaries? #f
       #:system "i686-linux"
       #:phases
       (modify-phases %standard-phases
         (delete 'configure)
         (delete 'build)
         (replace 'install
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (gcc:lib (assoc-ref inputs "gcc:lib"))
                    (libc (assoc-ref inputs "libc"))
                    (zlib (assoc-ref inputs "zlib"))
                    (ld-so (string-append libc
                                          ,(glibc-dynamic-linker "i686-linux")))
                    (rpath (string-append out "/lib:" zlib "/lib:"
                                          libc "/lib:" gcc:lib "/lib"))
                    (rustc (string-append out "/bin/rustc"))
                    (rustdoc (string-append out "/bin/rustdoc")))
               (system* "bash" "install.sh"
                        (string-append "--prefix=" out)
                        (string-append "--components=rustc,"
                                       "rust-std-i686-unknown-linux-gnu"))
               (for-each (lambda (file)
                           (system* "patchelf" "--set-rpath" rpath file))
                         (cons* rustc rustdoc (find-files out "\\.so$")))
               (for-each (lambda (file)
                           (system* "patchelf" "--set-interpreter" ld-so file))
                         (list rustc rustdoc))))))))
    (supported-systems '("i686-linux" "x86_64-linux"))
    (home-page "https://www.rust-lang.org")
    (synopsis "Prebuilt rust compiler")
    (description "This package provides a pre-built @command{rustc} compiler,
which can in turn be used to build the final Rust compiler.")
    (license license:asl2.0)))

;; FIXME: Make private once cargo is packaged. Is currently used by the
;; cargo-build-system.
(define-public cargo-bootstrap
  (package
    (name "cargo-bootstrap")
    (version (cargo-version %rust-bootstrap-binaries-version))
    (source %rust-bootstrap-binaries)
    (build-system gnu-build-system)
    (native-inputs
     `(("patchelf" ,patchelf)))
    (inputs
     `(("gcc:lib" ,(canonical-package gcc) "lib")))
    (arguments
     `(#:tests? #f
       #:strip-binaries? #f
       #:system "i686-linux"
       #:phases
       (modify-phases %standard-phases
         (delete 'configure)
         (delete 'build)
         (replace 'install
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (gcc:lib (assoc-ref inputs "gcc:lib"))
                    (libc (assoc-ref inputs "libc"))
                    (ld-so (string-append libc
                                          ,(glibc-dynamic-linker "i686-linux")))
                    (rpath (string-append out "/lib:" libc "/lib:"
                                          gcc:lib "/lib"))
                    (cargo (string-append out "/bin/cargo")))
               (system* "bash" "install.sh"
                        (string-append "--prefix=" out)
                        "--components=cargo")
               (system* "patchelf"
                        "--set-interpreter" ld-so
                        "--set-rpath" rpath
                        cargo)))))))
    (supported-systems '("i686-linux" "x86_64-linux"))
    (home-page "https://www.rust-lang.org")
    (synopsis "Prebuilt cargo package manager")
    (description "This package provides a pre-built @command{cargo} package
manager, which is required to build itself.")
    (license license:asl2.0)))

(define rust-bootstrap
  (package
    (name "rust-bootstrap")
    (version %rust-bootstrap-binaries-version)
    (source #f)
    (build-system trivial-build-system)
    (propagated-inputs
     `(("rustc-bootstrap" ,rustc-bootstrap)
       ("cargo-bootstrap" ,cargo-bootstrap)
       ("gcc" ,(canonical-package gcc))))
    (arguments
     `(#:modules ((guix build utils))
       #:builder
       (begin
         (use-modules (guix build utils))
         (let ((out (assoc-ref %outputs "out"))
               (gcc (assoc-ref %build-inputs "gcc")))
           (mkdir-p (string-append out "/bin"))
           ;; Rust requires a C toolchain for linking. The prebuilt
           ;; binaries expect a compiler called cc. Thus symlink gcc
           ;; to cc.
           (symlink (string-append gcc "/bin/gcc")
                    (string-append out "/bin/cc"))))))
    (home-page "https://www.rust-lang.org")
    (synopsis "Rust bootstrapping meta package")
    (description "Meta package for a rust environment. Provides pre-compiled
rustc-bootstrap and cargo-bootstrap packages.")
    (license license:asl2.0)))

(define-public rustc
  (package
    (name "rustc")
    (version (rustc-version %rust-bootstrap-binaries-version))
    (source (origin
              (method url-fetch)
              (uri (string-append
                    "https://static.rust-lang.org/dist/"
                    "rustc-" version "-src.tar.gz"))
              (sha256
               (base32
                "0srvmhhdbbcl21nzg9m9zni7k10h88lsy8k1ljz03g8mx79fv467"))))
    (build-system gnu-build-system)
    (native-inputs
     `(("cmake" ,cmake)
       ("git" ,git)
       ("python-2" ,python-2)
       ("rust-bootstrap" ,rust-bootstrap)
       ("which" ,which)))
    (inputs
     `(("jemalloc" ,jemalloc)
       ("llvm" ,llvm)))
    (arguments
     ;; FIXME: Test failure with llvm 3.8; Update llvm.
     ;; https://github.com/rust-lang/rust/issues/36835
     `(#:tests? #f
       #:phases
       (modify-phases %standard-phases
         (add-after 'unpack 'patch-configure
           (lambda _
             ;; Detect target CPU correctly.
             (substitute* "configure"
               (("/usr/bin/env") (which "env")))
             ;; Avoid curl as a build dependency.
             (substitute* "configure"
               (("probe_need CFG_CURL curl") ""))))
         (add-after 'unpack 'set-env
           (lambda _
             (setenv "SHELL" (which "sh"))
             (setenv "CONFIG_SHELL" (which "sh"))))
         (add-after 'unpack 'patch-lockfile-test
           (lambda _
             (substitute* "src/tools/tidy/src/main.rs"
               (("^.*cargo.*::check.*$") ""))))
         (replace 'configure
           (lambda* (#:key inputs outputs #:allow-other-keys)
             (let* ((out (assoc-ref outputs "out"))
                    (gcc (assoc-ref inputs "gcc"))
                    (python (assoc-ref inputs "python-2"))
                    (rustc (assoc-ref inputs "rustc-bootstrap"))
                    (llvm (assoc-ref inputs "llvm"))
                    (jemalloc (assoc-ref inputs "jemalloc"))
                    (flags (list
                            (string-append "--prefix=" out)
                            (string-append "--datadir=" out "/share")
                            (string-append "--infodir=" out "/share/info")
                            (string-append "--default-linker=" gcc "/bin/gcc")
                            (string-append "--default-ar=" gcc "/bin/ar")
                            (string-append "--python=" python "/bin/python2")
                            (string-append "--local-rust-root=" rustc)
                            (string-append "--llvm-root=" llvm)
                            (string-append "--jemalloc-root=" jemalloc "/lib")
                            "--release-channel=stable"
                            "--enable-rpath"
                            "--enable-local-rust"
                            ;;"--enable-rustbuild"
                            "--disable-manage-submodules")))
               ;; Rust uses a custom configure script (no autoconf).
               (zero? (apply system* "./configure" flags))))))))
    (synopsis "Compiler for the Rust progamming language")
    (description "Rust is a systems programming language that provides memory
safety and thread safety guarantees.")
    (home-page "https://www.rust-lang.org")
    ;; Dual licensed.
    (license (list license:asl2.0 license:expat))))

(define-public rust-libc
  (package
    (name "rust-libc")
    (version "0.2.18")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "libc" version))
       (file-name (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0w5cghr0wx3hi2sclk8r9iyzlbxsakil87ada40q2ykyhky24655"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/libc")
    (synopsis "Raw bindings to platform APIs for Rust")
    (description
     "Libc provides a library for types and bindings to native
C functions often found in libc or other common platform libraries.")
    (license (list license:expat license:asl2.0))))

(define-public rust-spin
  (package
    (name "rust-spin")
    (version "0.4.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "spin" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0lvyyxg646wl67b41655p2z25s725sw1rsfvpnm8d7vq5dpa45hx"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/mvdnes/spin-rs.git")
    (synopsis "Spin is a library which implements a simple spinlock")
    (description
     "Synchronization primitives based on spinning.  They may contain
data, they are usable without `std` and static initializers are
available.")
    (license license:expat)))

(define-public rust-lazy-static
  (package
    (name "rust-lazy-static")
    (version "0.2.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "lazy_static" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "16z1h7w702sxnscak38jykxlhxq0b5ip4mndlb46pkaqwzi0xgka"))))
    (build-system cargo-build-system)
    (inputs `(("rust-spin" ,rust-spin "src")))
    (home-page "https://github.com/rust-lang-nursery/lazy-static.rs")
    (synopsis "Macro for declaring lazily evaluated statics")
    (description
     "Lazy-static provides a macro for declaring lazily
evaluated statics in Rust.")
    (license license:expat)))

(define-public rust-qml
  (package
    (name "rust-qml")
    (version "0.0.9")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "qml" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1inbzzd7rg5fvypl927hmy0qdc899mbjp7x5b0wmk6869ril2nsy"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-lazy-static" ,rust-lazy-static "src")
       ("rust-libc" ,rust-libc "src")))
    (propagated-inputs
     ;; Rust has no concept for outside packages, but DOtherSide is
     ;; a dependency according to the github page.
     `(("dotherside" ,dotherside)))
    (home-page "https://github.com/White-Oak/qml-rust")
    (synopsis "QML (Qt Quick) bindings for Rust language")
    (description
     "QML-rust provides bindings for Qt Quick.  The bindings are based
on @code{DOtherSide} C bindings for QML Library.  It is mostly
feature-compliant with other bindings based on the library.")
    (license license:expat)))

(define-public rust-log
  (package
    (name "rust-log")
    (version "0.3.6")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "log" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0m40hgs3cg57dd5kk1mabfk6gk8z6l1cihar8akx4kmzz1xlk0xb"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/log")
    (synopsis "Logging implementation for Rust")
    (description
     "Log provides a logging facade.  Libraries can use the provided
logging API, and the consumer of those libraries can choose the logging
implementation that is most suitable for its use case.")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures
  (package
    (name "rust-futures")
    (version "0.1.7")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "futures" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "087yvc0baprw507nlr6lwkzd57a99gjj8zz95h12irfp3nk84yhp"))))
    (build-system cargo-build-system)
    (inputs `(("rust-log" ,rust-log "src")))
    (home-page "https://github.com/alexcrichton/futures-rs")
    (synopsis "Zero-cost futures and streams implementation")
    (description
     "Futures is a library implementation of futures and streams
featuring zero allocations, composability, and iterator-like interfaces.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rand
  (package
    (name "rust-rand")
    (version "0.3.15")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "rand" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "178qgglinqawwsw6l8imgnplxkmxcj404jqm92pds695xhv0cbh2"))))
    (build-system cargo-build-system)
    (native-inputs `(("rust-log" ,rust-log "src")))
    (inputs `(("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/rust-lang/rand")
    (synopsis "Random number generators and other randomness")
    (description
     "Library for random number generators and other randomness functionality.")
    (license (list license:expat license:asl2.0))))

(define-public rust-nix-test
  (package
    (name "rust-nix-test")
    (version "0.0.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "nix-test" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1g7i9p3lizipyg99swdmkg0jyxm0i3wm2jkf7hrbrkk3k3rbhp9y"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/carllerche/nix-rust")
    (synopsis "Bindings to *nix APIs")
    (description
     "Nix-test provides the testing helpers for nix.  Nix seeks to
provide bindings to various *nix platform APIs.
The goal is to not provide a 100% unified interface, but to
unify what can be while still providing platform specific APIs.

For many system APIs, Nix provides a safe alternative to the unsafe API
exposed by the libc crate.  This is done by wrapping the libc
functionality with types/abstractions that enforce legal/safe usage.")
    (license license:expat)))

(define-public rust-void
  (package
    (name "rust-void")
    (version "1.0.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "void" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0zc8f0ksxvmhvgx4fdg0zyn6vdnbxd2xv9hfx4nhzg6kbs4f80ka"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/reem/rust-void.git")
    (synopsis "Uninhabited void type for use in statically impossible cases")
    (description
     "The uninhabited type, @code{enum Void { }} is useful in dealing
with cases you know to be impossible.  If you are implementing a trait
which allows for error checking, but your case always succeeds, you can
mark the error case or type as Void, signaling to the compiler it can
never happen.
This crate also comes packed with a few traits offering extension
methods to @code{Result<T, Void>} and @code{Result<Void, T>}.")
    (license license:expat)))

(define-public rust-slab
  (package
    (name "rust-slab")
    (version "0.3.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "slab" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "08xw8w61zdfn1094qkq1d554vh5wmm9bqdys8gqqxc4sv2pgrd0p"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/carllerche/slab")
    (synopsis "Simple slab allocator")
    (description
     "Slab Allocator for Rust.  Preallocate memory for values
of a given type.")
    (license license:expat)))

(define-public rust-winapi-build
  (package
    (name "rust-winapi-build")
    (version "0.1.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "winapi-build" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1g4rqsgjky0a7530qajn2bbfcrl2v0zb39idgdws9b1l7gp5wc9d"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/retep998/winapi-rs")
    (synopsis "Common code for build.rs in WinAPI -sys crates.")
    (description
     "Common code for build.rs in WinAPI -sys crates.")
    (license license:expat)))

(define-public rust-tempdir
  (package
    (name "rust-tempdir")
    (version "0.3.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "tempdir" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1mij45kgzflkja0h8q9avrik76h5a0b60m9hfd6k9yqxbiplm5w7"))))
    (build-system cargo-build-system)
    (inputs `(("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/rust-lang/tempdir")
    (synopsis "Library for managing a temporary directory")
    (description
     "Tempdir provides a library for managing a temporary directory and
deleting all contents when it's dropped.")
    (license (list license:expat license:asl2.0))))

(define-public rust-glob
  (package
    (name "rust-glob")
    (version "0.2.11")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "glob" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1ysvi72slkw784fcsymgj4308c3y03gwjjzqxp80xdjnkbh8vqcb"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-tempdir" ,rust-tempdir "src")))
    (home-page "https://github.com/rust-lang/glob")
    (synopsis "Match file paths against Unix shell style patterns")
    (description
     "Support for matching file paths against Unix shell style patterns.")
    (license (list license:expat license:asl2.0))))

(define-public rust-scoped-tls
  (package
    (name "rust-scoped-tls")
    (version "0.1.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "scoped-tls" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0z8lgy007ffc9rdl6rhl7jxx6imxx641fmm7i044bsb3y0nw45zl"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/alexcrichton/scoped-tls")
    (synopsis "Library implementation of the `scoped_thread_local!` macro")
    (description
     "Library implementation of the standard library's old
@code{scoped_thread_local!} macro for providing scoped access to thread
local storage (TLS) so any type can be stored into TLS.")
    (license (list license:expat license:asl2.0))))

(define-public rust-bitflags
  (package
    (name "rust-bitflags")
    (version "0.7.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "bitflags" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0v8hh6wdkpk9my8z8442g4hqrqf05h0qj53dsay6mv18lqvqklda"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/bitflags")
    (synopsis "Macro to generate structures which behave like bitflags")
    (description
     "Bitflags provides a macro to generate structures which
behave like bitflags.")
    (license (list license:expat license:asl2.0))))

(define-public rust-unreachable
  (package
    (name "rust-unreachable")
    (version "0.1.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "unreachable" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "14gzpm329nrfgjvxf6zh77sp7plxakcnsq8p8xk9474fn7fyaahz"))))
    (build-system cargo-build-system)
    (inputs `(("rust-void" ,rust-void "src")))
    (home-page "https://github.com/reem/rust-unreachable.git")
    (synopsis "Unreachable code optimization hint stable rust")
    (description
     "Unreachable provides an unreachable code optimization hint in
stable rust, and some useful extension traits for @code{Option} and @code{Result}.")
    (license license:expat)))

(define-public rust-thread-id
  (package
    (name "rust-thread-id")
    (version "3.0.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "thread-id" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0jn13q459lz46l9r8qqy62ngzc9zbcw5p6k282g143f7b1swjds4"))))
    (build-system cargo-build-system)
    (inputs
     `(;("rust-kernel32-sys" ,rust-kernel32-sys "src") ; WINAPI
       ("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/ruuda/thread-id")
    (synopsis "Get a unique thread ID")
    (description
     "For diagnostics and debugging it can often be useful to get an ID
that is different for every thread.  Until Rust version 1.14, the
standard library did not expose a way to do that, which
made @code{thread-id} necessary.")
    (license license:asl2.0)))

(define-public rust-thread-local
  (package
    (name "rust-thread-local")
    (version "0.3.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "thread_local" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0pg07fla8i4z4v2bmzq49pr2z8ww6lbg9b7iwwbffz7py0ibg4vp"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-thread-id" ,rust-thread-id "src")
       ("rust-unreachable" ,rust-unreachable "src")))
    (home-page "https://github.com/Amanieu/thread_local-rs")
    (synopsis "Per-object thread-local storage")
    (description
     "This library provides the ThreadLocal type which allows a
separate copy of an object to be used for each thread.  This allows for
per-object thread-local storage, unlike the standard library's
@code{thread_local!} macro which only allows static thread-local
storage.")
    (license (list license:asl2.0 license:expat))))

(define-public rust-cfg-if
  (package
    (name "rust-cfg-if")
    (version "0.1.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "cfg-if" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "137qikjcal4h75frzcn6mknygqk8vy5bva7w851aydb5gc6pc7ny"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/alexcrichton/cfg-if")
    (synopsis
     "Ergonomically define an item depending on a large number of @code{#[cfg]} parameters")
    (description
     "Cfg-if provides a macro to ergonomically define an item depending
on a large number of @code{#[cfg]} parameters.  Structured like an
if-else chain, the first matching branch is the item that gets emitted.")
    (license (list license:expat license:asl2.0))))

(define-public rust-net2
  (package
    (name "rust-net2")
    (version "0.2.26")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "net2" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1qp3q6xynb481rsp3ig1nmqb6qlxfba3shfrmqij88cppsv9rpsy"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-cfg-if" ,rust-cfg-if "src")
       ("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/rust-lang-nursery/net2-rs")
    (synopsis "Extensions to the standard library's networking types")
    (description
     "Extensions to the standard library's networking types
as proposed in RFC 1158.  They expand the surface area of @code{std::net}
to bind more low-level interfaces and provide more advanced customization
and configuration of sockets.")
    (license (list license:expat license:asl2.0))))

(define-public rust-bytes
  (package
    (name "rust-bytes")
    (version "0.3.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "bytes" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "09vcp9kh12pva2xn2ir79k90v1a0id8f4sdv1abn5ifw2bqsyaf1"))))
    (build-system cargo-build-system)
    (native-inputs `(("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/carllerche/bytes")
    (synopsis "Types and traits for working with bytes")
    (description
     "Bytes provides a utility library for working with bytes.")
    (license license:expat)))

(define-public rust-openssl-probe
  (package
    (name "rust-openssl-probe")
    (version "0.1.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "openssl-probe" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0689h6rhzy6dypqr90lsxnf108nsnh952wsx7ggs70s48b44jvbm"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/alexcrichton/openssl-probe")
    (synopsis "Tool for helping to find SSL certificate locations on the system")
    (description
     "Openssl-probe probes the system for the directory in which
CA certificates should likely be found.  This will only search known
system locations.")
    (license (list license:expat license:asl2.0))))

(define-public rust-pkg-config
  (package
    (name "rust-pkg-config")
    (version "0.3.8")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "pkg-config" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1ypj4nj2z9z27qg06v3g40jyhw685i3l2wi098d21bvyri781vlc"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/alexcrichton/pkg-config-rs")
    (synopsis "Library to provide pkg-config to be used by Cargo")
    (description
     "This package provides a library to run the pkg-config system tool
at build time in order to be used in Cargo build scripts.")
    (license (list license:expat license:asl2.0))))

(define-public rust-num-traits
  (package
    (name "rust-num-traits")
    (version "0.1.36")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "num-traits" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "07688sp4z40p14lh5ywvrpm4zq8kcxzhjks8sg33jsr5da2l4sm1"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-num/num")
    (synopsis "Numeric traits for generic mathematics")
    (description
     "Num-traits provides numeric traits for generic mathematics.")
    (license (list license:expat license:asl2.0))))

(define-public rust-num-integer
  (package
    (name "rust-num-integer")
    (version "0.1.32")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "num-integer" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "14pvaaawl0pgdcgh4dfdd67lz58yxlfl95bry86h28pjnfzxj97v"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-num-traits" ,rust-num-traits "src")))
    (home-page "https://github.com/rust-num/num")
    (synopsis "Integer traits and functions")
    (description
     "Num-integer provides integer traits and functions.")
    (license (list license:expat license:asl2.0))))

(define-public rust-num-iter
  (package
    (name "rust-num-iter")
    (version "0.1.32")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "num-iter" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0p74nj5c1mc33h9lx4wpmlmggmn5lnkhxv1225g0aix8d6ciqyi8"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-num-integer" ,rust-num-integer "src")
       ("rust-num-traits" ,rust-num-traits "src")))
    (home-page "https://github.com/rust-num/num")
    (synopsis "External iterators for generic mathematics")
    (description
     "Num-iter provides external iterators for generic mathematics.")
    (license (list license:expat license:asl2.0))))

(define-public rust-openssl-sys
  (package
    (name "rust-openssl-sys")
    (version "0.9.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "openssl-sys" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "00fhzblw6l43ykrp3wwz3lwxqzl8sqd6vzrpb5jjn86av963f8sy"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-pkg-config" ,rust-pkg-config "src")))
    (inputs
     `(("rust-libc" ,rust-libc "src")
       ("openssl" ,openssl)))
    (home-page "https://github.com/sfackler/rust-openssl")
    (synopsis "OpenSSL bindings for Rust")
    (description "OpenSSL bindings for Rust")
    (license license:expat)))

(define-public rust-matches
  (package
    (name "rust-matches")
    (version "0.1.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "matches" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1c8190j84hbicy8jwscw5icfam12j6lcxi02lvmadq9260p65mzg"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/SimonSapin/rust-std-candidates")
    (synopsis "Macro to evaluate whether an expression matches a pattern")
    (description
     "This package provides a macro to evaluate, as a boolean,
whether an expression matches a pattern.")
    (license license:expat)))

(define-public rust-getopts
  (package
    (name "rust-getopts")
    (version "0.2.14")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "getopts" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "11fnh4awj227c85ax1sixbl5yb25c3qmxlv3nd870hwas3xpq16r"))))
    (build-system cargo-build-system)
    (native-inputs `(("rust-log" ,rust-log "src")))
    (home-page "https://github.com/rust-lang/getopts")
    (synopsis "Getopts-like option parsing")
    (description
     "Getopts provides a Rust library for option parsing for CLI utilities.")
    (license (list license:expat license:asl2.0))))

(define-public rust-encoding-index-tests
  (package
    (name "rust-encoding-index-tests")
    (version "0.1.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding_index_tests" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0s85y091gl17ixass49bzaivng7w8p82p6nyvz2r3my9w4mxhim2"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Helper macros used to test index tables for character encodings")
    (description
     "Encoding-index-tests provides helper macros used to test index
tables for character encodings.  This package is part of the crate \"encoding\",
which is providing character encoding support for Rust.")
    (license license:cc0)))

(define-public rust-encoding-index-japanese
  (package
    (name "rust-encoding-index-japanese")
    (version "1.20141219.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding-index-japanese" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "148c1lmd640p1d7fzk0nv7892mbyavvwddgqvcsm78798bzv5s04"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-encoding-index-tests" ,rust-encoding-index-tests "src")))
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Index tables for Japanese character encodings")
    (description
     "Encoding-index-japanese provides index tables for Japanese
character encodings.  This package is part of the crate \"encoding\",
which is providing character encoding support for Rust.")
    (license license:cc0)))

(define-public rust-encoding-index-korean
  (package
    (name "rust-encoding-index-korean")
    (version "1.20141219.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding-index-korean" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "10cxabp5ppygbq4y6y680856zl9zjvq7ahpiw8zj3fmwwsw3zhsd"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-encoding-index-tests" ,rust-encoding-index-tests "src")))
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Index tables for Korean character encodings")
    (description
     "Encoding-index-korean provides index tables for Korean character
encodings.  This package is part of the crate \"encoding\",
which is providing character encoding support for Rust.")
    (license license:cc0)))

(define-public rust-encoding-index-simpchinese
  (package
    (name "rust-encoding-index-simpchinese")
    (version "1.20141219.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding-index-simpchinese" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1xria2i7mc5dqdrpqxasdbxv1qx46jjbm53if3y1i4cvj2a72ynq"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-encoding-index-tests" ,rust-encoding-index-tests "src")))
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Index tables for simplified Chinese character encodings")
    (description
     "Encoding-index-simpchinese provides index tables for simplified
Chinese character encodings.  This package is part of the crate \"encoding\",
which is providing character encoding support for Rust.")
    (license license:cc0)))

(define-public rust-encoding-index-singlebyte
  (package
    (name "rust-encoding-index-singlebyte")
    (version "1.20141219.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding-index-singlebyte" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0jp85bz2pprzvg9m95w4q0vibh67b6w3bx35lafay95jzyndal9k"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-encoding-index-tests" ,rust-encoding-index-tests "src")))
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Index tables for various single-byte character encodings")
    (description
     "Encoding-index-singlebyte provides index tables for various
single-byte character encodings.  This package is part of the crate \"encoding\",
which is providing character encoding support for Rust.")
    (license license:cc0)))

(define-public rust-encoding-index-tradchinese
  (package
    (name "rust-encoding-index-tradchinese")
    (version "1.20141219.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding-index-tradchinese" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "060ci4iz6xfvzk38syfbjvs7pix5hch3mvxkksswmqwcd3aj03px"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-encoding-index-tests" ,rust-encoding-index-tests "src")))
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Index tables for traditional Chinese character encodings")
    (description
     "Encoding-index-tradchinese provides index tables for traditional
Chinese character encodings.  This package is part of the crate \"encoding\",
which is providing character encoding support for Rust.")
    (license license:cc0)))

(define-public rust-encoding
  (package
    (name "rust-encoding")
    (version "0.2.33")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "encoding" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1v1ndmkarh9z3n5hk53da4z56hgk9wa5kcsm7cnx345raqw983bb"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-getopts" ,rust-getopts "src")))
    (inputs
     `(("rust-encoding-index-japanese" ,rust-encoding-index-japanese "src")
       ("rust-encoding-index-korean" ,rust-encoding-index-korean "src")
       ("rust-encoding-index-simpchinese" ,rust-encoding-index-simpchinese "src")
       ("rust-encoding-index-singlebyte" ,rust-encoding-index-singlebyte "src")
       ("rust-encoding-index-tradchinese" ,rust-encoding-index-tradchinese "src")))
    (home-page "https://github.com/lifthrasiir/rust-encoding")
    (synopsis "Character encoding support for Rust")
    (description
     "@code{encoding} adds character encoding support for Rust.  It is
based on WHATWG Encoding Standard, and also provides an advanced
interface for error detection and recovery.")
    (license license:expat)))

(define-public rust-deque
  (package
    (name "rust-deque")
    (version "0.3.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "deque" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1gz75w8l3l0rjxxa9j1ykxra2kb5828j297av1g7h4g78286a50n"))))
    (build-system cargo-build-system)
    (inputs `(("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/kinghajj/deque")
    (synopsis "Mostly lock-free concurrent work-stealing deque")
    (description
     "@code{deque} contains an implementation of the Chase-Lev work
stealing deque described in \"Dynamic Circular Work-Stealing Deque\".
The implementation is heavily based on the implementation using C11
atomics in \"Correct and Efficient Work Stealing for Weak Memory Models\".

The only potentially lock-synchronized portion of this deque is the
occasional call to the memory allocator when growing the deque.
Otherwise all operations are lock-free.")
    (license (list license:expat license:asl2.0))))

(define-public rust-clippy-mini-macro-test
  (package
    (name "rust-clippy-mini-macro-test")
    (version "0.1.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "clippy-mini-macro-test" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1f1q09az4xk4aqnp8g1m6kf4hif75gr7rwzhh4yw7g1gqk94jsgq"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/Manishearth/rust-clippy")
    (synopsis "Macro to test clippy's procedural macro checks")
    (description
     "Clippy-mini-macro-test provides a macro to test
clippy's procedural macro checks.")
    (license license:mpl2.0)))

(define-public rust-unicode-normalization
  (package
    (name "rust-unicode-normalization")
    (version "0.1.3")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "unicode-normalization" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "17k67c2cjqyayirx239cxpb10lryyd79qql0a73zr40hjvvfk52y"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/unicode-rs/unicode-normalization")
    (synopsis "Functions for normalization of Unicode strings")
    (description
     "Unicode-normalization provides functions for normalization of
Unicode strings, including Canonical and Compatible Decomposition and
Recomposition, as described in Unicode Standard Annex #15.")
    (license (list license:expat license:asl2.0))))

(define-public rust-fnv
  (package
    (name "rust-fnv")
    (version "1.0.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "fnv" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0i73zsc7q1hapamwfv793k3xhan11jb9ylkgypx88a0y5y289i3c"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/servo/rust-fnv")
    (synopsis "Implementation of the Fowler–Noll–Vo hash function")
    (description
     "The FNV hash function is a custom Hasher implementation that is
more efficient for smaller hash keys.

The Rust FAQ states that while the default Hasher implementation,
SipHash, is good in many cases, it is notably slower than other
algorithms with short keys, such as when you have a map of integers to
other values.  In cases like these, FNV is demonstrably faster.")
    (license (list license:expat license:asl2.0))))

(define-public rust-heapsize
  (package
    (name "rust-heapsize")
    (version "0.3.7")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "heapsize" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0j9m3cw91apd2shfqv3xk0ih9sj2dv04s4v6jl8ak5c4fnaf304c"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/servo/heapsize")
    (synopsis "Measure the total runtime size of an object on the heap")
    (description
     "@code{heapsize} can be used in support of measuring heap
allocations in Rust programs.")
    (license license:mpl2.0)))

(define-public rust-unicode-bidi
  (package
    (name "rust-unicode-bidi")
    (version "0.2.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "unicode-bidi" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0y5prqsb68l5z3l3l8ql68pbq21yjiy7qxhg6wahy3pxwzri865n"))))
    (build-system cargo-build-system)
    (inputs `(("rust-matches" ,rust-matches "src")))
    (home-page "https://github.com/servo/unicode-bidi")
    (synopsis "Implementation of the Unicode Bidirectional Algorithm")
    (description
     "@code{unicode-bidi} implements the Unicode Bidirectional Algorithm for
display of mixed right-to-left and left-to-right text.  It is
written in safe Rust, compatible with the current stable release.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rustc-serialize
  (package
    (name "rust-rustc-serialize")
    (version "0.3.22")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "rustc-serialize" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0ywmsdk4l4q68hkw37743cf8kl7dp71p6317h14v82zji734cx93"))))
    (build-system cargo-build-system)
    (native-inputs `(("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/rust-lang/rustc-serialize")
    (synopsis "Generic serialization/deserialization support")
    (description
     "Generic serialization/deserialization support corresponding to the
@code{derive(RustcEncodable, RustcDecodable)} mode in the compiler.  It also
includes support for hex, base64, and json encoding and decoding.")
    (license (list license:expat license:asl2.0))))

(define-public rust-time
  (package
    (name "rust-time")
    (version "0.1.35")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "time" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1bw977mljs38cdajkpl1g55jz5rj76d8pdxkgbh59pr05bbccziw"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-log" ,rust-log "src")))
    (inputs
     `(("rust-libc" ,rust-libc "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")))
    (home-page "https://github.com/rust-lang/time")
    (synopsis "Utilities for working with time-related functions")
    (description
     "@code{time} provides utilities for working with
time-related functions in Rust.")
    (license (list license:expat license:asl2.0))))

(define-public rust-term
  (package
    (name "rust-term")
    (version "0.4.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "term" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0jpr7jb1xidadh0arklwr99r8w1k1dfc4an3ginpsq5nnfigivrx"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/Stebalien/term")
    (synopsis "Terminal formatting library")
    (description
     "Term provides a terminal formatting library.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rustc-test
  (package
    (name "rust-rustc-test")
    (version "0.1.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "rustc-test" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0x9878wxb8lqp97d6414sxl7nk0cnp8qqm4yvbhg8bfdqcmpr2js"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-getopts" ,rust-getopts "src")
       ("rust-libc" ,rust-libc "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")
       ("rust-term" ,rust-term "src")
       ("rust-time" ,rust-time "src")))
    (home-page "https://github.com/SimonSapin/rustc-test")
    (synopsis "Fork of Rust's `test` crate to use for rust stable")
    (description
     "@code{rustc-test} provides a fork of Rust's \"test\" crate that
does not require unstable language features.")
    (license (list license:expat license:asl2.0))))

(define-public rust-idna
  (package
    (name "rust-idna")
    (version "0.1.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "idna" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "049c2rmlydrrrgrxdaq2v21adx9vkfh6k9x4xj56ckyf01p26lqh"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-rustc-serialize" ,rust-rustc-serialize "src")
       ("rust-rustc-test" ,rust-rustc-test "src")))
    (inputs
     `(("rust-matches" ,rust-matches "src")
       ("rust-unicode-bidi" ,rust-unicode-bidi "src")
       ("rust-unicode-normalization" ,rust-unicode-normalization "src")))
    (home-page "https://github.com/servo/rust-url/")
    (synopsis "IDNA and Punycode")
    (description
     "@code{idna} provides IDNA (Internationalizing Domain Names in Applications) and Punycode.  It is part of the \"url\" package.")
    (license (list license:expat license:asl2.0))))

(define-public rust-compiletest-rs
  (package
    (name "rust-compiletest-rs")
    (version "0.2.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "compiletest_rs" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "031q3lsnk4bqmzc5sk0wv1a2ppfnksrw2r3g2vn7pbb5jww49wzk"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-log" ,rust-log "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")))
    (home-page "https://github.com/laumann/compiletest-rs")
    (synopsis "Compiletest utility as a standalone testing harness")
    (description
     "@code{compiletest-rs} provides the compiletest utility from the
Rust compiler as a standalone testing harness.")
    (license (list license:asl2.0 license:expat))))

(define-public rust-strsim
  (package
    (name "rust-strsim")
    (version "0.6.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "strsim" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "151ngha649cyybr3j50qg331b206zrinxqz7fzw1ra8r0n0mrldl"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/dguo/strsim-rs")
    (synopsis "Implementations of string similarity metrics")
    (description
     "@code{strsim} provides implementations of string similarity metrics.
Includes Hamming, Levenshtein, Damerau-Levenshtein, Jaro, and Jaro-Winkler.")
    (license license:expat)))

(define-public rust-quickcheck
  (package
    (name "rust-quickcheck")
    (version "0.4.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "quickcheck" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "01hligcv1h4pvc8ykch65qjzi7jgcq2s462v69j27slc84fl3hh2"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-log" ,rust-log "src")
       ;; TODO: ("rust-env-logger" ,rust-env-logger "src")
       ("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/BurntSushi/quickcheck")
    (synopsis "Automatic property based testing with shrinking")
    (description
     "QuickCheck is a way to do property based testing using randomly
generated input.  This crate comes with the ability to randomly
generate and shrink integers, floats, tuples, booleans, lists, strings,
options and results.  All QuickCheck needs is a property function, it
will then randomly generate inputs to that function and call the
property for each set of inputs.  If the property fails (whether by a
runtime error like index out-of-bounds or by not satisfying your
property), the inputs are \"shrunk\" to find a smaller counter-example.

The shrinking strategies for lists and numbers use a binary search to
cover the input space quickly.  It should be the same strategy used in
Koen Claessen's QuickCheck for Haskell.")
    (license (list license:unlicense license:expat))))

(define-public rust-memchr
  (package
    (name "rust-memchr")
    (version "1.0.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "memchr" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0a5fvj7pr422jgdmfw1fmnz00k68lw1wwd0z7cwiqwzhk29894kl"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-quickcheck" ,rust-quickcheck "src")))
    (inputs
     `(("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/BurntSushi/rust-memchr")
    (synopsis "Safe interface to memchr")
    (description
     "@code{memchr} provides an safe interface to memchr.")
    (license (list license:unlicense license:expat))))

(define-public rust-fs2
  (package
    (name "rust-fs2")
    (version "0.4.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "fs2" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1bsb3x8mkffsnr4xd5ac6v8b8sv80npfd1x37k0rv1amfphaxv9l"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-tempdir" ,rust-tempdir "src")))
    (inputs
     `(("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/danburkert/fs2-rs")
    (synopsis "Cross-platform file locks and file duplication")
    (description
     "@code{fs2} provides cross-platform file locks and file duplication.")
    (license (list license:expat license:asl2.0))))

(define-public rust-memmap
  (package
    (name "rust-memmap")
    (version "0.5.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "memmap" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1lmbkx92xlqb5yqh4cj2k4qfrm3x4jkbs04i84nfl60wyfdfap06"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-tempdir" ,rust-tempdir "src")))
    (inputs
     `(("rust-fs2" ,rust-fs2 "src")
       ("rust-libc" ,rust-libc "src")))
    (home-page "https://github.com/danburkert/memmap-rs")
    (synopsis "Cross-platform Rust API for memory-mapped file IO")
    (description
     "@code{memmap} provides a cross-platform Rust API for memory-mapped file IO.")
    (license (list license:expat license:asl2.0))))

(define-public rust-docopt
  (package
    (name "rust-docopt")
    (version "0.6.86")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "docopt" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1nf4f4zf5yk0d0l4kl7hkii4na22fhn0l2hgfb46yzv08l2g6zja"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-lazy-static" ,rust-lazy-static "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")
       ;; TODO: ("rust-regex" ,rust-regex "src")
       ("rust-strsim" ,rust-strsim "src")))
    (home-page "https://github.com/docopt/docopt.rs")
    (synopsis "Command line argument parsing")
    (description
     "Docopt for Rust with automatic type based decoding (in other words:
data validation).  This implementation conforms to the official
description of Docopt.")
    (license (list license:unlicense license:expat))))

(define-public rust-byteorder
  (package
    (name "rust-byteorder")
    (version "1.0.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "byteorder" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1j0qvrvpmk01v5qkmp5l7gmjvlpxxygivm1w074qb63bxsq7f2f4"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-quickcheck" ,rust-quickcheck "src")
       ("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/BurntSushi/byteorder")
    (synopsis "Library for numbers in big-endian and little-endian")
    (description
     "@code{byteorder} is a library for reading/writing numbers in
big-endian and little-endian.")
    (license (list license:unlicense license:expat))))

(define-public rust-csv
  (package
    (name "rust-csv")
    (version "0.14.7")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "csv" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1g0qvr9fj25fq1fy0p758glrb30yz7x46h18hsysaqyaswaihv16"))))
    (build-system cargo-build-system)
    ;; TODO: package regex
    ;; (native-inputs
    ;;  `(("rust-regex" ,rust-regex "src")))
    (inputs
     `(("rust-byteorder" ,rust-byteorder "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")))
    (home-page "https://github.com/BurntSushi/rust-csv")
    (synopsis "CSV parsing with automatic type based decoding and encoding")
    (description
     "@code{csv} provides CSV parsing with automatic type
based decoding and encoding.")
    (license (list license:unlicense license:expat))))

(define-public rust-aho-corasick
  (package
    (name "rust-aho-corasick")
    (version "0.5.3")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "aho-corasick" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0rnvdmlajikq0i4zdy1p3pv699q6apvsxfc7av7byhppllp2r5ya"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-csv" ,rust-csv "src")
       ("rust-docopt" ,rust-docopt "src")
       ("rust-memmap" ,rust-memmap "src")
       ("rust-quickcheck" ,rust-quickcheck "src")
       ("rust-rand" ,rust-rand "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")))
    (inputs
     `(("rust-memchr" ,rust-memchr "src")))
    (home-page "https://github.com/BurntSushi/aho-corasick")
    (synopsis "Fast implementation of Aho-Corasick in Rust")
    (description
     "@code{aho-corasick} provides an implementation of the
Aho-Corasick algorithm.  Its intended use case is for fast substring
matching, particularly when matching multiple substrings in a search
text.  This is achieved by compiling the substrings into a finite
state machine.

This implementation provides optimal algorithmic time complexity.
Construction of the finite state machine is O(p) where p is the length
of the substrings concatenated.  Matching against search text is
O(n + p + m), where n is the length of the search text and m is the
number of matches.")
    (license (list license:unlicense license:expat))))

(define-public rust-regex-syntax
  (package
    (name "rust-regex-syntax")
    (version "0.4.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "regex-syntax" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0ms4s2zdr9lr79isjphqqg2wkc8rblvpwcax21ghj0vnynqr349g"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-quickcheck" ,rust-quickcheck "src")
       ("rust-rand" ,rust-rand "src")))
    (home-page "https://github.com/rust-lang/regex")
    (synopsis "Regular expression parser")
    (description
     "Regex-syntax provides a regular expression parser.")
    (license (list license:expat license:asl2.0))))

(define rust-simd
  (package
    (name "rust-simd")
    (version "0.1.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "simd" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "08vhhz1w5m7amfp1d9lvfyyzl0jqjm82hrr7fb7afv3n5my89db3"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-cfg-if" ,rust-cfg-if "src")))
    ;; TODO: package them.
    ;; (inputs
    ;;  `(("rust-serde" ,rust-serde "src")
    ;;    ("rust-serde-macros" ,rust-serde-macros "src")))
    (home-page "https://github.com/huonw/simd")
    (synopsis "Limited cross-platform access to SIMD instructions on CPUs")
    (description
     "@code{simd} offers limited cross-platform access to SIMD instructions on
CPUs, as well as raw interfaces to platform-specific instructions.")
    (license (list license:expat license:asl2.0))))

(define-public rust-utf8-ranges
  (package
    (name "rust-utf8-ranges")
    (version "1.0.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "utf8-ranges" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "08j129anwcbdwvcx1izb4nsf0nbxksin2zqxjbrfz2x94mjsnbv6"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-quickcheck" ,rust-quickcheck "src")))
    (home-page "https://github.com/BurntSushi/utf8-ranges")
    (synopsis "Convert contiguous ranges of Unicode codepoints to UTF-8 byte ranges")
    (description
     "@code{utf8-ranges} converts contiguous ranges of Unicode scalar
values to UTF-8 byte ranges.  This is useful when constructing byte
based automata from Unicode.  Stated differently, this lets one embed
UTF-8 decoding as part of one's automaton.")
    (license (list license:unlicense license:expat))))

(define-public rust-regex
  (package
    (name "rust-regex")
    (version "0.2.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "regex" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "11r5392j9cwisspmjbppdamjybhwc4mjhw62zwj79ldig267ff2k"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-lazy-static" ,rust-lazy-static "src")
       ("rust-quickcheck" ,rust-quickcheck "src")
       ("rust-rand" ,rust-rand "src")))
    (inputs
     `(("rust-aho-corasick" ,rust-aho-corasick "src")
       ("rust-memchr" ,rust-memchr "src")
       ("rust-regex-syntax" ,rust-regex-syntax "src")
       ("rust-simd" ,rust-simd "src")
       ("rust-thread-local" ,rust-thread-local "src")
       ("rust-utf8-ranges" ,rust-utf8-ranges "src")))
    (home-page "https://github.com/rust-lang/regex")
    (synopsis "Implementation of regular expressions")
    (description
     "Implementation of regular expressions for Rust.  This implementation uses
finite automata and guarantees linear time matching on all inputs.")
    (license (list license:expat license:asl2.0))))

(define-public rust-env-logger
  (package
    (name "rust-env-logger")
    (version "0.3.5")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "env_logger" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0bvcjgkw4s3k1rd7glpflgc8s9a393zjd6jfdgvs8gjvwj0dgaqm"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-log" ,rust-log "src")
       ("rust-regex" ,rust-regex "src")))
    (home-page "https://github.com/rust-lang/log")
    (synopsis
     "Logging implementation for `log`")
    (description
     "Logging implementation for @code{log} which is configured via an
environment variable.")
    (license (list license:expat license:asl2.0))))

(define-public rust-quine-mc-cluskey
  (package
    (name "rust-quine-mc-cluskey")
    (version "0.2.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "quine-mc_cluskey" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0iazdlwffhrlksb8yhhs1prgwpa68rwjwqm4v26hr9hrswarcn07"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-quickcheck" ,rust-quickcheck "src")))
    (home-page "https://github.com/oli-obk/quine-mc_cluskey")
    (synopsis "Implementation of the Quine-McCluskey algorithm and Petrick's method")
    (description
     "@code{quine-mc-cluskey} is the Rust implementation of the
Quine-McCluskey algorithm and Petrick's method.")
    (license license:expat)))

(define-public rust-toml
  (package
    (name "rust-toml")
    (version "0.2.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "toml" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1d1cz43bxrx4fd6j2p6myckf81f72bp47akg36y3flxjkhj60svk"))))
    (build-system cargo-build-system)
    (inputs
     `(; TODO: ("rust-serde" ,rust-serde "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")))
    (home-page "https://github.com/alexcrichton/toml-rs")
    (synopsis "Native Rust encoder and decoder of TOML-formatted files and streams")
    (description
     "Toml provides a native Rust encoder and decoder of TOML-formatted files
and streams.  It provides implementations of the standard
Encodable/Decodable traits for TOML data to facilitate deserializing
and serializing Rust structures.")
    (license (list license:expat license:asl2.0))))

(define-public rust-semver-parser
  (package
    (name "rust-semver-parser")
    (version "0.6.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "semver-parser" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0rrsf0giv2pdvid0pmwcxfqlrq16k4sc3n5cjnmkcim5qp4z7zyq"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-lazy-static" ,rust-lazy-static "src")
       ("rust-regex" ,rust-regex "src")))
    (home-page "https://github.com/steveklabnik/semver-parser")
    (synopsis "Parsing of the semver spec")
    (description
     "@code{semver-parser} enables parsing of the semver spec.")
    (license (list license:expat license:asl2.0))))

(define-public rust-semver
  (package
    (name "rust-semver")
    (version "0.5.1")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "semver" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1xbiv8l72rmngb3lgbmk3vd4lalcbzxcnrn085c2b75irl7gcbxf"))))
    (build-system cargo-build-system)
    (native-inputs
     `(; TODO: ("rust-crates-index" ,rust-crates-index "src")
       ("rust-tempdir" ,rust-tempdir "src")))
    (inputs
     `(("rust-semver-parser" ,rust-semver-parser "src")))
    (home-page "https://docs.rs/crate/semver/")
    (synopsis "Semantic version parsing and comparison")
    (description
     "@code{semver} provides semantic version parsing and comparison.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rustc-version
  (package
    (name "rust-rustc-version")
    (version "0.1.7")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "rustc_version" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1160jjsqhqr25cvhr48hmpp8v61bjvjcnxzb0cyf4373lmp3gxf5"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-semver" ,rust-semver "src")))
    (home-page "https://github.com/Kimundi/rustc-version-rs")
    (synopsis "Library for querying the version of a installed rustc compiler")
    (description
     "Rustc-version provides a library for querying
the version of a installed rustc compiler.")
    (license (list license:expat license:asl2.0))))

(define-public rust-tempfile
  (package
    (name "rust-tempfile")
    (version "2.1.4")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "tempfile" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1j7h9xcxvzap9xpiy8w6mw9hb5iwddw7xrlgq7db3ldsjdx86w4j"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-rustc-version" ,rust-rustc-version "src")))
    (inputs
     `(("rust-libc" ,rust-libc "src")
       ("rust-rand" ,rust-rand "src")))
    (home-page "http://stebalien.com/projects/tempfile-rs")
    (synopsis "Securely create temporary files")
    (description
     "Tempfile allows you to securely create temporary files.")
    (license (list license:expat license:asl2.0))))

(define-public rust-nix
  (package
    (name "rust-nix")
    (version "0.7.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "nix" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0ywf2zyxlfk9zkw50lydnn93rymaxda7925qs05c2hdnm1gmrnd0"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-nix-test" ,rust-nix-test "src")
       ("rust-rand" ,rust-rand "src")
       ("rust-rustc-version" ,rust-rustc-version "src")
       ("rust-semver" ,rust-semver "src")
       ("rust-tempdir" ,rust-tempdir "src")
       ("rust-tempfile" ,rust-tempfile "src")))
    (inputs
     `(("rust-bitflags" ,rust-bitflags "src")
       ("rust-cfg-if" ,rust-cfg-if "src")
       ("rust-libc" ,rust-libc "src")
       ("rust-void" ,rust-void "src")))
    (home-page "https://github.com/nix-rust/nix")
    (synopsis "Rust friendly bindings to *nix APIs")
    (description
     "Nix provides Rust friendly bindings to *nix APIs.")
    (license license:expat)))

(define-public rust-clippy-lints
  (package
    (name "rust-clippy-lints")
    (version "0.0.104")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "clippy_lints" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "1ixil0j9mlyj59crkszj11sw4ar61377sm95s5vr5pm8q4kj10bh"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-matches" ,rust-matches "src")
       ("rust-quine-mc-cluskey" ,rust-quine-mc-cluskey "src")
       ("rust-regex-syntax" ,rust-regex-syntax "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")
       ("rust-semver" ,rust-semver "src")
       ("rust-toml" ,rust-toml "src")
       ("rust-unicode-normalization" ,rust-unicode-normalization "src")))
    (home-page "https://github.com/Manishearth/rust-clippy")
    (synopsis "Collection of helpful lints to avoid common pitfalls in Rust")
    (description
     "Clippy-lints provides a collection of helpful lints to
avoid common pitfalls in Rust.")
    (license license:mpl2.0)))

(define-public rust-clippy
  (package
    (name "rust-clippy")
    (version "0.0.104")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "clippy" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0d4fbg7j1rw1i2plx67inpafilgjkwclyvblirlqp812x5hv6gxf"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-clippy-mini-macro-test" ,rust-clippy-mini-macro-test "src")
       ("rust-compiletest-rs" ,rust-compiletest-rs "src")
       ("rust-lazy-static" ,rust-lazy-static "src")
       ("rust-regex" ,rust-regex "src")
       ;; TODO: ("rust-serde" ,rust-serde "src")
       ("rust-rustc-serialize" ,rust-rustc-serialize "src")))
    (inputs
     `(("rust-clippy-lints" ,rust-clippy-lints "src")))
    (home-page "https://github.com/Manishearth/rust-clippy")
    (synopsis "Collection of helpful lints to avoid common pitfalls in Rust")
    (description
     "Clippy provides a collection of helpful lints to
avoid common pitfalls in Rust.")
    (license license:mpl2.0)))

(define-public rust-lazycell
  (package
    (name "rust-lazycell")
    (version "0.5.0")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "lazycell" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "0cb3h771aqnq753krx6f6vpxw3nn41b8gaj24q6y7wqy5z1aaf7c"))))
    (build-system cargo-build-system)
    (inputs
     `(("rust-clippy" ,rust-clippy "src")))
    (home-page "https://github.com/indiv0/lazycell")
    (synopsis "Library providing a lazily filled Cell struct")
    (description
     "Lacycell provides a library providing a lazily filled Cell struct.")
    (license (list license:expat license:asl2.0))))

(define-public rust-mio
  (package
    (name "rust-mio")
    (version "0.6.2")
    (source
     (origin
       (method url-fetch)
       (uri (crate-uri "mio" version))
       (file-name
        (string-append name "-" version ".tar.gz"))
       (sha256
        (base32
         "101ybpbfc08403ca8gnsvys5sxmhfa0ifzqiy9vj1gcnzp4ksjav"))))
    (build-system cargo-build-system)
    (native-inputs
     `(("rust-bytes" ,rust-bytes "src")
       ("rust-env-logger" ,rust-env-logger "src")
       ("rust-tempdir" ,rust-tempdir "src")))
    (inputs
     `(("rust-lazycell" ,rust-lazycell "src")
       ("rust-libc" ,rust-libc "src")
       ("rust-log" ,rust-log "src")
       ("rust-net2" ,rust-net2 "src")
       ("rust-nix" ,rust-nix "src")
       ("rust-slab" ,rust-slab "src")))
    (home-page "https://github.com/carllerche/mio")
    (synopsis "Metal IO library for Rust")
    (description
     "MIO is a lightweight IO library for Rust with a focus on adding
as little overhead as possible over the OS abstractions.")
    (license license:expat)))