From 23919f27753db2c2258f4fed035be70e502428ff Mon Sep 17 00:00:00 2001
From: Efraim Flashner
Date: Mon, 26 Aug 2019 04:37:44 -0500
Subject: gn: rust-qtlreaper: Update to 0.1.4.

* gn/packages/genenetwork.scm (rust-qtlreaper): Update to 0.1.4.
[arguments]: Add rust-ndarray to cargo-inputs.
* gn/packages/crates-io.scm: Add many new crates.
---
 gn/packages/crates-io.scm   | 8282 ++++++++++++++++++++++++++++++++-----------
 gn/packages/genenetwork.scm |    9 +-
 2 files changed, 6302 insertions(+), 1989 deletions(-)

diff --git a/gn/packages/crates-io.scm b/gn/packages/crates-io.scm
index c7a0136..098e279 100644
--- a/gn/packages/crates-io.scm
+++ b/gn/packages/crates-io.scm
@@ -9,6 +9,32 @@
 
 ;; Please keep these packages sorted alphabetically
 
+(define-public rust-accelerate-src
+  (package
+    (name "rust-accelerate-src")
+    (version "0.3.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "accelerate-src" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "17fiqyq7f9k41pbsyrvk9pxyx9z6fw399wq036cvwkbmb14xcpj1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-development-inputs
+        (("rust-libc" ,rust-libc))))
+    (home-page
+      "https://github.com/blas-lapack-rs/accelerate-src")
+    (synopsis
+      "The package provides a source of BLAS and LAPACK via the Accelerate framework.")
+    (description
+      "The package provides a source of BLAS and LAPACK via the Accelerate framework.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-addr2line
   (package
     (name "rust-addr2line")
@@ -47,6 +73,30 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-adler32
+  (package
+    (name "rust-adler32")
+    (version "1.0.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "adler32" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0p7fxlnks9l7p7rwfqi7aqgnk2bps5zc0rjiw00mdw19nnbjjlky"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-development-inputs (("rust-rand" ,rust-rand-0.4))))
+    (home-page "https://github.com/remram44/adler32-rs")
+    (synopsis
+      "It is an implementation of the Adler32 rolling hash algorithm in the Rust programming language.")
+    (description
+      "It is an implementation of the Adler32 rolling hash algorithm in the Rust programming language.")
+    (license (list license:bsd-3
+                   license:zlib))))
+
 (define-public rust-afl
   (package
     (name "rust-afl")
@@ -101,6 +151,31 @@
     (license (list license:unlicense
                    license:expat))))
 
+(define-public rust-aho-corasick-0.6
+  (package
+    (inherit rust-aho-corasick)
+    (name "rust-aho-corasick")
+    (version "0.6.10")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "aho-corasick" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "19f8v503ibvlyr824g5ynicrh1lsmp2i0zmpszr8lqay0qw3vkl1"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-memchr" ,rust-memchr))
+       #:cargo-development-inputs
+       (("rust-csv" ,rust-csv)
+        ("rust-docopt" ,rust-docopt)
+        ("rust-memmap" ,rust-memmap)
+        ("rust-quickcheck" ,rust-quickcheck)
+        ("rust-rand" ,rust-rand-0.5)
+        ("rust-serde" ,rust-serde)
+        ("rust-serde-derive" ,rust-serde-derive))))))
+
 (define-public rust-ansi-term
   (package
     (name "rust-ansi-term")
@@ -147,6 +222,27 @@
       `(#:cargo-inputs
         (("rust-winapi" ,rust-winapi))))))
 
+(define-public rust-antidote
+  (package
+    (name "rust-antidote")
+    (version "1.0.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "antidote" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "19g2sw2qa2ibnh4x7j1snk46593jgx6y7rnvva496ynq61af5z9l"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/sfackler/rust-antidote")
+    (synopsis
+      "Poison-free versions of the Rust standard library Mutex and RwLock types.")
+    (description
+      "Poison-free versions of the Rust standard library Mutex and RwLock types.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-arrayvec
   (package
     (name "rust-arrayvec")
@@ -591,6 +687,48 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-blas-src
+  (package
+    (name "rust-blas-src")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "blas-src" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0cxln7bgwxbknaf3qbv4hscy9k53msax14x0szvvp680km3z9zs6"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-accelerate-src" ,rust-accelerate-src)
+        ("rust-intel-mkl-src" ,rust-intel-mkl-src)
+        ("rust-netlib-src" ,rust-netlib-src)
+        ("rust-openblas-src" ,rust-openblas-src))))
+    (home-page
+      "https://github.com/blas-lapack-rs/blas-src")
+    (synopsis
+      "The package provides a BLAS source of choice.")
+    (description
+      "The package provides a BLAS source of choice.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-blas-src-0.2
+  (package
+    (inherit rust-blas-src)
+    (name "rust-blas-src")
+    (version "0.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "blas-src" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0l9c1gjhld3ajalak1ipklxfjvwqyy3l7xl019spdbqlrk8r9f57"))))))
+
 (define-public rust-blobby
   (package
     (name "rust-blobby")
@@ -619,6 +757,34 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-bodyparser
+  (package
+    (name "rust-bodyparser")
+    (version "0.8.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "bodyparser" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0c1gynj9l7wv3mjrzr5jifmy0pjdwachfqz09aygdmmab3xan8zh"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-iron" ,rust-iron)
+         ("rust-persistent" ,rust-persistent)
+         ("rust-plugin" ,rust-plugin)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json))
+        #:cargo-development-inputs
+        (("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://github.com/iron/body-parser")
+    (synopsis "Body parsing middleware for Iron.")
+    (description "Body parsing middleware for Iron.")
+    (license license:expat)))
+
 (define-public rust-bumpalo
   (package
     (name "rust-bumpalo")
@@ -732,6 +898,31 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-cblas-sys
+  (package
+    (name "rust-cblas-sys")
+    (version "0.1.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "cblas-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0rgsn3klhhh09d8qf3b87zl4rwk93l2g0qzh9hhb0lff5kcfrzmn"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs (("rust-libc" ,rust-libc))))
+    (home-page
+      "https://github.com/blas-lapack-rs/cblas-sys")
+    (synopsis
+      "The package provides bindings to CBLAS (C).")
+    (description
+      "The package provides bindings to CBLAS (C).")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-cc
   (package
     (name "rust-cc")
@@ -1132,6 +1323,70 @@
       "This crate provides a number of conversion traits with more specific semantics than those provided by 'as' or 'From'/'Into'.")
     (license license:expat)))
 
+(define-public rust-cookie
+  (package
+    (name "rust-cookie")
+    (version "0.12.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "cookie" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1mdvqixahcywvqp0y8k2skkgbpfhsp0w73l9mz93dcrx1gq091l8"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-time" ,rust-time)
+         ("rust-base64" ,rust-base64)
+         ("rust-ring" ,rust-ring)
+         ("rust-url" ,rust-url))))
+    (home-page
+      "https://github.com/alexcrichton/cookie-rs")
+    (synopsis "Crate for parsing HTTP cookie headers and managing a cookie jar. Supports signed and private (encrypted + signed) jars.")
+    (description "Crate for parsing HTTP cookie headers and managing a cookie jar. Supports signed and private (encrypted + signed) jars.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-cookie-store
+  (package
+    (name "rust-cookie-store")
+    (version "0.8.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "cookie_store" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0204vzqszkjs5j4bqf8rrzrjj9c6f1zdydsid8ndkc7h7bx1v90l"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-cookie" ,rust-cookie)
+         ("rust-idna" ,rust-idna)
+         ("rust-log" ,rust-log)
+         ("rust-publicsuffix" ,rust-publicsuffix)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-time" ,rust-time)
+         ("rust-try-from" ,rust-try-from)
+         ("rust-url" ,rust-url))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-pretty-assertions" ,rust-pretty-assertions))))
+    (home-page
+      "https://github.com/pfernie/cookie_store")
+    (synopsis
+      "Implementation of Cookie storage and retrieval per [RFC6265](http://tools.ietf.org/html/rfc6265)")
+    (description
+      "Implementation of Cookie storage and retrieval per [RFC6265](http://tools.ietf.org/html/rfc6265)")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-core-arch
   (package
     (name "rust-core-arch")
@@ -1159,6 +1414,56 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-core-foundation
+  (package
+    (name "rust-core-foundation")
+    (version "0.6.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "core-foundation" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0va97wf49c8dzm9c8pgyk1jn7z21rl0bj1syf2zz5m2z2hzy1f95"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-chrono" ,rust-chrono)
+         ("rust-core-foundation-sys"
+          ,rust-core-foundation-sys)
+         ("rust-libc" ,rust-libc)
+         ("rust-uuid" ,rust-uuid))))
+    (home-page
+      "https://github.com/servo/core-foundation-rs")
+    (synopsis
+      "Bindings to Core Foundation for macOS")
+    (description
+      "Bindings to Core Foundation for macOS")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-core-foundation-sys
+  (package
+    (name "rust-core-foundation-sys")
+    (version "0.6.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "core-foundation-sys" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0fzsw1j9g1x598yhwklg59l15hwzc0pyvs01w9fg2kin4598mjp7"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/servo/core-foundation-rs")
+    (synopsis "Bindings to Core Foundation for OS X")
+    (description
+      "Bindings to Core Foundation for OS X")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-cpp-demangle
   (package
     (name "rust-cpp-demangle")
@@ -1167,11 +1472,10 @@
       (origin
         (method url-fetch)
         (uri (crate-uri "cpp_demangle" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0a4hqsfc0sfdwy7pcr0rc1fjp2j47fxbkqfc2lfrbi4zlm5hq36k"))))
+         (base32
+          "0a4hqsfc0sfdwy7pcr0rc1fjp2j47fxbkqfc2lfrbi4zlm5hq36k"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
@@ -1221,6 +1525,34 @@
       "Library for retrieving and interacting with the crates.io index")
     (license license:asl2.0)))
 
+(define-public rust-crc32fast
+  (package
+    (name "rust-crc32fast")
+    (version "1.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "crc32fast" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1c9dhkvf3brrzzplcijaywxi2w8wv5578i0ryhcm7x8dmzi5s4ms"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-cfg-if" ,rust-cfg-if))
+       #:cargo-development-inputs
+       (("rust-bencher" ,rust-bencher)
+        ("rust-quickcheck" ,rust-quickcheck-0.6)
+        ("rust-rand" ,rust-rand-0.4))))
+    (home-page "https://github.com/srijs/rust-crc32fast")
+    (synopsis
+      "Fast, SIMD-accelerated CRC32 (IEEE) checksum computation")
+    (description
+      "Fast, SIMD-accelerated CRC32 (IEEE) checksum computation")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-criterion
   (package
     (name "rust-criterion")
@@ -1270,6 +1602,38 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-crossbeam
+  (package
+    (name "rust-crossbeam")
+    (version "0.7.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "crossbeam" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0g5jysq5x4gndc1v5sq9n3f1m97k7qihwdpigw6ar6knj14qm09d"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-crossbeam-channel"
+          ,rust-crossbeam-channel)
+         ("rust-crossbeam-deque" ,rust-crossbeam-deque)
+         ("rust-crossbeam-epoch" ,rust-crossbeam-epoch)
+         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
+         ("rust-crossbeam-utils" ,rust-crossbeam-utils))
+        #:cargo-development-inputs
+        (("rust-rand" ,rust-rand-0.6))))
+    (home-page
+      "https://github.com/crossbeam-rs/crossbeam")
+    (synopsis "Tools for concurrent programming")
+    (description "Tools for concurrent programming")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-crossbeam-deque
   (package
     (name "rust-crossbeam-deque")
@@ -1467,32 +1831,142 @@
       `(#:cargo-inputs
         (("rust-cfg-if" ,rust-cfg-if))))))
 
-(define-public rust-custom-derive
+(define-public rust-csv
   (package
-    (name "rust-custom-derive")
-    (version "0.1.7")
+    (name "rust-csv")
+    (version "1.1.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "custom_derive" version))
+        (uri (crate-uri "csv" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1f81bavw1wnykwh21hh4yyzigs6zl6f6pkk9p3car8kq95yfb2pg"))))
+            "0zgq18xam24rbggm3ybmrygipa0mrr7rscf9r8hmi9vkzp6rql9p"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-development-inputs
-        (("rust-rustc-serialize" ,rust-rustc-serialize))))
+      `(#:cargo-inputs
+        (("rust-bstr" ,rust-bstr)
+         ("rust-csv-core" ,rust-csv-core)
+         ("rust-itoa" ,rust-itoa)
+         ("rust-ryu" ,rust-ryu)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-serde" ,rust-serde))))
     (home-page
-      "https://github.com/DanielKeep/rust-custom-derive/tree/custom_derive-master")
+      "https://github.com/BurntSushi/rust-csv")
     (synopsis
-      "(Note: superseded by `macro-attr`) This crate provides a macro that enables the use of custom derive attributes.")
+      "Fast CSV parsing with support for serde.")
+    (description
+      "Fast CSV parsing with support for serde.")
+    (license (list license:unlicense
+                   license:expat))))
+
+(define-public rust-ct-logs
+  (package
+    (name "rust-ct-logs")
+    (version "0.6.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ct-logs" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "04wiwiv4ghni3x2vni3z711mlz0ndqvh04vmdkbw3nr7zbsqcdjd"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs (("rust-sct" ,rust-sct))))
+    (home-page "https://github.com/ctz/ct-logs")
+    (synopsis
+      "Google's list of Certificate Transparency logs for use with sct crate")
+    (description
+      "Google's list of Certificate Transparency logs for use with sct crate")
+    (license (list license:asl2.0
+                   license:isc
+                   license:expat))))
+
+(define-public rust-custom-derive
+  (package
+    (name "rust-custom-derive")
+    (version "0.1.7")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "custom_derive" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1f81bavw1wnykwh21hh4yyzigs6zl6f6pkk9p3car8kq95yfb2pg"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-development-inputs
+        (("rust-rustc-serialize" ,rust-rustc-serialize))))
+    (home-page
+      "https://github.com/DanielKeep/rust-custom-derive/tree/custom_derive-master")
+    (synopsis
+      "(Note: superseded by `macro-attr`) This crate provides a macro that enables the use of custom derive attributes.")
     (description
       "(Note: superseded by `macro-attr`) This crate provides a macro that enables the use of custom derive attributes.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-data-encoding
+  (package
+    (name "rust-data-encoding")
+    (version "2.1.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "data-encoding" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "15xd6afhsjl08285piwczrafmckpp8i29padj8v12xhahshprx7l"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/ia0/data-encoding")
+    (synopsis
+      "This library provides the following common encodings")
+    (description
+      "This library provides the following common encodings")
+    (license license:expat)))
+
+(define-public rust-defmac
+  (package
+    (name "rust-defmac")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "defmac" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "01ff3jdmcc5waffkwllndnx5hsn414r7x1rq4ib73n7awsyzxkxv"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/bluss/defmac")
+    (synopsis "A macro to define lambda-like macros inline.")
+    (description "A macro to define lambda-like macros inline.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-defmac-0.1
+  (package
+    (inherit rust-defmac)
+    (name "rust-defmac")
+    (version "0.1.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "defmac" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "17giv0n0n1r64z0dahfvkjy3ys517jxyhs8sd9lmgvcljpjyryxa"))))))
+
 (define-public rust-demo-hack
   (package
     (name "rust-demo-hack")
@@ -1730,6 +2204,61 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-encoding-rs
+  (package
+    (name "rust-encoding-rs")
+    (version "0.8.17")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "encoding_rs" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1v902qqnbd37vdq4rjvp6k05wmghrasfdcjy30gp1xpjg5f7hma1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-packed-simd" ,rust-packed-simd)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json))))
+    (home-page "https://docs.rs/encoding_rs/")
+    (synopsis
+      "A Gecko-oriented implementation of the Encoding Standard")
+    (description
+      "This package provides a Gecko-oriented implementation of the Encoding Standard")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-enum-as-inner
+  (package
+    (name "rust-enum-as-inner")
+    (version "0.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "enum-as-inner" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0zg3h7k3g1z7a9ayqy63sk302d4dg5g2h274ddv80mj4jxn2cn1x"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-proc-macro2" ,rust-proc-macro2)
+        ("rust-quote" ,rust-quote)
+        ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/bluejekyll/enum-as-inner")
+    (synopsis "A deriving proc-macro for generating functions to automatically give access to the inner members of enum.")
+    (description "A deriving proc-macro for generating functions to automatically give access to the inner members of enum.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-env-logger
   (package
     (name "rust-env-logger")
@@ -1760,6 +2289,38 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-env-logger-0.5
+  (package
+    (inherit rust-env-logger)
+    (name "rust-env-logger")
+    (version "0.5.13")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "env_logger" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0f0c4i4c65jh8lci0afl5yg74ac0lbnpxcp81chj114zwg9a9c0m"))))))
+
+(define-public rust-env-logger-0.4
+  (package
+    (inherit rust-env-logger)
+    (name "rust-env-logger")
+    (version "0.4.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "env_logger" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0nydz2lidsvx9gs0v2zcz68rzqx8in7fzmiprgsrhqh17vkj3prx"))))
+   (arguments
+    `(#:cargo-inputs
+      (("rust-log" ,rust-log)
+       ("rust-regex" ,rust-regex-0.2))))))
+
 (define-public rust-envmnt
   (package
     (name "rust-envmnt")
@@ -1899,6 +2460,37 @@
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-filetime
+  (package
+    (name "rust-filetime")
+    (version "0.2.7")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "filetime" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0sflihq2l77xjrza7yjalnxsc7dxzg25rhzcfbd9vmyfah5kimvb"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-libc" ,rust-libc)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-winapi" ,rust-winapi))
+        #:cargo-development-inputs
+        (("rust-tempdir" ,rust-tempdir))))
+    (home-page
+      "https://github.com/alexcrichton/filetime")
+    (synopsis
+      "Platform-agnostic accessors of timestamps in File metadata")
+    (description
+      "Platform-agnostic accessors of timestamps in File metadata")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-findshlibs
   (package
     (name "rust-findshlibs")
@@ -1926,95 +2518,282 @@
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-float-ord
+(define-public rust-fixedbitset
   (package
-    (name "rust-float-ord")
-    (version "0.2.0")
+    (name "rust-fixedbitset")
+    (version "0.1.9")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "float-ord" version))
+        (uri (crate-uri "fixedbitset" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0kin50365sr3spnbscq43lksymybi99ai9rkqdw90m6vixhlibbv"))))
+            "0czam11mi80dbyhf4rd4lz0ihcf7vkfchrdcrn45wbs0h40dxm46"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/bluss/fixedbitset")
+    (synopsis "FixedBitSet is a simple bitset collection")
+    (description "FixedBitSet is a simple bitset collection")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-flame
+  (package
+    (name "rust-flame")
+    (version "0.2.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "flame" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0c5bmhyimzxch3pmh0w3z9n57saasgix4bmbbksr9vp1c5j71hhz"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-development-inputs
-        (("rust-rand" ,rust-rand))))
-    (home-page
-      "https://github.com/notriddle/rust-float-ord")
-    (synopsis
-      "A total ordering for floating-point numbers")
+     `(#:cargo-inputs
+       (("rust-lazy-static" ,rust-lazy-static)
+        ("rust-thread-id" ,rust-thread-id)
+        ("rust-serde" ,rust-serde)
+        ("rust-serde-derive" ,rust-serde-derive)
+        ("rust-serde-json" ,rust-serde-json))))
+    (home-page "https://github.com/TyOverby/flame")
+    (synopsis "A cool flamegraph library for rust")
     (description
-      "This package provides a total ordering for floating-point numbers")
+     "Flamegraphs are a great way to view profiling information.  At a glance, they give you information about how much time your program spends in critical sections of your code giving you some much-needed insight into where optimizations may be needed.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-fst
+(define-public rust-flamer
   (package
-    (name "rust-fst")
-    (version "0.3.5")
+    (name "rust-flamer")
+    (version "0.4.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "fst" version))
+        (uri (crate-uri "flamer" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1avszq3fn4ix7p6wjfdkli6fjyxccks1qhzja92a6kpxakd35drn"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-flame" ,rust-flame)
+        ("rust-quote" ,rust-quote)
+        ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/llogiq/flamer")
+    (synopsis "A proc macro to insert appropriate flame::start_guard(_) calls (for use with flame)")
+    (description
+      "A proc macro to insert appropriate flame::start_guard(_) calls (for use with flame)")
+    (license license:asl2.0)))
+
+(define-public rust-flate2
+  (package
+    (name "rust-flate2")
+    (version "1.0.11")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "flate2" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1mpby7wa5mkpgjiilam94a2l9mxx9wpgs3nw2nr1a0czzwsb8zwj"))))
+            "10j6bpgpipywmrsxxmp1q48qd9vp1c4fs64y2hv02r48cfxgznia"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-byteorder" ,rust-byteorder)
-         ("rust-memmap" ,rust-memmap))
+        (("rust-crc32fast" ,rust-crc32fast)
+         ("rust-futures" ,rust-futures)
+         ("rust-libc" ,rust-libc)
+         ("rust-libz-sys" ,rust-libz-sys)
+         ("rust-miniz-sys" ,rust-miniz-sys)
+         ("rust-miniz-oxide" ,rust-miniz-oxide)
+         ("rust-miniz-oxide" ,rust-miniz-oxide)
+         ("rust-tokio-io" ,rust-tokio-io))
         #:cargo-development-inputs
-        (("rust-fnv" ,rust-fnv)
-         ("rust-fst-levenshtein" ,rust-fst-levenshtein)
-         ("rust-fst-regex" ,rust-fst-regex)
-         ("rust-lazy-static" ,rust-lazy-static)
+        (("rust-futures" ,rust-futures)
          ("rust-quickcheck" ,rust-quickcheck)
-         ("rust-rand" ,rust-rand))))
-    (home-page "https://github.com/BurntSushi/fst")
+         ("rust-rand" ,rust-rand)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-tokio-threadpool" ,rust-tokio-threadpool))))
+    (home-page
+      "https://github.com/alexcrichton/flate2-rs")
     (synopsis
-      "Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible).")
+      "Bindings to miniz.c for DEFLATE compression and decompression exposed as
+      Reader/Writer streams. Contains bindings for zlib, deflate, and gzip-based
+      streams.")
     (description
-      "Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible). ")
-    (license (list license:unlicense
+      "Bindings to miniz.c for DEFLATE compression and decompression exposed as
+      Reader/Writer streams.  Contains bindings for zlib, deflate, and gzip-based
+      streams.")
+    (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-fst-levenshtein
+(define-public rust-float-ord
   (package
-    (name "rust-fst-levenshtein")
-    (version "0.2.1")
+    (name "rust-float-ord")
+    (version "0.2.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "fst-levenshtein" version))
+        (uri (crate-uri "float-ord" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1s5ml10442bbnpmilmwjh4pfixsj6837rg68vjzg63i3djd4524y"))))
+            "0kin50365sr3spnbscq43lksymybi99ai9rkqdw90m6vixhlibbv"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-fst" ,rust-fst)
-         ("rust-utf8-ranges" ,rust-utf8-ranges))))
-    (home-page "https://github.com/BurntSushi/fst")
+      `(#:cargo-development-inputs
+        (("rust-rand" ,rust-rand))))
+    (home-page
+      "https://github.com/notriddle/rust-float-ord")
     (synopsis
-      "Search finite state transducers with fuzzy queries using Levenshtein automata.")
+      "A total ordering for floating-point numbers")
     (description
-      "Search finite state transducers with fuzzy queries using Levenshtein automata.")
-    (license (list license:unlicense
+      "This package provides a total ordering for floating-point numbers")
+    (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-fst-regex
+(define-public rust-foreign-types
   (package
-    (name "rust-fst-regex")
-    (version "0.2.2")
+    (name "rust-foreign-types")
+    (version "0.4.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "foreign-types" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0ca4i38yrf9iy5k47lr1ylb3rvcbn36d81k5pr5kzf6kmj6p111n"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-foreign-types-macros" ,rust-foreign-types-macros)
+         ("rust-foreign-types-shared" ,rust-foreign-types-shared))))
+    (home-page
+      "https://github.com/sfackler/foreign-types")
+    (synopsis
+      "A framework for Rust wrappers over C APIs.")
+    (description
+      "A framework for Rust wrappers over C APIs.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-foreign-types-macros
+  (package
+    (name "rust-foreign-types-macros")
+    (version "0.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "foreign-types-macros" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "16yjigjcsklcwy2ad32l24k1nwm9n3bsnyhxc3z9whjbsrj60qk6"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-proc-macro2" ,rust-proc-macro2)
+        ("rust-quote" ,rust-quote)
+        ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/sfackler/foreign-types")
+    (synopsis "An internal crate used by foreign-types")
+    (description
+      "An internal crate used by foreign-types.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-foreign-types-shared
+  (package
+    (name "rust-foreign-types-shared")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "foreign-types-shared" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0kanxlif1vp0ffh2r9l610jqbkmb3183yqykxq1z5w1vay2rn7y6"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/sfackler/foreign-types")
+    (synopsis "An internal crate used by foreign-types")
+    (description
+     "An internal crate used by foreign-types.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-fst
+  (package
+    (name "rust-fst")
+    (version "0.3.5")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "fst" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1mpby7wa5mkpgjiilam94a2l9mxx9wpgs3nw2nr1a0czzwsb8zwj"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-memmap" ,rust-memmap))
+        #:cargo-development-inputs
+        (("rust-fnv" ,rust-fnv)
+         ("rust-fst-levenshtein" ,rust-fst-levenshtein)
+         ("rust-fst-regex" ,rust-fst-regex)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-quickcheck" ,rust-quickcheck)
+         ("rust-rand" ,rust-rand))))
+    (home-page "https://github.com/BurntSushi/fst")
+    (synopsis
+      "Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible).")
+    (description
+      "Use finite state transducers to compactly represents sets or maps of many strings (> 1 billion is possible). ")
+    (license (list license:unlicense
+                   license:expat))))
+
+(define-public rust-fst-levenshtein
+  (package
+    (name "rust-fst-levenshtein")
+    (version "0.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "fst-levenshtein" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1s5ml10442bbnpmilmwjh4pfixsj6837rg68vjzg63i3djd4524y"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-fst" ,rust-fst)
+         ("rust-utf8-ranges" ,rust-utf8-ranges))))
+    (home-page "https://github.com/BurntSushi/fst")
+    (synopsis
+      "Search finite state transducers with fuzzy queries using Levenshtein automata.")
+    (description
+      "Search finite state transducers with fuzzy queries using Levenshtein automata.")
+    (license (list license:unlicense
+                   license:expat))))
+
+(define-public rust-fst-regex
+  (package
+    (name "rust-fst-regex")
+    (version "0.2.2")
     (source
       (origin
         (method url-fetch)
@@ -2057,6 +2836,46 @@
 pseudorandom number generator")
     (license license:bsd-3)))
 
+(define-public rust-fuchsia-zircon
+  (package
+    (name "rust-fuchsia-zircon")
+    (version "0.3.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "fuchsia-zircon" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "10jxc5ks1x06gpd0xg51kcjrxr35nj6qhx2zlc5n7bmskv3675rf"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-bitflags" ,rust-bitflags)
+        ("rust-fuchsia-zircon-sys" ,rust-fuchsia-zircon-sys))))
+    (home-page "https://fuchsia.googlesource.com/garnet/")
+    (synopsis "Rust bindings for the Zircon kernel")
+    (description "Rust bindings for the Zircon kernel.")
+    (license license:bsd-3)))
+
+(define-public rust-fuchsia-zircon-sys
+  (package
+    (name "rust-fuchsia-zircon-sys")
+    (version "0.3.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "fuchsia-zircon-sys" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "19zp2085qsyq2bh1gvcxq1lb8w6v6jj9kbdkhpdjrl95fypakjix"))))
+    (build-system cargo-build-system)
+    (home-page "https://fuchsia.googlesource.com/garnet/")
+    (synopsis "Low-level Rust bindings for the Zircon kernel")
+    (description "Low-level Rust bindings for the Zircon kernel.")
+    (license license:bsd-3)))
+
 (define-public rust-futures-channel-preview
   (package
     (name "rust-futures-channel-preview")
@@ -2106,6 +2925,33 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-futures-cpupool
+  (package
+    (name "rust-futures-cpupool")
+    (version "0.1.8")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "futures-cpupool" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1r32456gpblzfvnkf60545v8acqk7gh5zhyhi1jn669k9gicv45b"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-futures" ,rust-futures)
+         ("rust-num-cpus" ,rust-num-cpus))))
+    (home-page
+      "https://github.com/alexcrichton/futures-rs")
+    (synopsis
+      "An implementation of thread pools which hand out futures to the results of the computation on the threads themselves.")
+    (description
+      "An implementation of thread pools which hand out futures to the results of the computation on the threads themselves.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-futures-executor-preview
   (package
     (name "rust-futures-executor-preview")
@@ -2158,6 +3004,43 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-futures-preview
+  (package
+    (name "rust-futures-preview")
+    (version "0.3.0-alpha.18")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "futures-preview" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1dg4qijba037xqykminifxpnjasabcjx9pwa3ww8wcmj9w6gka7g"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-futures-channel-preview"
+          ,rust-futures-channel-preview)
+         ("rust-futures-core-preview"
+          ,rust-futures-core-preview)
+         ("rust-futures-executor-preview"
+          ,rust-futures-executor-preview)
+         ("rust-futures-io-preview"
+          ,rust-futures-io-preview)
+         ("rust-futures-sink-preview"
+          ,rust-futures-sink-preview)
+         ("rust-futures-util-preview"
+          ,rust-futures-util-preview))))
+    (home-page
+      "https://rust-lang-nursery.github.io/futures-rs")
+    (synopsis
+      "An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces.")
+    (description
+      "An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-futures-select-macro-preview
   (package
     (name "rust-futures-select-macro-preview")
@@ -2216,6 +3099,35 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-futures-timer
+  (package
+    (name "rust-futures-timer")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "futures-timer" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0l35r7nm8p43j0adkhybnwxzbjiqy0b00kgccjy3l513m9abb7lg"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-futures-preview" ,rust-futures-preview)
+         ("rust-pin-utils" ,rust-pin-utils))
+        #:cargo-development-inputs
+        (("rust-runtime" ,rust-runtime))))
+    (home-page
+      "https://github.com/alexcrichton/futures-timer")
+    (synopsis
+      "Timeouts and intervals for futures.")
+    (description
+      "Timeouts and intervals for futures.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-futures-util-preview
   (package
     (name "rust-futures-util-preview")
@@ -2537,6 +3449,52 @@ pseudorandom number generator")
       "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
     (license license:expat)))
 
+(define-public rust-h2
+  (package
+    (name "rust-h2")
+    (version "0.1.26")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "h2" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0qn457y8xh03p7c7cpk76r22gqpyqxc58g5022j3iya7d0j4rcx5"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-bytes" ,rust-bytes)
+         ("rust-fnv" ,rust-fnv)
+         ("rust-futures" ,rust-futures)
+         ("rust-http" ,rust-http)
+         ("rust-indexmap" ,rust-indexmap)
+         ("rust-log" ,rust-log)
+         ("rust-slab" ,rust-slab)
+         ("rust-string" ,rust-string)
+         ("rust-tokio-io" ,rust-tokio-io))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-hex" ,rust-hex)
+         ("rust-quickcheck" ,rust-quickcheck)
+         ("rust-rand" ,rust-rand)
+         ("rust-rustls" ,rust-rustls)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-rustls" ,rust-tokio-rustls)
+         ("rust-walkdir" ,rust-walkdir)
+         ("rust-webpki" ,rust-webpki)
+         ("rust-webpki-roots" ,rust-webpki-roots))))
+    (home-page "https://github.com/hyperium/h2")
+    (synopsis
+      "A Tokio aware, HTTP/2.0 client & server implementation for Rust.")
+    (description
+      "A Tokio aware, HTTP/2.0 client & server implementation for Rust.")
+    (license license:expat)))
+
 (define-public rust-heapsize
   (package
     (name "rust-heapsize")
@@ -2561,6 +3519,29 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-heapsize-plugin
+  (package
+    (name "rust-heapsize-plugin")
+    (version "0.1.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "heapsize_plugin" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1i72isf699q9jl167g2kg4xd6h3cd05rc79zaph58aqjy0g0m9y9"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-development-inputs (("rust-heapsize" ,rust-heapsize))))
+    (home-page "https://github.com/servo/heapsize")
+    (synopsis
+      "Automatically generating infrastructure for measuring the total runtime size of an object on the heap")
+    (description
+      "Automatically generating infrastructure for measuring the total runtime size of an object on the heap")
+    (license license:mpl2.0)))
+
 (define-public rust-heck
   (package
     (name "rust-heck")
@@ -2673,28 +3654,143 @@ pseudorandom number generator")
      `(#:cargo-inputs
        (("rust-proc-macro-hack" ,rust-proc-macro-hack-0.4))))))
 
-(define-public rust-humantime
+(define-public rust-hostname
   (package
-    (name "rust-humantime")
-    (version "1.2.0")
+    (name "rust-hostname")
+    (version "0.1.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "humantime" version))
+        (uri (crate-uri "hostname" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "057ilhy6vc9iqhhby5ymh45m051pgxwq2z437gwkbnqhw7rfb9rw"))))
+            "0kprf862qaa7lwdms6aw7f3275h0j2rwhs9nz5784pm8hdmb9ki1"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-quick-error" ,rust-quick-error))
-        #:cargo-development-inputs
-        (("rust-chrono" ,rust-chrono)
-         ("rust-rand" ,rust-rand-0.4)
-         ("rust-time" ,rust-time))))
-    (home-page
+        (("rust-libc" ,rust-libc)
+         ("rust-winutil" ,rust-winutil))))
+    (home-page "https://github.com/fengcen/hostname")
+    (synopsis
+      "Get hostname. Compatible with windows and linux, redox.")
+    (description
+      "Get hostname.  Compatible with windows and linux, redox.")
+    (license license:expat)))
+
+(define-public rust-http
+  (package
+    (name "rust-http")
+    (version "0.1.18")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "http" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1r5nlliz3340dqn1fanr4f13lxfqiwp9r1mhgw8lkr1rz5bcnarp"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-fnv" ,rust-fnv)
+         ("rust-itoa" ,rust-itoa))
+        #:cargo-development-inputs
+        (("rust-doc-comment" ,rust-doc-comment)
+         ("rust-indexmap" ,rust-indexmap)
+         ("rust-quickcheck" ,rust-quickcheck)
+         ("rust-rand" ,rust-rand-0.4)
+         ("rust-seahash" ,rust-seahash)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json))))
+    (home-page
+      "https://github.com/hyperium/http")
+    (synopsis
+      "A general purpose library of common HTTP types")
+    (description
+      "A general purpose library of common HTTP types")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-http-body
+  (package
+    (name "rust-http-body")
+    (version "0.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "http-body" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0b99404k4mw6a92hvyr0qwzkqv4f866ykg0x7913limjq5cwhhb7"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-http" ,rust-http)
+         ("rust-tokio-buf" ,rust-tokio-buf))))
+    (home-page
+      "https://github.com/hyperium/http-body")
+    (synopsis
+      "Trait representing an asynchronous, streaming, HTTP request or response body.")
+    (description
+      "Trait representing an asynchronous, streaming, HTTP request or response body.")
+    (license license:expat)))
+
+(define-public rust-httparse
+  (package
+    (name "rust-httparse")
+    (version "1.3.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "httparse" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1yf23ldnjwfkkhkca7f4w15mky9961gjz28dlwyybhphc7l9l5yd"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-development-inputs
+        (("rust-pico-sys" ,rust-pico-sys))))
+    (home-page
+      "https://github.com/seanmonstar/httparse")
+    (synopsis
+      "A push parser for the HTTP 1.x protocol.")
+    (description
+      "A push parser for the HTTP 1.x protocol.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-humantime
+  (package
+    (name "rust-humantime")
+    (version "1.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "humantime" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "057ilhy6vc9iqhhby5ymh45m051pgxwq2z437gwkbnqhw7rfb9rw"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-quick-error" ,rust-quick-error))
+        #:cargo-development-inputs
+        (("rust-chrono" ,rust-chrono)
+         ("rust-rand" ,rust-rand-0.4)
+         ("rust-time" ,rust-time))))
+    (home-page
       "https://github.com/tailhook/humantime")
     (synopsis
       "A parser and formatter for std::time::{Duration, SystemTime}")
@@ -2703,6 +3799,186 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-hyper
+  (package
+    (name "rust-hyper")
+    (version "0.12.33")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "hyper" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "13rc9js5n8b338lwif94v6mfni5cjjvxf2jcdsrlzvnqx6y4rd3w"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-futures-cpupool" ,rust-futures-cpupool)
+         ("rust-h2" ,rust-h2)
+         ("rust-http" ,rust-http)
+         ("rust-http-body" ,rust-http-body)
+         ("rust-httparse" ,rust-httparse)
+         ("rust-iovec" ,rust-iovec)
+         ("rust-itoa" ,rust-itoa)
+         ("rust-log" ,rust-log)
+         ("rust-net2" ,rust-net2)
+         ("rust-time" ,rust-time)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-buf" ,rust-tokio-buf)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-tokio-threadpool" ,rust-tokio-threadpool)
+         ("rust-tokio-timer" ,rust-tokio-timer)
+         ("rust-want" ,rust-want))
+        #:cargo-development-inputs
+        (("rust-futures-timer" ,rust-futures-timer)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-pretty-env-logger"
+          ,rust-pretty-env-logger)
+         ("rust-rustc-version" ,rust-rustc-version)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-spmc" ,rust-spmc)
+         ("rust-tokio-fs" ,rust-tokio-fs)
+         ("rust-tokio-mockstream" ,rust-tokio-mockstream)
+         ("rust-url" ,rust-url))))
+    (home-page "https://hyper.rs")
+    (synopsis "A fast and correct HTTP library.")
+    (description
+      "This package provides a fast and correct HTTP library.")
+    (license license:expat)))
+
+(define-public rust-hyper-old-types
+  (package
+    (name "rust-hyper-old-types")
+    (version "0.11.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "hyper-old-types" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1i69sks0bwamzqdbx8ffgkssxffv6crdmwjgl47nr5pkxi8vx5k8"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-base64" ,rust-base64)
+         ("rust-bytes" ,rust-bytes)
+         ("rust-http" ,rust-http)
+         ("rust-httparse" ,rust-httparse)
+         ("rust-language-tags" ,rust-language-tags)
+         ("rust-log" ,rust-log)
+         ("rust-mime" ,rust-mime)
+         ("rust-percent-encoding" ,rust-percent-encoding)
+         ("rust-time" ,rust-time)
+         ("rust-unicase" ,rust-unicase))))
+    (home-page "https://hyper.rs")
+    (synopsis "HTTP types from hyper 0.11.x")
+    (description "HTTP types from hyper 0.11.x")
+    (license license:expat)))
+
+(define-public rust-hyper-native-tls
+  (package
+    (name "rust-hyper-native-tls")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "hyper-native-tls" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0s30y20qy0akzss91yxsq1x1q7rr04jy33i0cq72nx22yjc5advd"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-antidote" ,rust-antidote)
+         ("rust-hyper" ,rust-hyper)
+         ("rust-native-tls" ,rust-native-tls))))
+    (home-page "https://github.com/sfackler/hyper-native-tls")
+    (synopsis "native-tls support for Hyper 0.10.")
+    (description "native-tls support for Hyper 0.10.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-hyper-rustls
+  (package
+    (name "rust-hyper-rustls")
+    (version "0.17.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "hyper-rustls" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0li9xkzmqd40dbjbl9g0nbf2ka9y0q538ififyd30zsavz3qb7bi"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-ct-logs" ,rust-ct-logs)
+         ("rust-futures" ,rust-futures)
+         ("rust-hyper" ,rust-hyper)
+         ("rust-rustls" ,rust-rustls)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-rustls" ,rust-tokio-rustls)
+         ("rust-webpki" ,rust-webpki)
+         ("rust-webpki-roots" ,rust-webpki-roots))
+        #:cargo-development-inputs
+        (("rust-tokio" ,rust-tokio)
+         ("rust-tokio-tcp" ,rust-tokio-tcp))))
+    (home-page "https://github.com/ctz/hyper-rustls")
+    (synopsis
+      "Rustls+hyper integration for pure rust HTTPS")
+    (description
+      "Rustls+hyper integration for pure rust HTTPS")
+    (license (list license:asl2.0
+                   license:isc
+                   license:expat))))
+
+(define-public rust-hyper-tls
+  (package
+    (name "rust-hyper-tls")
+    (version "0.3.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "hyper-tls" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0kqp4sz8613j6nv375wfj3gh95ff4nb6a3rb1f2vbx0almm0v01s"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-hyper" ,rust-hyper)
+         ("rust-native-tls" ,rust-native-tls)
+         ("rust-tokio-io" ,rust-tokio-io))
+        #:cargo-development-inputs
+        (("rust-tokio" ,rust-tokio))))
+    (home-page "https://hyper.rs")
+    (synopsis
+      "Default TLS implementation for use with hyper")
+    (description
+      "Default TLS implementation for use with hyper")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-hyphenation
   (package
     (name "rust-hyphenation")
@@ -2889,6 +4165,38 @@ pseudorandom number generator")
       "This package provides a snapshot testing library for Rust")
     (license license:asl2.0)))
 
+(define-public rust-intel-mkl-src
+  (package
+    (name "rust-intel-mkl-src")
+    (version "0.4.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "intel-mkl-src" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "16kq725cl4rnvfpwq9x4rl83ylcqs7d0xryagx8ijm6bdblbfabc"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-failure" ,rust-failure)
+         ("rust-pkg-config" ,rust-pkg-config)
+         ("rust-reqwest" ,rust-reqwest)
+         ("rust-tar" ,rust-tar)
+         ("rust-xz2" ,rust-xz2))
+        #:cargo-development-inputs
+        (("rust-libc" ,rust-libc))))
+    (home-page
+      "https://github.com/termoshtt/rust-intel-mkl")
+    (synopsis
+      "Redistribution of Intel MKL as a crate.")
+    (description
+      "Redistribution of Intel MKL as a crate.")
+    (license (list license:non-copyleft "Intel Simplified Software License"
+                   license:expat)))) ; some wrapper codes
+
 (define-public rust-intervaltree
   (package
     (name "rust-intervaltree")
@@ -2914,6 +4222,39 @@ pseudorandom number generator")
       "This package provides a simple and generic implementation of an immutable interval tree.")
     (license license:expat)))
 
+(define-public rust-iron
+  (package
+    (name "rust-iron")
+    (version "0.6.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "iron" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1s4mf8395f693nhwsr0znw3j5frzn56gzllypyl50il85p50ily6"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-hyper" ,rust-hyper)
+         ("rust-log" ,rust-log)
+         ("rust-mime-guess" ,rust-mime-guess)
+         ("rust-modifier" ,rust-modifier)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-plugin" ,rust-plugin)
+         ("rust-typemap" ,rust-typemap)
+         ("rust-url" ,rust-url)
+         ("rust-hyper-native-tls" ,rust-hyper-native-tls))
+        #:cargo-development-inputs
+        (("rust-mime" ,rust-mime)
+         ("rust-time" ,rust-time))))
+    (home-page "https://github.com/iron/iron")
+    (synopsis "Extensible, Concurrency Focused Web Development in Rust.")
+    (description "Extensible, Concurrency Focused Web Development in Rust.")
+    (license license:expat)))
+
 (define-public rust-iovec
   (package
     (name "rust-iovec")
@@ -2940,6 +4281,35 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-ipconfig
+  (package
+    (name "rust-ipconfig")
+    (version "0.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ipconfig" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0gyqiqr4nk2dw9ild1aq3hnv6984sgydfdq7ki586q5ydwhzlyda"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-socket2" ,rust-socket2)
+         ("rust-widestring" ,rust-widestring)
+         ("rust-winapi" ,rust-winapi)
+         ("rust-winreg" ,rust-winreg))))
+    (home-page
+      "https://github.com/liranringel/ipconfig")
+    (synopsis
+      "Get network adapters information and network configuration for windows.")
+    (description
+      "Get network adapters information and network configuration for windows.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-itertools
   (package
     (name "rust-itertools")
@@ -2970,9 +4340,29 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-jemalloc-ctl
+(define-public rust-itertools-0.7
   (package
-    (name "rust-jemalloc-ctl")
+    (inherit rust-itertools)
+    (name "rust-itertools")
+    (version "0.7.11")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "itertools" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "03cpsj26xmyamcalclqzr1i700vwx8hnbgxbpjvs354f8mnr8iqd"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-either" ,rust-either))
+       #:cargo-development-inputs
+       (("rust-permutohedron" ,rust-permutohedron)
+        ("rust-quickcheck" ,rust-quickcheck-0.5))))))
+
+(define-public rust-jemalloc-ctl
+  (package
+    (name "rust-jemalloc-ctl")
     (version "0.3.3")
     (source
       (origin
@@ -3086,6 +4476,87 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-js-sys
+  (package
+    (name "rust-js-sys")
+    (version "0.3.27")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "js-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1m6p0bdgdkhwwy6bvapl9z3bw9nq3li2x480anfffn3calm4zz0y"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-wasm-bindgen" ,rust-wasm-bindgen))
+        #:cargo-development-inputs
+        (("rust-futures" ,rust-futures)
+         ("rust-wasm-bindgen-futures"
+          ,rust-wasm-bindgen-futures)
+         ("rust-wasm-bindgen-test"
+          ,rust-wasm-bindgen-test))))
+    (home-page
+      "https://rustwasm.github.io/wasm-bindgen/")
+    (synopsis
+      "Bindings for all JS global objects and functions in all JS environments like Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.")
+    (description
+      "Bindings for all JS global objects and functions in all JS environments like Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-kernel32-sys
+  (package
+    (name "rust-kernel32-sys")
+    (version "0.2.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "kernel32-sys" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1389av0601a9yz8dvx5zha9vmkd6ik7ax0idpb032d28555n41vm"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-winapi" ,rust-winapi)
+        ("rust-winapi-build" ,rust-winapi-build))))
+    (home-page "https://github.com/retep998/winapi-rs")
+    (synopsis "Contains function definitions for the Windows API library kernel32")
+    (description "Contains function definitions for the Windows API library kernel32.")
+    (license license:expat)))
+
+(define-public rust-language-tags
+  (package
+    (name "rust-language-tags")
+    (version "0.2.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "language-tags" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "16hrjdpa827carq5x4b8zhas24d8kg4s16m6nmmn1kb7cr5qh7d9"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-heapsize" ,rust-heapsize))
+        #:cargo-development-inputs
+        (("rust-heapsize-plugin" ,rust-heapsize-plugin))))
+    (home-page
+      "https://github.com/pyfisch/rust-language-tags")
+    (synopsis
+      "Language tags for Rust")
+    (description
+      "Language tags for Rust")
+    (license license:expat)))
+
 (define-public rust-lazy-static
   (package
     (name "rust-lazy-static")
@@ -3171,6 +4642,35 @@ pseudorandom number generator")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-libflate
+  (package
+    (name "rust-libflate")
+    (version "0.1.27")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "libflate" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1p8z839c5lpl0g01mf8iglys9lgcjxw6xjw56crhwp8z7gs5s4yr"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-adler32" ,rust-adler32)
+         ("rust-crc32fast" ,rust-crc32fast)
+         ("rust-rle-decode-fast" ,rust-rle-decode-fast)
+         ("rust-take-mut" ,rust-take-mut))
+        #:cargo-development-inputs
+        (("rust-clap" ,rust-clap))))
+    (home-page "https://github.com/sile/libflate")
+    (synopsis
+      "A Rust implementation of DEFLATE algorithm and related formats (ZLIB, GZIP)")
+    (description
+      "This package provides a Rust implementation of DEFLATE algorithm and related formats (ZLIB, GZIP)")
+    (license license:expat)))
+
 (define-public rust-libgit2-sys
   (package
     (name "rust-libgit2-sys")
@@ -3444,26 +4944,180 @@ pseudorandom number generator")
       (origin
         (method url-fetch)
         (uri (crate-uri "log" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1cx51p86d9s1y2vbyi6jr4wj5cs7nryikygfcpbc42h7ajnvcxf2"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-cfg-if" ,rust-cfg-if)
+        ("rust-serde" ,rust-serde))
+       #:cargo-development-inputs
+       (("rust-serde-test" ,rust-serde-test))))
+    (home-page "https://github.com/rust-lang/log")
+    (synopsis
+      "A lightweight logging facade for Rust")
+    (description
+      "This package provides a lightweight logging facade for Rust")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-log-0.3
+  (package
+    (inherit rust-log)
+    (name "rust-log")
+    (version "0.3.9")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "log" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0jq23hhn5h35k7pa8r7wqnsywji6x3wn1q5q7lif5q536if8v7p1"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-log" ,rust-log))))))
+
+(define-public rust-loom
+  (package
+    (name "rust-loom")
+    (version "0.2.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "loom" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1cx51p86d9s1y2vbyi6jr4wj5cs7nryikygfcpbc42h7ajnvcxf2"))))
+            "0w95rjw0sv3f5psaxlgfl4fsj6imjv16v2pap18alx2w7n2f8j24"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
         (("rust-cfg-if" ,rust-cfg-if)
-         ("rust-serde" ,rust-serde))
+         ("rust-futures-util-preview"
+          ,rust-futures-util-preview)
+         ("rust-generator" ,rust-generator)
+         ("rust-scoped-tls" ,rust-scoped-tls)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json))))
+    (home-page "https://github.com/carllerche/loom")
+    (synopsis
+      "Permutation testing for concurrent code")
+    (description
+      "Permutation testing for concurrent code")
+    (license license:expat)))
+
+(define-public rust-lru-cache
+  (package
+    (name "rust-lru-cache")
+    (version "0.1.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "lru-cache" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "071viv6g2p3akwqmfb3c8vsycs5n7kr17b70l7la071jv0d4zqii"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-heapsize" ,rust-heapsize)
+         ("rust-linked-hash-map" ,rust-linked-hash-map))))
+    (home-page
+      "https://github.com/contain-rs/lru-cache")
+    (synopsis
+      "A cache that holds a limited number of key-value pairs")
+    (description
+      "This package provides a cache that holds a limited number of key-value pairs")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-lzma-sys
+  (package
+    (name "rust-lzma-sys")
+    (version "0.1.15")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "lzma-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "14gyj256yh0wm77jbvmlc39v7lfn0navpfrja4alczarzlc8ir2k"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-libc" ,rust-libc))
         #:cargo-development-inputs
-        (("rust-serde-test" ,rust-serde-test))))
-    (home-page "https://github.com/rust-lang/log")
+        (("rust-cc" ,rust-cc)
+         ("rust-pkg-config" ,rust-pkg-config))))
+    (home-page
+      "https://github.com/alexcrichton/xz2-rs")
     (synopsis
-      "A lightweight logging facade for Rust")
+      "Raw bindings to liblzma which contains an implementation of LZMA and xz stream
+      encoding/decoding.
+
+      High level Rust bindings are available in the `xz2` crate.")
     (description
-      "This package provides a lightweight logging facade for Rust")
+        "Raw bindings to liblzma which contains an implementation of LZMA and xz stream
+        encoding/decoding.
+
+        High level Rust bindings are available in the `xz2` crate.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-matrixmultiply
+  (package
+    (name "rust-matrixmultiply")
+    (version "0.2.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "matrixmultiply" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "16sgc1j87hmsqmhlqpqgcpbrb00f267ikbr55fhxla8nhwnxgznw"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rawpointer" ,rust-rawpointer))
+        #:cargo-development-inputs
+        (("rust-bencher" ,rust-bencher)
+         ("rust-itertools" ,rust-itertools))))
+    (home-page
+      "https://github.com/bluss/matrixmultiply/")
+    (synopsis "General matrix multiplication for f32 and f64 matrices.")
+    (description "General matrix multiplication for f32 and f64 matrices. Operates on matrices with general layout (they can use arbitrary row and column stride). Detects and uses AVX or SSE2 on x86 platforms transparently for higher performance. Uses a microkernel strategy, so that the implementation is easy to parallelize and optimize.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-matrixmultiply-0.1
+  (package
+    (inherit rust-matrixmultiply)
+    (name "rust-matrixmultiply")
+    (version "0.1.15")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "matrixmultiply" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "00p0fpjhm45qdzi37mgv7ggsy8b9gqvq4999yrbgyn1dxkf6gbfw"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-rawpointer" ,rust-rawpointer))
+       #:cargo-development-inputs
+       (("rust-bencher" ,rust-bencher))))))
+
 (define-public rust-memchr
   (package
     (name "rust-memchr")
@@ -3552,3577 +5206,5722 @@ pseudorandom number generator")
       (origin
         (method url-fetch)
         (uri (crate-uri "memoffset" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "1cvm2z7dy138s302ii7wlzcxbka5a8yfl5pl5di7lbdnw9hw578g"))))))
+         (base32
+          "1cvm2z7dy138s302ii7wlzcxbka5a8yfl5pl5di7lbdnw9hw578g"))))))
 
-(define-public rust-no-panic
+(define-public rust-mime
   (package
-    (name "rust-no-panic")
-    (version "0.1.10")
+    (name "rust-mime")
+    (version "0.3.13")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "no-panic" version))
+        (uri (crate-uri "mime" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "089gmyxg7kviimqn5nmghm5kngnmi77a0c6fbv0j67jxx7pjhq3r"))))
+            "09clbyvdkwflp8anwjhqdib0sw8191gphcchdp80nc8ayhhwl9ry"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))
-        #:cargo-development-inputs
-        (("rust-tempfile" ,rust-tempfile))))
-    (home-page "https://github.com/dtolnay/no-panic")
+        (("rust-unicase" ,rust-unicase))))
+    (home-page "https://github.com/hyperium/mime")
     (synopsis
-      "Attribute macro to require that the compiler prove a function can't ever panic.")
+      "Strongly Typed Mimes")
     (description
-      "Attribute macro to require that the compiler prove a function can't ever panic.")
+      "Strongly Typed Mimes")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-nodrop ; guix upstreamable
+(define-public rust-mime-guess
   (package
-    (name "rust-nodrop")
-    (version "0.1.13")
+    (name "rust-mime-guess")
+    (version "2.0.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "nodrop" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "mime_guess" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0if9ifn6rvar5jirx4b3qh4sl5kjkmcifycvzhxa9j3crkfng5ig"))))
+          (base32
+            "16c5ssgali30db6jh1cndy77dd1qgcykhshiyfyjvxxf94wx03hs"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-nodrop-union" ,rust-nodrop-union))))
-    (home-page "https://github.com/bluss/arrayvec")
-    (synopsis "Wrapper type to inhibit drop (destructor)")
-    (description "This package provides a wrapper type to inhibit drop
-(destructor).  Use @code{std::mem::ManuallyDrop} instead!")
-    (license (list license:asl2.0
-                   license:expat))))
+      `(#:cargo-inputs
+        (("rust-mime" ,rust-mime)
+         ("rust-unicase" ,rust-unicase))
+        #:cargo-development-inputs
+        (("rust-criterion" ,rust-criterion))))
+    (home-page "https://github.com/abonander/mime_guess")
+    (synopsis
+      "MIME/MediaType guessing by file extension. Uses a static map of known file extension -> MIME type mappings.")
+    (description
+      "MIME/MediaType guessing by file extension. Uses a static map of known file extension -> MIME type mappings.")
+    (license license:expat)))
 
-(define-public rust-nodrop-union ; guix upstreamable
+(define-public rust-miniz-oxide
   (package
-    (name "rust-nodrop-union")
-    (version "0.1.10")
+    (name "rust-miniz-oxide")
+    (version "0.3.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "nodrop-union" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "miniz_oxide" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0jsnkdn9l8jlmb9h4wssi76sxnyxwnyi00p6y1p2gdq7c1gdw2b7"))))
-    (build-system cargo-build-system)
-    (home-page "https://github.com/bluss/arrayvec")
-    (synopsis "Wrapper type to inhibit drop (destructor)")
-    (description "This package provides a wrapper type to inhibit drop
-(destructor).  Implementation crate for nodrop, the untagged unions
-implementation (which is unstable / requires nightly).")
-    (license (list license:asl2.0
-                   license:expat))))
-
-(define-public rust-nom
-  (package
-    (name "rust-nom")
-    (version "5.0.0")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (crate-uri "nom" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
-        (sha256
-          (base32
-            "06snml9wfrvk8k71l4md6gg29jgj4pa8wzsg180q3qr0jf2isxp9"))))
+          (base32
+            "041s41l5w7z8pkp93pdzn8rngxr93q4wxp034pr0cvc7bgway23i"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-lazy-static" ,rust-lazy-static)
-         ("rust-lexical-core" ,rust-lexical-core)
-         ("rust-memchr" ,rust-memchr)
-         ("rust-regex" ,rust-regex))
-        #:cargo-development-inputs
-        (("rust-criterion" ,rust-criterion)
-         ("rust-doc-comment" ,rust-doc-comment)
-         ("rust-jemallocator" ,rust-jemallocator)
-         ("rust-version-check" ,rust-version-check))))
-    (home-page "https://github.com/Geal/nom")
+      `(#:cargo-inputs (("rust-adler32" ,rust-adler32))))
+    (home-page
+      "https://github.com/Frommi/miniz_oxide/tree/master/miniz_oxide")
     (synopsis
-      "A byte-oriented, zero-copy, parser combinators library")
+      "DEFLATE compression and decompression library rewritten in Rust based on miniz")
     (description
-      "This package provides a byte-oriented, zero-copy, parser combinators library")
+      "DEFLATE compression and decompression library rewritten in Rust based on miniz")
     (license license:expat)))
 
-(define-public rust-num-cpus
+(define-public rust-miniz-sys
   (package
-    (name "rust-num-cpus")
-    (version "1.10.1")
+    (name "rust-miniz-sys")
+    (version "0.1.12")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "num_cpus" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "miniz-sys" version))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0wrj3zvj6h3q26sqj9zxpd59frjb54n7jhjwf307clq31ic47vxw"))))
+         (base32
+          "00l2r4anm8g35x0js2zfdnwfbrih9m43vphdpb77c5ga3kjkm7hy"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-libc" ,rust-libc))
-        #:cargo-development-inputs
-        (("rust-doc-comment" ,rust-doc-comment))))
-    (home-page
-      "https://github.com/seanmonstar/num_cpus")
-    (synopsis "Get the number of CPUs on a machine.")
+     `(#:cargo-inputs
+       (("rust-cc" ,rust-cc)
+        ("rust-libc" ,rust-libc))))
+    (home-page "https://github.com/alexcrichton/flate2-rs")
+    (synopsis
+      "Bindings to the miniz.c library.")
     (description
-      "Get the number of CPUs on a machine.")
+      "Bindings to the miniz.c library.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-num-iter
+(define-public rust-mio
   (package
-    (name "rust-num-iter")
-    (version "0.1.39")
+    (name "rust-mio")
+    (version "0.6.19")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "num-iter" version))
+        (uri (crate-uri "mio" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0bhk2qbr3261r6zvfc58lz4spfqjhvdripxgz5mks5rd85r55gbn"))))
+            "08zzs227vrnyz5kvws6awzlgzb8zqpnihs71hkqlw07dlfb1kxc3"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-num-integer" ,rust-num-integer)
-         ("rust-num-traits" ,rust-num-traits))
+        (("rust-fuchsia-zircon" ,rust-fuchsia-zircon)
+         ("rust-fuchsia-zircon-sys"
+          ,rust-fuchsia-zircon-sys)
+         ("rust-iovec" ,rust-iovec)
+         ("rust-kernel32-sys" ,rust-kernel32-sys)
+         ("rust-libc" ,rust-libc)
+         ("rust-log" ,rust-log)
+         ("rust-miow" ,rust-miow)
+         ("rust-net2" ,rust-net2)
+         ("rust-slab" ,rust-slab)
+         ("rust-winapi" ,rust-winapi))
         #:cargo-development-inputs
-        (("rust-autocfg" ,rust-autocfg))))
-    (home-page
-      "https://github.com/rust-num/num-iter")
-    (synopsis
-      "External iterators for generic mathematics")
-    (description
-      "External iterators for generic mathematics")
-    (license (list license:asl2.0
-                   license:expat))))
+        (("rust-bytes" ,rust-bytes)
+         ("rust-env-logger" ,rust-env-logger)
+         ("rust-tempdir" ,rust-tempdir))))
+    (home-page "https://github.com/carllerche/mio")
+    (synopsis "Lightweight non-blocking IO")
+    (description "Lightweight non-blocking IO")
+    (license license:expat)))
 
-(define-public rust-openssl
+(define-public rust-mio-uds
   (package
-    (name "rust-openssl")
-    (version "0.10.24")
+    (name "rust-mio-uds")
+    (version "0.6.7")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "openssl" version))
+        (uri (crate-uri "mio-uds" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "05dg25rmg17rl3ykfl2yf69ghfd5z6zf6di38qw1awjvkddbnll1"))))
+            "09gimdbnj7b9yca99pk8lxh9jhl79msj795c8fxi2sqr9slmfqln"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-bitflags" ,rust-bitflags)
-         ("rust-cfg-if" ,rust-cfg-if)
-         ("rust-foreign-types" ,rust-foreign-types)
-         ("rust-lazy-static" ,rust-lazy-static)
+        (("rust-iovec" ,rust-iovec)
          ("rust-libc" ,rust-libc)
-         ("rust-openssl-sys" ,rust-openssl-sys))
+         ("rust-mio" ,rust-mio))
         #:cargo-development-inputs
-        (("rust-hex" ,rust-hex)
-         ("rust-tempdir" ,rust-tempdir))
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'find-openssl
-           (lambda* (#:key inputs #:allow-other-keys)
-             (let ((openssl (assoc-ref inputs "openssl")))
-               (setenv "OPENSSL_DIR" openssl))
-             #t)))))
-    (inputs
-     `(("openssl" ,(@ (gnu packages tls) openssl))))
+        (("rust-tempdir" ,rust-tempdir))))
     (home-page
-      "https://github.com/sfackler/rust-openssl")
-    (synopsis "OpenSSL bindings")
-    (description "OpenSSL bindings")
-    (license license:asl2.0)))
+      "https://github.com/alexcrichton/mio-uds")
+    (synopsis
+      "Unix domain socket bindings for mio")
+    (description
+      "Unix domain socket bindings for mio")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-openssl-src
+(define-public rust-miow
   (package
-    (name "rust-openssl-src")
-    (version "111.4.0+1.1.1c")
+    (name "rust-miow")
+    (version "0.3.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "openssl-src" version))
+        (uri (crate-uri "miow" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "10s3hvkfk6bi4ba1ssvj914rjs31vs8plssy4kbvsa0w7idkqfkq"))))
+            "09ljvx6wg30f2xlv7b7hhpkw7k312n3hjgmrbhwzhz9x03ra0sir"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs (("rust-cc" ,rust-cc))))
+      `(#:cargo-inputs
+        (("rust-socket2" ,rust-socket2)
+         ("rust-winapi" ,rust-winapi))
+        #:cargo-development-inputs
+        (("rust-rand" ,rust-rand))))
     (home-page
-      "https://github.com/alexcrichton/openssl-src-rs")
+      "https://github.com/alexcrichton/miow")
     (synopsis
-      "Source of OpenSSL and logic to build it.")
+      "A zero overhead I/O library for Windows, focusing on IOCP and Async I/O abstractions.")
     (description
-      "Source of OpenSSL and logic to build it.")
+      "This package provides a zero overhead I/O library for Windows, focusing on IOCP and Async I/O abstractions.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-openssl-sys
+(define-public rust-modifier
   (package
-    (name "rust-openssl-sys")
-    (version "0.9.48")
+    (name "rust-modifier")
+    (version "0.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "openssl-sys" version))
+        (uri (crate-uri "modifier" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "1f05kxx8mai9ac16x1lk0404bymghbbj7vcbqrfwqfr52w131fmm"))))
+         (base32
+          "0n3fmgli1nsskl0whrfzm1gk0rmwwl6pw1q4nb9sqqmn5h8wkxa1"))))
     (build-system cargo-build-system)
-    (arguments
-     `(#:cargo-inputs
-       (("rust-autocfg" ,rust-autocfg)
-        ("rust-libc" ,rust-libc))
-       #:cargo-development-inputs
-       (("rust-autocfg" ,rust-autocfg)
-        ("rust-cc" ,rust-cc)
-        ("rust-openssl-src" ,rust-openssl-src)
-        ("rust-pkg-config" ,rust-pkg-config)
-        ("rust-vcpkg" ,rust-vcpkg))
-       #:phases
-       (modify-phases %standard-phases
-         (add-after 'unpack 'find-openssl
-           (lambda* (#:key inputs #:allow-other-keys)
-             (let ((openssl (assoc-ref inputs "openssl")))
-               (setenv "OPENSSL_DIR" openssl))
-             #t)))))
-    (inputs
-     `(("openssl" ,(@ (gnu packages tls) openssl))
-       ("pkg-config" ,(@ (gnu packages pkg-config) pkg-config))))
-    (home-page
-      "https://github.com/sfackler/rust-openssl")
-    (synopsis "FFI bindings to OpenSSL")
-    (description "FFI bindings to OpenSSL")
+    (home-page "https://github.com/reem/rust-modifier")
+    (synopsis
+      "Chaining APIs for both self -> Self and &mut self methods.")
+    (description
+      "Chaining APIs for both self -> Self and &mut self methods.")
     (license license:expat)))
 
-(define-public rust-rand-os
+(define-public rust-native-tls
   (package
-    (name "rust-rand-os")
-    (version "0.2.0")
+    (name "rust-native-tls")
+    (version "0.2.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_os" version))
+        (uri (crate-uri "native-tls" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "06is69f8rfzs620g5b54k6cgy5yaycrsyqg55flyfrsf8g88733f"))))
+            "0ki7cj4wzyd2nach4qdjly69sp7rs0yz3n3z2ii4mm1gqajg2bab"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-getrandom" ,rust-getrandom)
-         ("rust-rand-core" ,rust-rand-core))))
-    (home-page "https://crates.io/crates/rand_os")
-    (synopsis "OS backed Random Number Generator")
-    (description "OS backed Random Number Generator")
+        (("rust-lazy-static" ,rust-lazy-static)
+         ("rust-libc" ,rust-libc)
+         ("rust-log" ,rust-log)
+         ("rust-openssl" ,rust-openssl)
+         ("rust-openssl-probe" ,rust-openssl-probe)
+         ("rust-openssl-sys" ,rust-openssl-sys)
+         ("rust-schannel" ,rust-schannel)
+         ("rust-security-framework" ,rust-security-framework)
+         ("rust-security-framework-sys" ,rust-security-framework-sys)
+         ("rust-tempfile" ,rust-tempfile))
+        #:cargo-development-inputs
+        (("rust-hex" ,rust-hex))))
+    (home-page "https://github.com/sfackler/rust-native-tls")
+    (synopsis
+      "An abstraction over platform-specific TLS implementations.")
+    (description
+      "An abstraction over platform-specific TLS implementations.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-os-0.1
+(define-public rust-ndarray
   (package
-    (inherit rust-rand-os)
-    (name "rust-rand-os")
-    (version "0.1.3")
+    (name "rust-ndarray")
+    (version "0.12.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_os" version))
+        (uri (crate-uri "ndarray" version))
         (file-name (string-append name "-" version ".tar.gz"))
         (sha256
          (base32
-          "0wahppm0s64gkr2vmhcgwc0lij37in1lgfxg5rbgqlz0l5vgcxbv"))))
+          "0a5rfwcbqnvbwi3nw5sfz6kf0flhmjxs64s0b4kxc6lhmyl81wvw"))))
+    (build-system cargo-build-system)
     (arguments
      `(#:cargo-inputs
-       (("rust-cloudabi" ,rust-cloudabi)
-        ("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
-        ("rust-getrandom" ,rust-getrandom)
-        ("rust-libc" ,rust-libc)
-        ("rust-log" ,rust-log)
-        ("rust-rand-core" ,rust-rand-core-0.4)
-        ("rust-rdrand" ,rust-rdrand-0.4)
-        ("rust-stdweb" ,rust-stdweb)
-        ("rust-wasm-bindgen" ,rust-wasm-bindgen)
-        ("rust-winapi" ,rust-winapi))))))
+       (("rust-itertools" ,rust-itertools-0.7)
+        ("rust-matrixmultiply" ,rust-matrixmultiply-0.1)
+        ("rust-num-complex" ,rust-num-complex)
+        ("rust-num-traits" ,rust-num-traits)
+        ("rust-blas-src" ,rust-blas-src-0.2)
+        ("rust-cblas-sys" ,rust-cblas-sys)
+        ("rust-rustc-serialize" ,rust-rustc-serialize)
+        ("rust-serde" ,rust-serde))
+       #:cargo-development-inputs
+       (("rust-defmac" ,rust-defmac-0.1)
+        ("rust-quickcheck" ,rust-quickcheck-0.7)
+        ("rust-rawpointer" ,rust-rawpointer))))
+    (home-page "https://github.com/rust-ndarray/ndarray")
+    (synopsis
+      "ndarray implements an n-dimensional container for general elements and for numerics.")
+    (description
+      "ndarray implements an n-dimensional container for general elements and for numerics.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-packed-simd
+(define-public rust-net2
   (package
-    (name "rust-packed-simd")
-    (version "0.3.3")
+    (name "rust-net2")
+    (version "0.2.33")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "packed_simd" version))
+        (uri (crate-uri "net2" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0822wqf6kzw4ig9ykndg348w2bxkhs3x64brzsvdxh2a1pyajpm8"))))
+            "126g3fgfxp06zimc1l9iyxnn9cif1hjsg7sd81nlls5nnyghsma2"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
         (("rust-cfg-if" ,rust-cfg-if)
-         ("rust-core-arch" ,rust-core-arch)
-         ("rust-sleef-sys" ,rust-sleef-sys))
-        #:cargo-development-inputs
-        (("rust-arrayvec" ,rust-arrayvec)
-         ("rust-paste" ,rust-paste)
-         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
-         ("rust-wasm-bindgen-test"
-          ,rust-wasm-bindgen-test))))
+         ("rust-libc" ,rust-libc)
+         ("rust-winapi" ,rust-winapi))))
     (home-page
-      "https://github.com/rust-lang-nursery/packed_simd")
-    (synopsis "Portable Packed SIMD vectors")
-    (description "Portable Packed SIMD vectors")
+      "https://github.com/rust-lang-nursery/net2-rs")
+    (synopsis
+      "Extensions to the standard library's networking types as proposed in RFC 1158.")
+    (description
+      "Extensions to the standard library's networking types as proposed in RFC 1158.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-parking-lot
+(define-public rust-netlib-src
   (package
-    (name "rust-parking-lot")
-    (version "0.9.0")
+    (name "rust-netlib-src")
+    (version "0.7.4")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "parking_lot" version))
+        (uri (crate-uri "netlib-src" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0lk2vq3hp88ygpgsrypdr3ss71fidnqbykva0csgxhmn5scb2hpq"))))
+            "112hwfw1zzdj10h3j213xxqjrq38iygb3nb3ijay65ycmrg819s4"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-lock-api" ,rust-lock-api)
-         ("rust-parking-lot-core" ,rust-parking-lot-core))
-        #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode)
-         ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-rand" ,rust-rand)
-         ("rust-rustc-version" ,rust-rustc-version))))
-    (home-page
-      "https://github.com/Amanieu/parking_lot")
+      `(#:cargo-development-inputs
+        (("rust-cmake" ,rust-cmake)
+         ("rust-libc" ,rust-libc))))
+    (home-page "https://github.com/cmr/netlib-src")
     (synopsis
-      "More compact and efficient implementations of the standard synchronization primitives.")
+      "The package provides a source of BLAS and LAPACK via Netlib.")
     (description
-      "More compact and efficient implementations of the standard synchronization primitives.")
+      "The package provides a source of BLAS and LAPACK via Netlib.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-parking-lot-core
+(define-public rust-no-panic
   (package
-    (name "rust-parking-lot-core")
-    (version "0.6.2")
+    (name "rust-no-panic")
+    (version "0.1.10")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "parking_lot_core" version))
+        (uri (crate-uri "no-panic" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0ay67dpnrn68ryyvp720m9i8hzp189fd4d6slrs1lvmcwywv2xmq"))))
+            "089gmyxg7kviimqn5nmghm5kngnmi77a0c6fbv0j67jxx7pjhq3r"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-backtrace" ,rust-backtrace)
-         ("rust-cfg-if" ,rust-cfg-if)
-         ("rust-cloudabi" ,rust-cloudabi)
-         ("rust-libc" ,rust-libc)
-         ("rust-petgraph" ,rust-petgraph)
-         ("rust-redox-syscall" ,rust-redox-syscall)
-         ("rust-smallvec" ,rust-smallvec)
-         ("rust-thread-id" ,rust-thread-id)
-         ("rust-winapi" ,rust-winapi))
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))
         #:cargo-development-inputs
-        (("rust-rustc-version" ,rust-rustc-version))))
-    (home-page
-      "https://github.com/Amanieu/parking_lot")
+        (("rust-tempfile" ,rust-tempfile))))
+    (home-page "https://github.com/dtolnay/no-panic")
     (synopsis
-      "An advanced API for creating custom synchronization primitives.")
+      "Attribute macro to require that the compiler prove a function can't ever panic.")
     (description
-      "An advanced API for creating custom synchronization primitives.")
+      "Attribute macro to require that the compiler prove a function can't ever panic.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-paste
+(define-public rust-nodrop ; guix upstreamable
   (package
-    (name "rust-paste")
-    (version "0.1.5")
+    (name "rust-nodrop")
+    (version "0.1.13")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "paste" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "nodrop" version))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0ygs077hlq8qlx5y46sfgrmhlqqgkmvvhn4x3y10arawalf4ljhz"))))
+         (base32
+          "0if9ifn6rvar5jirx4b3qh4sl5kjkmcifycvzhxa9j3crkfng5ig"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-paste-impl" ,rust-paste-impl)
-         ("rust-proc-macro-hack" ,rust-proc-macro-hack))))
-    (home-page "https://github.com/dtolnay/paste")
-    (synopsis
-      "Macros for all your token pasting needs")
-    (description
-      "Macros for all your token pasting needs")
+     `(#:cargo-inputs
+       (("rust-nodrop-union" ,rust-nodrop-union))))
+    (home-page "https://github.com/bluss/arrayvec")
+    (synopsis "Wrapper type to inhibit drop (destructor)")
+    (description "This package provides a wrapper type to inhibit drop
+(destructor).  Use @code{std::mem::ManuallyDrop} instead!")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-paste-impl
+(define-public rust-nodrop-union ; guix upstreamable
   (package
-    (name "rust-paste-impl")
-    (version "0.1.5")
+    (name "rust-nodrop-union")
+    (version "0.1.10")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "paste-impl" version))
+        (uri (crate-uri "nodrop-union" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0jsnkdn9l8jlmb9h4wssi76sxnyxwnyi00p6y1p2gdq7c1gdw2b7"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/bluss/arrayvec")
+    (synopsis "Wrapper type to inhibit drop (destructor)")
+    (description "This package provides a wrapper type to inhibit drop
+(destructor).  Implementation crate for nodrop, the untagged unions
+implementation (which is unstable / requires nightly).")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-nom
+  (package
+    (name "rust-nom")
+    (version "5.0.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "nom" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1rkh8nixmb7r1y0mjnsz62p6r1bqah5ciri7bwhmgcmq4gk9drr6"))))
+            "06snml9wfrvk8k71l4md6gg29jgj4pa8wzsg180q3qr0jf2isxp9"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro-hack" ,rust-proc-macro-hack)
-         ("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))))
-    (home-page "https://github.com/dtolnay/paste")
+        (("rust-lazy-static" ,rust-lazy-static)
+         ("rust-lexical-core" ,rust-lexical-core)
+         ("rust-memchr" ,rust-memchr)
+         ("rust-regex" ,rust-regex))
+        #:cargo-development-inputs
+        (("rust-criterion" ,rust-criterion)
+         ("rust-doc-comment" ,rust-doc-comment)
+         ("rust-jemallocator" ,rust-jemallocator)
+         ("rust-version-check" ,rust-version-check))))
+    (home-page "https://github.com/Geal/nom")
     (synopsis
-      "Implementation detail of the `paste` crate")
+      "A byte-oriented, zero-copy, parser combinators library")
     (description
-      "Implementation detail of the `paste` crate")
-    (license (list license:asl2.0
-                   license:expat))))
+      "This package provides a byte-oriented, zero-copy, parser combinators library")
+    (license license:expat)))
 
-(define-public rust-pest
+(define-public rust-num-complex
   (package
-    (name "rust-pest")
-    (version "2.1.1")
+    (name "rust-num-complex")
+    (version "0.2.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "pest" version))
+        (uri (crate-uri "num-complex" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "134686mwxm73asbiads53zfchqvvcrsrsyax2cghfcizmvg8ac4k"))))
+            "1z6zjdzx1g1hj4y132ddy83d3p3zvw06igbf59npxxrzzcqwzc7w"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-serde" ,rust-serde)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-ucd-trie" ,rust-ucd-trie))))
-    (home-page "https://pest-parser.github.io/")
-    (synopsis "The Elegant Parser")
-    (description "The Elegant Parser")
+        (("rust-num-traits" ,rust-num-traits)
+         ("rust-rand" ,rust-rand)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-autocfg" ,rust-autocfg))))
+    (home-page
+      "https://github.com/rust-num/num-complex")
+    (synopsis
+      "Complex numbers implementation for Rust")
+    (description
+      "Complex numbers implementation for Rust")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-pest-derive
+(define-public rust-num-cpus
   (package
-    (name "rust-pest-derive")
-    (version "2.1.0")
+    (name "rust-num-cpus")
+    (version "1.10.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "pest_derive" version))
+        (uri (crate-uri "num_cpus" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1l5jfa6ril71cw5nsiw0r45br54dd8cj2r1nc2d1wq6wb3jilgc3"))))
+            "0wrj3zvj6h3q26sqj9zxpd59frjb54n7jhjwf307clq31ic47vxw"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-pest" ,rust-pest)
-         ("rust-pest-generator" ,rust-pest-generator))))
-    (home-page "https://pest-parser.github.io/")
-    (synopsis "pest's derive macro")
-    (description "pest's derive macro")
+        (("rust-libc" ,rust-libc))
+        #:cargo-development-inputs
+        (("rust-doc-comment" ,rust-doc-comment))))
+    (home-page
+      "https://github.com/seanmonstar/num_cpus")
+    (synopsis "Get the number of CPUs on a machine.")
+    (description
+      "Get the number of CPUs on a machine.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-pest-generator
+(define-public rust-num-iter
   (package
-    (name "rust-pest-generator")
-    (version "2.1.0")
+    (name "rust-num-iter")
+    (version "0.1.39")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "pest_generator" version))
+        (uri (crate-uri "num-iter" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0ipnv77lqhj4d4fpfxi8m168lcjp482kszaknlardmpgqiv0a4k3"))))
+            "0bhk2qbr3261r6zvfc58lz4spfqjhvdripxgz5mks5rd85r55gbn"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-pest" ,rust-pest)
-         ("rust-pest-meta" ,rust-pest-meta)
-         ("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))))
-    (home-page "https://pest-parser.github.io/")
-    (synopsis "pest code generator")
-    (description "pest code generator")
+        (("rust-num-integer" ,rust-num-integer)
+         ("rust-num-traits" ,rust-num-traits))
+        #:cargo-development-inputs
+        (("rust-autocfg" ,rust-autocfg))))
+    (home-page
+      "https://github.com/rust-num/num-iter")
+    (synopsis
+      "External iterators for generic mathematics")
+    (description
+      "External iterators for generic mathematics")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-pest-meta
+(define-public rust-object
   (package
-    (name "rust-pest-meta")
-    (version "2.1.1")
+    (name "rust-object")
+    (version "0.13.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "pest_meta" version))
+        (uri (crate-uri "object" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0kaprdz3jis9bjfwhri1zncbsvack5m3gx2g5flspdy7wxnyljgj"))))
+            "05gfh6da1aavksxxq52hpzy40yiqpwzra8lfk7pcc45qqrdw97nq"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-maplit" ,rust-maplit)
-        ("rust-pest" ,rust-pest)
-        ("rust-sha-1" ,rust-sha-1))))
-    (home-page "https://pest-parser.github.io/")
-    (synopsis "pest meta language parser and validator")
+      `(#:cargo-inputs
+        (("rust-goblin" ,rust-goblin)
+         ("rust-scroll" ,rust-scroll)
+         ("rust-target-lexicon" ,rust-target-lexicon)
+         ("rust-uuid" ,rust-uuid)
+         ("rust-crc32fast" ,rust-crc32fast)
+         ("rust-flate2" ,rust-flate2)
+         ("rust-indexmap" ,rust-indexmap)
+         ("rust-parity-wasm" ,rust-parity-wasm))
+        #:cargo-development-inputs
+        (("rust-memmap" ,rust-memmap))))
+    (home-page "https://github.com/gimli-rs/object")
+    (synopsis
+      "A unified interface for parsing object file formats.")
     (description
-      "pest meta language parser and validator")
+      "A unified interface for parsing object file formats.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-pkg-config
+(define-public rust-odds
   (package
-    (name "rust-pkg-config")
-    (version "0.3.14")
+    (name "rust-odds")
+    (version "0.3.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "pkg-config" version))
+        (uri (crate-uri "odds" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "135ia995lqzr0gxpk85h0bjxf82kj6hbxdx924sh9jdln6r8wvk7"))))
+            "0rdnxa0na4897yb0svb3figz35g4imxjv61yfm2j21gbh5q8v8d9"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-development-inputs
-       (("rust-lazy-static" ,rust-lazy-static))))
-    (inputs
-     `(("pkg-config" ,(@ (gnu packages pkg-config) pkg-config))))
+      `(#:cargo-inputs
+        (("rust-rawpointer" ,rust-rawpointer)
+         ("rust-rawslice" ,rust-rawslice)
+         ("rust-unchecked-index" ,rust-unchecked-index))
+        #:cargo-development-inputs
+        (("rust-itertools" ,rust-itertools)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-memchr" ,rust-memchr)
+         ("rust-quickcheck" ,rust-quickcheck))))
     (home-page
-      "https://github.com/alexcrichton/pkg-config-rs")
+      "https://github.com/bluss/odds")
     (synopsis
-      "A library to run the pkg-config system tool at build time in order to be used in Cargo build scripts.")
+      "Odds and ends")
     (description
-      "A library to run the pkg-config system tool at build time in order to be used in Cargo build scripts.")
+      "Odds and ends  collection miscellania. Extra functionality for slices (`.find()`, `RevSlice`), strings and other things. Things in odds may move to more appropriate crates if we find them.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-proc-macro-nested ; guix upstreamable
+(define-public rust-openblas-src
   (package
-    (name "rust-proc-macro-nested")
-    (version "0.1.3")
+    (name "rust-openblas-src")
+    (version "0.7.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "proc-macro-nested" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "openblas-src" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0bmlksm8vl44wkwihmwr7jsjznhbg0n7aibcw1cs2jgjcp86x6in"))))
+          (base32
+            "1dyf7yh6rmkk7k3pgcp5p8248f08hhajkigw42bfwjw1d3jk6d8b"))))
     (build-system cargo-build-system)
-    (home-page "https://github.com/dtolnay/proc-macro-hack")
-    (synopsis "Support for nested proc-macro-hack invocations")
-    (description "This crate provides support for nested proc-macro-hack
-invocations.")
+    (arguments
+      `(#:cargo-development-inputs
+        (("rust-libc" ,rust-libc))))
+    (home-page
+      "https://github.com/blas-lapack-rs/openblas-src")
+    (synopsis
+      "The package provides a source of BLAS and LAPACK via OpenBLAS.")
+    (description
+      "The package provides a source of BLAS and LAPACK via OpenBLAS.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-proptest
+(define-public rust-openssl
   (package
-    (name "rust-proptest")
-    (version "0.9.4")
+    (name "rust-openssl")
+    (version "0.10.24")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "proptest" version))
+        (uri (crate-uri "openssl" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "17sjg8isas4qk85807c4panih9k0lwa4k1mbajhciw5c5q17w56g"))))
+            "05dg25rmg17rl3ykfl2yf69ghfd5z6zf6di38qw1awjvkddbnll1"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-bit-set" ,rust-bit-set)
-         ("rust-bitflags" ,rust-bitflags)
-         ("rust-byteorder" ,rust-byteorder)
+        (("rust-bitflags" ,rust-bitflags)
+         ("rust-cfg-if" ,rust-cfg-if)
+         ("rust-foreign-types" ,rust-foreign-types)
          ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-num-traits" ,rust-num-traits)
-         ("rust-quick-error" ,rust-quick-error)
-         ("rust-rand" ,rust-rand)
-         ("rust-rand-chacha" ,rust-rand-chacha)
-         ("rust-rand-xorshift" ,rust-rand-xorshift)
-         ("rust-regex-syntax" ,rust-regex-syntax)
-         ("rust-rusty-fork" ,rust-rusty-fork)
-         ("rust-tempfile" ,rust-tempfile))
+         ("rust-libc" ,rust-libc)
+         ("rust-openssl-sys" ,rust-openssl-sys))
         #:cargo-development-inputs
-        (("rust-regex" ,rust-regex))))
-    (home-page
-      "https://altsysrq.github.io/proptest-book/proptest/index.html")
-    (synopsis
-      "Hypothesis-like property-based testing and shrinking.")
-    (description
-      "Hypothesis-like property-based testing and shrinking.")
-    (license (list license:asl2.0
-                   license:expat))))
+        (("rust-hex" ,rust-hex)
+         ("rust-tempdir" ,rust-tempdir))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'find-openssl
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((openssl (assoc-ref inputs "openssl")))
+               (setenv "OPENSSL_DIR" openssl))
+             #t)))))
+    (inputs
+     `(("openssl" ,(@ (gnu packages tls) openssl))))
+    (home-page
+      "https://github.com/sfackler/rust-openssl")
+    (synopsis "OpenSSL bindings")
+    (description "OpenSSL bindings")
+    (license license:asl2.0)))
 
-(define-public rust-proc-macro-hack
+(define-public rust-openssl-probe
   (package
-    (name "rust-proc-macro-hack")
-    (version "0.5.8")
+    (name "rust-openssl-probe")
+    (version "0.1.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "proc-macro-hack" version))
+        (uri (crate-uri "openssl-probe" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0y2ix90qdvsfks4j1g5qnpyzaa6a4j6sdi35klqvm120378kaalq"))))
+            "1pijrdifgsdwd45b08c2g0dsmnhz7c3kmagb70839ngrd7d29bvp"))))
     (build-system cargo-build-system)
-    (arguments
-      `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))
-        #:cargo-development-inputs
-        (("rust-demo-hack" ,rust-demo-hack)
-         ("rust-demo-hack-impl" ,rust-demo-hack-impl))))
     (home-page
-      "https://github.com/dtolnay/proc-macro-hack")
+      "https://github.com/alexcrichton/openssl-probe")
     (synopsis
-      "Procedural functionlike!() macros using only Macros 1.1")
+      "Tool for helping to find SSL certificate locations on the system for OpenSSL")
     (description
-      "Procedural functionlike!() macros using only Macros 1.1")
+      "Tool for helping to find SSL certificate locations on the system for OpenSSL")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-proc-macro-hack-0.4
+(define-public rust-openssl-src
   (package
-    (inherit rust-proc-macro-hack)
-    (name "rust-proc-macro-hack")
-    (version "0.4.2")
+    (name "rust-openssl-src")
+    (version "111.4.0+1.1.1c")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "proc-macro-hack" version))
+        (uri (crate-uri "openssl-src" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0fxn3qfhw76c518dfal2qqjwj5dbf0a1f7z0r5c4wd0igygg4fs6"))))
+            "10s3hvkfk6bi4ba1ssvj914rjs31vs8plssy4kbvsa0w7idkqfkq"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-proc-macro-hack-impl" ,rust-proc-macro-hack-impl))
-        #:cargo-development-inputs
-        (("rust-demo-hack" ,rust-demo-hack)
-         ("rust-demo-hack-impl" ,rust-demo-hack-impl))))))
+      `(#:cargo-inputs (("rust-cc" ,rust-cc))))
+    (home-page
+      "https://github.com/alexcrichton/openssl-src-rs")
+    (synopsis
+      "Source of OpenSSL and logic to build it.")
+    (description
+      "Source of OpenSSL and logic to build it.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-pulldown-cmark
+(define-public rust-openssl-sys
   (package
-    (name "rust-pulldown-cmark")
-    (version "0.5.3")
+    (name "rust-openssl-sys")
+    (version "0.9.48")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "pulldown-cmark" version))
+        (uri (crate-uri "openssl-sys" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0mq3cgjwxlrv0p1svjg93m1jkybzyfrl9p0jwa76hx1352hks13p"))))
+            "1f05kxx8mai9ac16x1lk0404bymghbbj7vcbqrfwqfr52w131fmm"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-bitflags" ,rust-bitflags)
-         ("rust-getopts" ,rust-getopts)
-         ("rust-memchr" ,rust-memchr)
-         ("rust-unicase" ,rust-unicase))
-        #:cargo-development-inputs
-        (("rust-criterion" ,rust-criterion)
-         ("rust-html5ever" ,rust-html5ever)
-         ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-regex" ,rust-regex)
-         ("rust-tendril" ,rust-tendril))))
+     `(#:cargo-inputs
+       (("rust-autocfg" ,rust-autocfg)
+        ("rust-libc" ,rust-libc))
+       #:cargo-development-inputs
+       (("rust-autocfg" ,rust-autocfg)
+        ("rust-cc" ,rust-cc)
+        ("rust-openssl-src" ,rust-openssl-src)
+        ("rust-pkg-config" ,rust-pkg-config)
+        ("rust-vcpkg" ,rust-vcpkg))
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'find-openssl
+           (lambda* (#:key inputs #:allow-other-keys)
+             (let ((openssl (assoc-ref inputs "openssl")))
+               (setenv "OPENSSL_DIR" openssl))
+             #t)))))
+    (inputs
+     `(("openssl" ,(@ (gnu packages tls) openssl))
+       ("pkg-config" ,(@ (gnu packages pkg-config) pkg-config))))
     (home-page
-      "https://github.com/raphlinus/pulldown-cmark")
-    (synopsis "A pull parser for CommonMark")
-    (description
-      "This package provides a pull parser for CommonMark")
+      "https://github.com/sfackler/rust-openssl")
+    (synopsis "FFI bindings to OpenSSL")
+    (description "FFI bindings to OpenSSL")
     (license license:expat)))
 
-(define-public rust-quantiles
+(define-public rust-ordermap
   (package
-    (name "rust-quantiles")
-    (version "0.7.1")
+    (name "rust-ordermap")
+    (version "0.4.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "quantiles" version))
+        (uri (crate-uri "ordermap" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1wjp16a3d4bmldq9w2wds0q4gjz4mnsqac3g38r6ryr6zc9sh3y1"))))
+            "1m0vxmlm1x92m1ydgpddzg5mrfk3ddy8gk3r9dmpml18qrs9ch4i"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))
-        #:cargo-development-inputs
-        (("rust-quickcheck" ,rust-quickcheck))))
-    (home-page
-      "https://github.com/postmates/quantiles")
+     `(#:cargo-inputs
+       (("rust-serde" ,rust-serde))
+       #:cargo-development-inputs
+       (("rust-fnv" ,rust-fnv)
+        ("rust-itertools" ,rust-itertools)
+        ("rust-lazy-static" ,rust-lazy-static)
+        ("rust-quickcheck" ,rust-quickcheck)
+        ("rust-rand" ,rust-rand-0.4)
+        ("rust-serde-test" ,rust-serde-test))))
+    (home-page "https://github.com/bluss/ordermap")
     (synopsis
-      "a collection of approximate quantile algorithms")
+      "A hash table with consistent order and fast iteration. NOTE: This crate was renamed to indexmap. Please use it under its new name.")
     (description
-      "a collection of approximate quantile algorithms")
-    (license license:expat)))
+      "A hash table with consistent order and fast iteration. NOTE: This crate was renamed to indexmap. Please use it under its new name.")
+    (properties `((superseded . ,rust-indexmap)))
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-quickcheck
+(define-public rust-owning-ref
   (package
-    (name "rust-quickcheck")
-    (version "0.8.5")
+    (name "rust-owning-ref")
+    (version "0.4.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "quickcheck" version))
+        (uri (crate-uri "owning_ref" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0mkl4wnvvjk4m32aq3an4ayfyvnmbxnzcybfm7n3fbsndb1xjdcw"))))
+            "04zgwy77lin8qz398s6g44467pd6kjhbrlqifkia5rkr47mbi929"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-env-logger" ,rust-env-logger)
-         ("rust-log" ,rust-log)
-         ("rust-rand" ,rust-rand-0.6)
-         ("rust-rand-core" ,rust-rand-core))))
+        (("rust-stable-deref-trait" ,rust-stable-deref-trait))))
     (home-page
-      "https://github.com/BurntSushi/quickcheck")
+      "https://github.com/Kimundi/owning-ref-rs")
     (synopsis
-      "Automatic property based testing with shrinking.")
+      "A library for creating references that carry their owner with them.")
     (description
-      "Automatic property based testing with shrinking.")
-    (license (list license:unlicense
-                   license:expat))))
+      "A library for creating references that carry their owner with them.")
+    (license license:expat)))
 
-(define-public rust-rand
+(define-public rust-rand-os
   (package
-    (name "rust-rand")
-    (version "0.7.0")
+    (name "rust-rand-os")
+    (version "0.2.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "rand_os" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0b05gwx8nnxr9bydyjxd1rszdvqnm946ky15z103ssfrhc7anznl"))))
+          (base32
+            "06is69f8rfzs620g5b54k6cgy5yaycrsyqg55flyfrsf8g88733f"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-getrandom" ,rust-getrandom)
-        ("rust-libc" ,rust-libc)
-        ("rust-log" ,rust-log)
-        ("rust-packed-simd" ,rust-packed-simd)
-        ("rust-rand-chacha" ,rust-rand-chacha)
-        ("rust-rand-core" ,rust-rand-core)
-        ("rust-rand-hc" ,rust-rand-hc)
-        ("rust-rand-pcg" ,rust-rand-pcg))
-       #:cargo-development-inputs
-       (("rust-rand-hc" ,rust-rand-hc)
-        ("rust-rand-isaac" ,rust-rand-isaac)
-        ("rust-rand-pcg" ,rust-rand-pcg)
-        ("rust-rand-xorshift" ,rust-rand-xorshift)
-        ("rust-rand-xoshiro" ,rust-rand-xoshiro))))
-    (home-page "https://crates.io/crates/rand")
-    (synopsis
-      "Random number generators and other randomness functionality.")
-    (description
-      "Random number generators and other randomness functionality.")
+      `(#:cargo-inputs
+        (("rust-getrandom" ,rust-getrandom)
+         ("rust-rand-core" ,rust-rand-core))))
+    (home-page "https://crates.io/crates/rand_os")
+    (synopsis "OS backed Random Number Generator")
+    (description "OS backed Random Number Generator")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-0.6
+(define-public rust-rand-os-0.1
   (package
-    (inherit rust-rand)
-    (name "rust-rand")
-    (version "0.6.5")
+    (inherit rust-rand-os)
+    (name "rust-rand-os")
+    (version "0.1.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand" version))
+        (uri (crate-uri "rand_os" version))
         (file-name (string-append name "-" version ".tar.gz"))
         (sha256
          (base32
-          "1jl4449jcl4wgmzld6ffwqj5gwxrp8zvx8w573g1z368qg6xlwbd"))))
+          "0wahppm0s64gkr2vmhcgwc0lij37in1lgfxg5rbgqlz0l5vgcxbv"))))
     (arguments
      `(#:cargo-inputs
-       (("rust-autocfg" ,rust-autocfg)
+       (("rust-cloudabi" ,rust-cloudabi)
+        ("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
+        ("rust-getrandom" ,rust-getrandom)
         ("rust-libc" ,rust-libc)
         ("rust-log" ,rust-log)
-        ("rust-packed-simd" ,rust-packed-simd)
-        ("rust-rand-chacha" ,rust-rand-chacha-0.1)
         ("rust-rand-core" ,rust-rand-core-0.4)
-        ("rust-rand-hc" ,rust-rand-hc-0.1)
-        ("rust-rand-isaac" ,rust-rand-isaac-0.1)
-        ("rust-rand-jitter" ,rust-rand-jitter-0.1)
-        ("rust-rand-os" ,rust-rand-os-0.1)
-        ("rust-rand-pcg" ,rust-rand-pcg-0.1)
-        ("rust-rand-xorshift" ,rust-rand-xorshift-0.1)
-        ("rust-winapi" ,rust-winapi))
-       #:cargo-development-inputs
-       (("rust-average" ,rust-average-0.9)
-        ("rust-rand-xoshiro" ,rust-rand-xoshiro-0.1))))))
+        ("rust-rdrand" ,rust-rdrand-0.4)
+        ("rust-stdweb" ,rust-stdweb)
+        ("rust-wasm-bindgen" ,rust-wasm-bindgen)
+        ("rust-winapi" ,rust-winapi))))))
 
-(define-public rust-rand-0.5
+(define-public rust-rawpointer
   (package
-    (inherit rust-rand)
-    (name "rust-rand")
-    (version "0.5.6")
+    (name "rust-rawpointer")
+    (version "0.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand" version))
+        (uri (crate-uri "rawpointer" version))
         (file-name (string-append name "-" version ".tar.gz"))
         (sha256
          (base32
-          "1fdcgja9167hlzkf4g5daqwp498lwiyq7aqm05whklpbsdyc8666"))))
-    (arguments
-     `(#:cargo-inputs
-       (("rust-cloudabi" ,rust-cloudabi)
-        ("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
-        ("rust-libc" ,rust-libc)
-        ("rust-log" ,rust-log)
-        ("rust-rand-core" ,rust-rand-core-0.3)
-        ("rust-serde" ,rust-serde)
-        ("rust-serde-derive" ,rust-serde-derive)
-        ("rust-stdweb" ,rust-stdweb)
-        ("rust-winapi" ,rust-winapi))
-       #:cargo-development-inputs
-       (("rust-bincode" ,rust-bincode))))))
+          "06ghpm9y7gacks78s3maakha07kbnwrxif5q37r2l7z1sali3b7b"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/bluss/rawpointer/")
+    (synopsis "Extra methods for raw pointers. For example `.post_inc()` and `.pre_dec()` (c.f. `ptr++` and `--ptr`) and `ptrdistance`.")
+    (description "Extra methods for raw pointers. For example `.post_inc()` and `.pre_dec()` (c.f. `ptr++` and `--ptr`) and `ptrdistance`.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-rand-0.4
+(define-public rust-rspec
   (package
-    (inherit rust-rand)
-    (name "rust-rand")
-    (version "0.4.6")
+    (name "rust-rspec")
+    (version "1.0.0-beta.4")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "rspec" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "14qjfv3gggzhnma20k0sc1jf8y6pplsaq7n1j9ls5c8kf2wl0a2m"))))
+          (base32
+            "1abfzwkbxlwahb243k8d3fp6i135lx1aqmbfl79w9zlpng182ndk"))))
+    (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
-        ("rust-libc" ,rust-libc)
-        ("rust-rand-core" ,rust-rand-core-0.3)
-        ("rust-rdrand" ,rust-rdrand-0.4)
-        ("rust-winapi" ,rust-winapi))))))
-
-(define-public rust-rand-0.3
-  (package
-    (inherit rust-rand)
-    (name "rust-rand")
-    (version "0.3.23")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (crate-uri "rand" version))
-        (file-name (string-append name "-" version ".tar.gz"))
-        (sha256
-         (base32
-          "0v679h38pjjqj5h4md7v2slsvj6686qgcn7p9fbw3h43iwnk1b34"))))
-    (arguments
-     `(#:cargo-inputs
-       (("rust-libc" ,rust-libc)
-        ("rust-rand" ,rust-rand-0.4))))))
+      `(#:cargo-inputs
+        (("rust-colored" ,rust-colored)
+         ("rust-derive-new" ,rust-derive-new)
+         ("rust-derive-builder" ,rust-derive-builder)
+         ("rust-expectest" ,rust-expectest)
+         ("rust-rayon" ,rust-rayon))
+        #:cargo-development-inputs
+        (("rust-clippy" ,rust-clippy))))
+    (home-page "https://mackwic.github.io/rspec")
+    (synopsis
+      "Write Rspec-like tests with stable rust")
+    (description
+      "Write Rspec-like tests with stable rust")
+    (license license:mpl2.0)))
 
-(define-public rust-rand-chacha
+(define-public rust-packed-simd
   (package
-    (name "rust-rand-chacha")
-    (version "0.2.0")
+    (name "rust-packed-simd")
+    (version "0.3.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_chacha" version))
+        (uri (crate-uri "packed_simd" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "178d36jfkc4v95s25scc2vibj2hd2hlk64cs6id4hvzg89whd4z1"))))
+            "0822wqf6kzw4ig9ykndg348w2bxkhs3x64brzsvdxh2a1pyajpm8"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-c2-chacha" ,rust-c2-chacha)
-         ("rust-rand-core" ,rust-rand-core))
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-core-arch" ,rust-core-arch)
+         ("rust-sleef-sys" ,rust-sleef-sys))
         #:cargo-development-inputs
-        (("rust-autocfg" ,rust-autocfg))))
+        (("rust-arrayvec" ,rust-arrayvec)
+         ("rust-paste" ,rust-paste)
+         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
+         ("rust-wasm-bindgen-test"
+          ,rust-wasm-bindgen-test))))
     (home-page
-      "https://crates.io/crates/rand_chacha")
-    (synopsis "ChaCha random number generator")
-    (description "ChaCha random number generator")
+      "https://github.com/rust-lang-nursery/packed_simd")
+    (synopsis "Portable Packed SIMD vectors")
+    (description "Portable Packed SIMD vectors")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-chacha-0.1
+(define-public rust-parity-wasm
   (package
-    (inherit rust-rand-chacha)
-    (name "rust-rand-chacha")
-    (version "0.1.1")
+    (name "rust-parity-wasm")
+    (version "0.40.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_chacha" version))
+        (uri (crate-uri "parity-wasm" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1vxwyzs4fy1ffjc8l00fsyygpiss135irjf7nyxgq2v0lqf3lvam"))))
+            "0sp1nv5yjw2wpg2j7mjq3mhqqjqb85wmbxrgk27q2zvw7ddqmrky"))))
+    (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-autocfg" ,rust-autocfg)
-         ("rust-rand-core" ,rust-rand-core-0.3))))))
+      `(#:cargo-development-inputs
+        (("rust-time" ,rust-time))))
+    (home-page
+      "https://github.com/paritytech/parity-wasm")
+    (synopsis
+      "WebAssembly binary format serialization/deserialization/interpreter")
+    (description
+      "WebAssembly binary format serialization/deserialization/interpreter")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-rand-core
+(define-public rust-parking-lot
   (package
-    (name "rust-rand-core")
-    (version "0.5.0")
+    (name "rust-parking-lot")
+    (version "0.9.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_core" version))
+        (uri (crate-uri "parking_lot" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1jis94x9ri8xlxki2w2w5k29sjpfwgzkjylg7paganp74hrnhpk1"))))
+            "0lk2vq3hp88ygpgsrypdr3ss71fidnqbykva0csgxhmn5scb2hpq"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-getrandom" ,rust-getrandom)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))))
-    (home-page "https://crates.io/crates/rand_core")
+        (("rust-lock-api" ,rust-lock-api)
+         ("rust-parking-lot-core" ,rust-parking-lot-core))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-rand" ,rust-rand)
+         ("rust-rustc-version" ,rust-rustc-version))))
+    (home-page
+      "https://github.com/Amanieu/parking_lot")
     (synopsis
-      "Core random number generator traits and tools for implementation.")
+      "More compact and efficient implementations of the standard synchronization primitives.")
     (description
-      "Core random number generator traits and tools for implementation.")
+      "More compact and efficient implementations of the standard synchronization primitives.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-core-0.4
+(define-public rust-parking-lot-core
   (package
-    (inherit rust-rand-core)
-    (name "rust-rand-core")
-    (version "0.4.0")
+    (name "rust-parking-lot-core")
+    (version "0.6.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_core" version))
+        (uri (crate-uri "parking_lot_core" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "1h3dbrhi5qgflqnzzd86s48v1dn1l17bmdssi5q170whsm4sbryh"))))
+          (base32
+            "0ay67dpnrn68ryyvp720m9i8hzp189fd4d6slrs1lvmcwywv2xmq"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-serde" ,rust-serde)
-        ("rust-serde-derive" ,rust-serde-derive))))))
+      `(#:cargo-inputs
+        (("rust-backtrace" ,rust-backtrace)
+         ("rust-cfg-if" ,rust-cfg-if)
+         ("rust-cloudabi" ,rust-cloudabi)
+         ("rust-libc" ,rust-libc)
+         ("rust-petgraph" ,rust-petgraph)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-smallvec" ,rust-smallvec)
+         ("rust-thread-id" ,rust-thread-id)
+         ("rust-winapi" ,rust-winapi))
+        #:cargo-development-inputs
+        (("rust-rustc-version" ,rust-rustc-version))))
+    (home-page
+      "https://github.com/Amanieu/parking_lot")
+    (synopsis
+      "An advanced API for creating custom synchronization primitives.")
+    (description
+      "An advanced API for creating custom synchronization primitives.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-rand-core-0.3
+(define-public rust-paste
   (package
-    (inherit rust-rand-core)
-    (name "rust-rand-core")
-    (version "0.3.1")
+    (name "rust-paste")
+    (version "0.1.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_core" version))
+        (uri (crate-uri "paste" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0jzdgszfa4bliigiy4hi66k7fs3gfwi2qxn8vik84ph77fwdwvvs"))))
+          (base32
+            "0ygs077hlq8qlx5y46sfgrmhlqqgkmvvhn4x3y10arawalf4ljhz"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-rand-core" ,rust-rand-core-0.4))))))
+      `(#:cargo-inputs
+        (("rust-paste-impl" ,rust-paste-impl)
+         ("rust-proc-macro-hack" ,rust-proc-macro-hack))))
+    (home-page "https://github.com/dtolnay/paste")
+    (synopsis
+      "Macros for all your token pasting needs")
+    (description
+      "Macros for all your token pasting needs")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-rand-distr
+(define-public rust-paste-impl
   (package
-    (name "rust-rand-distr")
-    (version "0.2.1")
+    (name "rust-paste-impl")
+    (version "0.1.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_distr" version))
+        (uri (crate-uri "paste-impl" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "08drhcw9k4a79pri3rd1vkv7v9cbm6cf4i342nai39f527c58zn3"))))
+            "1rkh8nixmb7r1y0mjnsz62p6r1bqah5ciri7bwhmgcmq4gk9drr6"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand" ,rust-rand))
-        #:cargo-development-inputs
-        (("rust-average" ,rust-average)
-         ("rust-rand-pcg" ,rust-rand-pcg))))
-    (home-page "https://crates.io/crates/rand_distr")
+        (("rust-proc-macro-hack" ,rust-proc-macro-hack)
+         ("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/dtolnay/paste")
     (synopsis
-      "Sampling from random number distributions")
+      "Implementation detail of the `paste` crate")
     (description
-      "Sampling from random number distributions")
+      "Implementation detail of the `paste` crate")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-hc
+(define-public rust-permutohedron
   (package
-    (name "rust-rand-hc")
-    (version "0.2.0")
+    (name "rust-permutohedron")
+    (version "0.2.4")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_hc" version))
+        (uri (crate-uri "permutohedron" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0g31sqwpmsirdlwr0svnacr4dbqyz339im4ssl9738cjgfpjjcfa"))))
+            "0b1pzh48j86v46wxngch6k1kx9cdw3jr3lwa86gd6jd4bmxzz1xn"))))
     (build-system cargo-build-system)
-    (arguments
-      `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core))))
-    (home-page "https://crates.io/crates/rand_hc")
-    (synopsis "HC128 random number generator")
-    (description "HC128 random number generator")
+    (home-page
+      "https://github.com/bluss/permutohedron")
+    (synopsis
+      "Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.")
+    (description
+      "Generate permutations of sequences. Either lexicographical order permutations, or a minimal swaps permutation sequence implemented using Heap's algorithm.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-hc-0.1
+(define-public rust-persistent
   (package
-    (inherit rust-rand-hc)
-    (name "rust-rand-hc")
-    (version "0.1.0")
+    (name "rust-persistent")
+    (version "0.4.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_hc" version))
+        (uri (crate-uri "persistent" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1i0vl8q5ddvvy0x8hf1zxny393miyzxkwqnw31ifg6p0gdy6fh3v"))))
+            "1iblxjjzd0h784l5y573nw5z3pdb3330k69hh413agagkh0a13wf"))))
+    (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core-0.3))))))
+        (("rust-iron" ,rust-iron)
+         ("rust-plugin" ,rust-plugin))))
+    (home-page "https://github.com/iron/persistent")
+    (synopsis "A set of middleware for sharing server-global data in Iron.")
+    (description "A set of middleware for sharing server-global data in Iron.")
+    (license license:expat)))
 
-(define-public rust-rand-isaac
+(define-public rust-pest
   (package
-    (name "rust-rand-isaac")
-    (version "0.2.0")
+    (name "rust-pest")
+    (version "2.1.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_isaac" version))
+        (uri (crate-uri "pest" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0xlb9415x518ffkazxhvk8b04i9i548nva4i5l5s34crvjrv1xld"))))
+            "134686mwxm73asbiads53zfchqvvcrsrsyax2cghfcizmvg8ac4k"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode))))
-    (home-page "https://crates.io/crates/rand_isaac")
-    (synopsis "ISAAC random number generator")
-    (description "ISAAC random number generator")
+        (("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-ucd-trie" ,rust-ucd-trie))))
+    (home-page "https://pest-parser.github.io/")
+    (synopsis "The Elegant Parser")
+    (description "The Elegant Parser")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-isaac-0.1
+(define-public rust-pest-derive
   (package
-    (inherit rust-rand-isaac)
-    (name "rust-rand-isaac")
-    (version "0.1.1")
+    (name "rust-pest-derive")
+    (version "2.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_isaac" version))
+        (uri (crate-uri "pest_derive" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "027flpjr4znx2csxk7gxb7vrf9c7y5mydmvg5az2afgisp4rgnfy"))))
+            "1l5jfa6ril71cw5nsiw0r45br54dd8cj2r1nc2d1wq6wb3jilgc3"))))
+    (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core-0.3)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))
-        #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode))))))
+        (("rust-pest" ,rust-pest)
+         ("rust-pest-generator" ,rust-pest-generator))))
+    (home-page "https://pest-parser.github.io/")
+    (synopsis "pest's derive macro")
+    (description "pest's derive macro")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-rand-jitter
+(define-public rust-pest-generator
   (package
-    (name "rust-rand-jitter")
-    (version "0.2.0")
+    (name "rust-pest-generator")
+    (version "2.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_jitter" version))
+        (uri (crate-uri "pest_generator" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1mnjbfzj97g788jslz0k77bpsg6qjhz676cibk82ibbvgqp4sy43"))))
+            "0ipnv77lqhj4d4fpfxi8m168lcjp482kszaknlardmpgqiv0a4k3"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-libc" ,rust-libc)
-         ("rust-log" ,rust-log)
-         ("rust-rand-core" ,rust-rand-core)
-         ("rust-winapi" ,rust-winapi))))
-    (home-page "https://github.com/rust-random/rand")
-    (synopsis
-      "Random number generator based on timing jitter")
-    (description
-      "Random number generator based on timing jitter")
+        (("rust-pest" ,rust-pest)
+         ("rust-pest-meta" ,rust-pest-meta)
+         ("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))))
+    (home-page "https://pest-parser.github.io/")
+    (synopsis "pest code generator")
+    (description "pest code generator")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-jitter-0.1
+(define-public rust-pest-meta
   (package
-    (inherit rust-rand-jitter)
-    (name "rust-rand-jitter")
-    (version "0.1.4")
+    (name "rust-pest-meta")
+    (version "2.1.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_jitter" version))
+        (uri (crate-uri "pest_meta" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "16z387y46bfz3csc42zxbjq89vcr1axqacncvv8qhyy93p4xarhi"))))
+            "0kaprdz3jis9bjfwhri1zncbsvack5m3gx2g5flspdy7wxnyljgj"))))
+    (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-libc" ,rust-libc)
-         ("rust-log" ,rust-log)
-         ("rust-rand-core" ,rust-rand-core-0.4)
-         ("rust-winapi" ,rust-winapi))))))
+     `(#:cargo-inputs
+       (("rust-maplit" ,rust-maplit)
+        ("rust-pest" ,rust-pest)
+        ("rust-sha-1" ,rust-sha-1))))
+    (home-page "https://pest-parser.github.io/")
+    (synopsis "pest meta language parser and validator")
+    (description
+      "pest meta language parser and validator")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-rand-pcg
+(define-public rust-petgraph
   (package
-    (name "rust-rand-pcg")
-    (version "0.2.0")
+    (name "rust-petgraph")
+    (version "0.4.13")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_pcg" version))
+        (uri (crate-uri "petgraph" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1dljwilv3640l1c5vlg4isiq7qz8gqa2cjbvgv3p0p5wrd36669y"))))
+            "0kyfmca854s54jk26g2x1kjb04c3k7cjilaxyr0if8lhxv8mjdlw"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-autocfg" ,rust-autocfg)
-         ("rust-rand-core" ,rust-rand-core)
-         ("rust-serde" ,rust-serde))
+        (("rust-fixedbitset" ,rust-fixedbitset)
+         ("rust-ordermap" ,rust-ordermap)
+         ("rust-quickcheck" ,rust-quickcheck)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))
         #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode))))
-    (home-page "https://crates.io/crates/rand_pcg")
+        (("rust-defmac" ,rust-defmac)
+         ("rust-itertools" ,rust-itertools)
+         ("rust-odds" ,rust-odds)
+         ("rust-rand" ,rust-rand-0.3))))
+    (home-page
+      "https://github.com/bluss/petgraph")
     (synopsis
-      "Selected PCG random number generators")
+      "Graph data structure library. Provides graph types and graph algorithms.")
     (description
-      "Selected PCG random number generators")
+      "Graph data structure library. Provides graph types and graph algorithms.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-pcg-0.1
+(define-public rust-pico-sys
   (package
-    (inherit rust-rand-pcg)
-    (name "rust-rand-pcg")
-    (version "0.1.2")
+    (name "rust-pico-sys")
+    (version "0.0.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_pcg" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "pico-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
          (base32
-          "0i0bdla18a8x4jn1w0fxsbs3jg7ajllz6azmch1zw33r06dv1ydb"))))
+          "1q5pg0ms6szz6b5h26h4k40zb76zbwwjgyigac4wly9qngdj4yl5"))))
+    (build-system cargo-build-system)
     (arguments
      `(#:cargo-inputs
-       (("rust-autocfg" ,rust-autocfg)
-        ("rust-rand-core" ,rust-rand-core-0.4)
-        ("rust-serde" ,rust-serde)
-        ("rust-serde" ,rust-serde-derive))
-       #:cargo-development-inputs
-       (("rust-bincode" ,rust-bincode))))))
+       (("rust-cc" ,rust-cc)
+        ("rust-libc" ,rust-libc))))
+    (home-page "https://github.com/reem/rust-pico-sys.git")
+    (synopsis
+      "Bindings to the PicoHTTPParser.")
+    (description
+      "Bindings to the PicoHTTPParser.")
+    (license license:expat)))
 
-(define-public rust-rand-xorshift
+(define-public rust-pkg-config
   (package
-    (name "rust-rand-xorshift")
-    (version "0.2.0")
+    (name "rust-pkg-config")
+    (version "0.3.14")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_xorshift" version))
+        (uri (crate-uri "pkg-config" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1a6wy76lc5fimm1n9n8fzhp4cfjwfwxh4hx63bg3vlh1d2w1dm3p"))))
+            "135ia995lqzr0gxpk85h0bjxf82kj6hbxdx924sh9jdln6r8wvk7"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode))))
+     `(#:cargo-development-inputs
+       (("rust-lazy-static" ,rust-lazy-static))))
+    (inputs
+     `(("pkg-config" ,(@ (gnu packages pkg-config) pkg-config))))
     (home-page
-      "https://crates.io/crates/rand_xorshift")
-    (synopsis "Xorshift random number generator")
+      "https://github.com/alexcrichton/pkg-config-rs")
+    (synopsis
+      "A library to run the pkg-config system tool at build time in order to be used in Cargo build scripts.")
     (description
-      "Xorshift random number generator")
+      "A library to run the pkg-config system tool at build time in order to be used in Cargo build scripts.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-xorshift-0.1
+(define-public rust-plugin
   (package
-    (inherit rust-rand-xorshift)
-    (name "rust-rand-xorshift")
-    (version "0.1.1")
+    (name "rust-plugin")
+    (version "0.2.6")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_xorshift" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "plugin" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0p2x8nr00hricpi2m6ca5vysiha7ybnghz79yqhhx6sl4gkfkxyb"))))
+          (base32
+            "1q7nghkpvxxr168y2jnzh3w7qc9vfrby9n7ygy3xpj0bj71hsshs"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core-0.3)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde" ,rust-serde-derive))
+        (("rust-typemap" ,rust-typemap))
         #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode))))))
+        (("rust-void" ,rust-void))))
+    (home-page "https://github.com/reem/rust-plugin")
+    (synopsis
+      "Lazily evaluated, order-independent plugins for extensible types.")
+    (description
+      "Lazily evaluated, order-independent plugins for extensible types.")
+    (license license:expat)))
 
-(define-public rust-rand-xoshiro
+(define-public rust-pretty-env-logger
   (package
-    (name "rust-rand-xoshiro")
-    (version "0.3.0")
+    (name "rust-pretty-env-logger")
+    (version "0.3.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_xoshiro" version))
+        (uri (crate-uri "pretty_env_logger" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "07w3qgrac8r356lz5vqff42rly6yd9vs3g5lx5pbn13rcmb05rqb"))))
+            "0x4hyjlnvvhyk9m74iypzybm22w3dl2k8img4b956239n5vf8zki"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-byteorder" ,rust-byteorder)
-         ("rust-rand-core" ,rust-rand-core)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode))))
+        (("rust-chrono" ,rust-chrono)
+         ("rust-env-logger" ,rust-env-logger)
+         ("rust-log" ,rust-log))))
     (home-page
-      "https://crates.io/crates/rand_xoshiro")
+      "https://github.com/seanmonstar/pretty-env-logger")
     (synopsis
-      "Xoshiro, xoroshiro and splitmix64 random number generators")
+      "A simple logger built on top off env_logger. It is configured via an environment variable and writes to standard error with nice colored output for log levels.")
     (description
-      "Xoshiro, xoroshiro and splitmix64 random number generators")
+      "A simple logger built on top off env_logger. It is configured via an environment variable and writes to standard error with nice colored output for log levels.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rand-xoshiro-0.1
+(define-public rust-pretty-assertions
   (package
-    (inherit rust-rand-xoshiro)
-    (name "rust-rand-xoshiro")
-    (version "0.1.0")
+    (name "rust-pretty-assertions")
+    (version "0.6.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rand_xoshiro" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "pretty_assertions" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0ac9ha6ll8b6l1930bd99k29jrjpsbpddvr6ycrnbi5rkwb1id03"))))
+          (base32
+            "09yl14gnmpygiqrdlsa64lcl4w6ydjl9m8jri6kgam0v9rjf309z"))))
+    (build-system cargo-build-system)
     (arguments
      `(#:cargo-inputs
-       (("rust-byteorder" ,rust-byteorder)
-        ("rust-rand-core" ,rust-rand-core-0.3))
-       #:cargo-development-inputs
-       (("rust-rand" ,rust-rand-0.6))))))
+       (("rust-ansi-term" ,rust-ansi-term)
+        ("rust-ctor" ,rust-ctor)
+        ("rust-difference" ,rust-difference)
+        ("rust-output-vt100" ,rust-output-vt100))))
+    (home-page
+      "https://github.com/colin-kiegel/rust-pretty-assertions")
+    (synopsis
+      "When writing tests in Rust, you'll probably use assert_eq!(a, b) a lot.
 
-(define-public rust-rayon
+      If such a test fails, it will present all the details of a and b. But you have to spot the differences yourself, which is not always straightforward, like here:")
+    (description
+      "When writing tests in Rust, you'll probably use assert_eq!(a, b) a lot.
+
+      If such a test fails, it will present all the details of a and b. But you have to spot the differences yourself, which is not always straightforward, like here:")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-proc-macro-nested ; guix upstreamable
   (package
-    (name "rust-rayon")
-    (version "1.1.0")
+    (name "rust-proc-macro-nested")
+    (version "0.1.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rayon" version))
+        (uri (crate-uri "proc-macro-nested" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0bmlksm8vl44wkwihmwr7jsjznhbg0n7aibcw1cs2jgjcp86x6in"))))
+    (build-system cargo-build-system)
+    (home-page "https://github.com/dtolnay/proc-macro-hack")
+    (synopsis "Support for nested proc-macro-hack invocations")
+    (description "This crate provides support for nested proc-macro-hack
+invocations.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-proptest
+  (package
+    (name "rust-proptest")
+    (version "0.9.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "proptest" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "190hkbcdfvcphyyzkdg52zdia2y9d9yanpm072bmnzbn49p1ic54"))))
+            "17sjg8isas4qk85807c4panih9k0lwa4k1mbajhciw5c5q17w56g"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-crossbeam-deque" ,rust-crossbeam-deque-0.6)
-         ("rust-either" ,rust-either)
-         ("rust-rayon-core" ,rust-rayon-core))
-        #:cargo-development-inputs
-        (("rust-doc-comment" ,rust-doc-comment)
-         ("rust-docopt" ,rust-docopt)
+        (("rust-bit-set" ,rust-bit-set)
+         ("rust-bitflags" ,rust-bitflags)
+         ("rust-byteorder" ,rust-byteorder)
          ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-rand" ,rust-rand-0.6)
+         ("rust-num-traits" ,rust-num-traits)
+         ("rust-quick-error" ,rust-quick-error)
+         ("rust-rand" ,rust-rand)
+         ("rust-rand-chacha" ,rust-rand-chacha)
          ("rust-rand-xorshift" ,rust-rand-xorshift)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))))
-    (home-page "https://github.com/rayon-rs/rayon")
+         ("rust-regex-syntax" ,rust-regex-syntax)
+         ("rust-rusty-fork" ,rust-rusty-fork)
+         ("rust-tempfile" ,rust-tempfile))
+        #:cargo-development-inputs
+        (("rust-regex" ,rust-regex))))
+    (home-page
+      "https://altsysrq.github.io/proptest-book/proptest/index.html")
     (synopsis
-      "Simple work-stealing parallelism for Rust")
+      "Hypothesis-like property-based testing and shrinking.")
     (description
-      "Simple work-stealing parallelism for Rust")
+      "Hypothesis-like property-based testing and shrinking.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rayon-1.0
+(define-public rust-proc-macro-hack
   (package
-    (inherit rust-rayon)
-    (name "rust-rayon")
-    (version "1.0.3")
+    (name "rust-proc-macro-hack")
+    (version "0.5.8")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rayon" version))
+        (uri (crate-uri "proc-macro-hack" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "0wq41f15y05nlarijn9c1vxscxj5sazn3lhd6mmnicj5fzr18f1p"))))
+          (base32
+            "0y2ix90qdvsfks4j1g5qnpyzaa6a4j6sdi35klqvm120378kaalq"))))
+    (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-crossbeam-deque" ,rust-crossbeam-deque-0.2)
-         ("rust-either" ,rust-either)
-         ("rust-rand" ,rust-rand-0.5)
-         ("rust-rayon-core" ,rust-rayon-core))
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))
         #:cargo-development-inputs
-        (("rust-docopt" ,rust-docopt)
-         ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))))))
-
-(define-public rust-rayon-core
+        (("rust-demo-hack" ,rust-demo-hack)
+         ("rust-demo-hack-impl" ,rust-demo-hack-impl))))
+    (home-page
+      "https://github.com/dtolnay/proc-macro-hack")
+    (synopsis
+      "Procedural functionlike!() macros using only Macros 1.1")
+    (description
+      "Procedural functionlike!() macros using only Macros 1.1")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-proc-macro-hack-0.4
   (package
-    (name "rust-rayon-core")
-    (version "1.5.0")
+    (inherit rust-proc-macro-hack)
+    (name "rust-proc-macro-hack")
+    (version "0.4.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rayon-core" version))
+        (uri (crate-uri "proc-macro-hack" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0fxn3qfhw76c518dfal2qqjwj5dbf0a1f7z0r5c4wd0igygg4fs6"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-proc-macro-hack-impl" ,rust-proc-macro-hack-impl))
+        #:cargo-development-inputs
+        (("rust-demo-hack" ,rust-demo-hack)
+         ("rust-demo-hack-impl" ,rust-demo-hack-impl))))))
+
+(define-public rust-publicsuffix
+  (package
+    (name "rust-publicsuffix")
+    (version "1.5.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "publicsuffix" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
          (base32
-          "1ljva6blaf1wmzvg77h1i9pd0hsmsbbcmdk7sjbw7h2s8gw0vgpb"))))
+          "07ddqpri1xy7nxg5b7z8w49gw90rkn4qjvr423b4y7ngdnlcpzjs"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-crossbeam-deque" ,rust-crossbeam-deque-0.6)
-         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
-         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
+        (("rust-error-chain" ,rust-error-chain)
+         ("rust-idna" ,rust-idna)
          ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-num-cpus" ,rust-num-cpus))
+         ("rust-regex" ,rust-regex)
+         ("rust-url" ,rust-url)
+         ("rust-native-tls" ,rust-native-tls))
         #:cargo-development-inputs
-        (("rust-libc" ,rust-libc)
-         ("rust-rand" ,rust-rand)
-         ("rust-rand-xorshift" ,rust-rand-xorshift)
-         ("rust-scoped-tls" ,rust-scoped-tls))))
-    (home-page "https://github.com/rayon-rs/rayon")
-    (synopsis "Core APIs for Rayon")
-    (description "Core APIs for Rayon")
+        (("rust-rspec" ,rust-rspec))))
+    (home-page
+      "https://github.com/rushmorem/publicsuffix")
+    (synopsis
+      "Robust domain name parsing and RFC compliant email address validation")
+    (description
+      "Robust domain name parsing and RFC compliant email address validation")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rdrand
+(define-public rust-pulldown-cmark
   (package
-    (name "rust-rdrand")
-    (version "0.5.1")
+    (name "rust-pulldown-cmark")
+    (version "0.5.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rdrand" version))
+        (uri (crate-uri "pulldown-cmark" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "02dsyibvl1iygkmljr0ld9vjyp525q4mjy5j9yazrrkyvhvw7gvp"))))
+            "0mq3cgjwxlrv0p1svjg93m1jkybzyfrl9p0jwa76hx1352hks13p"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core))))
+        (("rust-bitflags" ,rust-bitflags)
+         ("rust-getopts" ,rust-getopts)
+         ("rust-memchr" ,rust-memchr)
+         ("rust-unicase" ,rust-unicase))
+        #:cargo-development-inputs
+        (("rust-criterion" ,rust-criterion)
+         ("rust-html5ever" ,rust-html5ever)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-regex" ,rust-regex)
+         ("rust-tendril" ,rust-tendril))))
     (home-page
-      "https://github.com/nagisa/rust_rdrand/")
+      "https://github.com/raphlinus/pulldown-cmark")
+    (synopsis "A pull parser for CommonMark")
+    (description
+      "This package provides a pull parser for CommonMark")
+    (license license:expat)))
+
+(define-public rust-quantiles
+  (package
+    (name "rust-quantiles")
+    (version "0.7.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "quantiles" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1wjp16a3d4bmldq9w2wds0q4gjz4mnsqac3g38r6ryr6zc9sh3y1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))
+        #:cargo-development-inputs
+        (("rust-quickcheck" ,rust-quickcheck))))
+    (home-page
+      "https://github.com/postmates/quantiles")
     (synopsis
-      "An implementation of random number generator based on rdrand and rdseed instructions")
+      "a collection of approximate quantile algorithms")
     (description
-      "An implementation of random number generator based on rdrand and rdseed instructions")
-    (license license:isc)))
+      "a collection of approximate quantile algorithms")
+    (license license:expat)))
 
-(define-public rust-rdrand-0.4
+(define-public rust-quickcheck
   (package
-    (inherit rust-rdrand)
-    (name "rust-rdrand")
-    (version "0.4.0")
+    (name "rust-quickcheck")
+    (version "0.8.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rdrand" version))
+        (uri (crate-uri "quickcheck" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1cjq0kwx1bk7jx3kzyciiish5gqsj7620dm43dc52sr8fzmm9037"))))
+            "0mkl4wnvvjk4m32aq3an4ayfyvnmbxnzcybfm7n3fbsndb1xjdcw"))))
+    (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-rand-core" ,rust-rand-core-0.3))))))
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-log" ,rust-log)
+         ("rust-rand" ,rust-rand-0.6)
+         ("rust-rand-core" ,rust-rand-core))))
+    (home-page
+      "https://github.com/BurntSushi/quickcheck")
+    (synopsis
+      "Automatic property based testing with shrinking.")
+    (description
+      "Automatic property based testing with shrinking.")
+    (license (list license:unlicense
+                   license:expat))))
 
-(define-public rust-redox-syscall ; guix upstreamable
+(define-public rust-quickcheck-0.7
+  (package
+    (inherit rust-quickcheck)
+    (name "rust-quickcheck")
+    (version "0.7.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "quickcheck" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "05pqzja6fwdyrs1za5vmxb9ifb993knmpdsrs1fs2wyz9qz7slyl"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-env-logger" ,rust-env-logger-0.5)
+        ("rust-log" ,rust-log)
+        ("rust-rand" ,rust-rand-0.5)
+        ("rust-rand-core" ,rust-rand-core-0.2))))))
+
+(define-public rust-quickcheck-0.6
+  (package
+    (inherit rust-quickcheck)
+    (name "rust-quickcheck")
+    (version "0.6.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "quickcheck" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1dyazm2fcq0v9fscq1a7597zsvdl9f0j8c2bfj1jm2nlzz2sn6y0"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-env-logger" ,rust-env-logger-0.5)
+        ("rust-log" ,rust-log)
+        ("rust-rand" ,rust-rand-0.4))))))
+
+(define-public rust-quickcheck-0.5
+  (package
+    (inherit rust-quickcheck)
+    (name "rust-quickcheck")
+    (version "0.5.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "quickcheck" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1jzm1ygfbn4igaq14b9nipc8yvsn6c8panpgd1qiy5r2insjllyd"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-env-logger" ,rust-env-logger-0.4)
+        ("rust-log" ,rust-log-0.3)
+        ("rust-rand" ,rust-rand-0.3))))))
+
+(define-public rust-rand
+  (package
+    (name "rust-rand")
+    (version "0.7.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0b05gwx8nnxr9bydyjxd1rszdvqnm946ky15z103ssfrhc7anznl"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-getrandom" ,rust-getrandom)
+        ("rust-libc" ,rust-libc)
+        ("rust-log" ,rust-log)
+        ("rust-packed-simd" ,rust-packed-simd)
+        ("rust-rand-chacha" ,rust-rand-chacha)
+        ("rust-rand-core" ,rust-rand-core)
+        ("rust-rand-hc" ,rust-rand-hc)
+        ("rust-rand-pcg" ,rust-rand-pcg))
+       #:cargo-development-inputs
+       (("rust-rand-hc" ,rust-rand-hc)
+        ("rust-rand-isaac" ,rust-rand-isaac)
+        ("rust-rand-pcg" ,rust-rand-pcg)
+        ("rust-rand-xorshift" ,rust-rand-xorshift)
+        ("rust-rand-xoshiro" ,rust-rand-xoshiro))))
+    (home-page "https://crates.io/crates/rand")
+    (synopsis
+      "Random number generators and other randomness functionality.")
+    (description
+      "Random number generators and other randomness functionality.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-0.6
+  (package
+    (inherit rust-rand)
+    (name "rust-rand")
+    (version "0.6.5")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1jl4449jcl4wgmzld6ffwqj5gwxrp8zvx8w573g1z368qg6xlwbd"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-autocfg" ,rust-autocfg)
+        ("rust-libc" ,rust-libc)
+        ("rust-log" ,rust-log)
+        ("rust-packed-simd" ,rust-packed-simd)
+        ("rust-rand-chacha" ,rust-rand-chacha-0.1)
+        ("rust-rand-core" ,rust-rand-core-0.4)
+        ("rust-rand-hc" ,rust-rand-hc-0.1)
+        ("rust-rand-isaac" ,rust-rand-isaac-0.1)
+        ("rust-rand-jitter" ,rust-rand-jitter-0.1)
+        ("rust-rand-os" ,rust-rand-os-0.1)
+        ("rust-rand-pcg" ,rust-rand-pcg-0.1)
+        ("rust-rand-xorshift" ,rust-rand-xorshift-0.1)
+        ("rust-winapi" ,rust-winapi))
+       #:cargo-development-inputs
+       (("rust-average" ,rust-average-0.9)
+        ("rust-rand-xoshiro" ,rust-rand-xoshiro-0.1))))))
+
+(define-public rust-rand-0.5
+  (package
+    (inherit rust-rand)
+    (name "rust-rand")
+    (version "0.5.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1fdcgja9167hlzkf4g5daqwp498lwiyq7aqm05whklpbsdyc8666"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-cloudabi" ,rust-cloudabi)
+        ("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
+        ("rust-libc" ,rust-libc)
+        ("rust-log" ,rust-log)
+        ("rust-rand-core" ,rust-rand-core-0.3)
+        ("rust-serde" ,rust-serde)
+        ("rust-serde-derive" ,rust-serde-derive)
+        ("rust-stdweb" ,rust-stdweb)
+        ("rust-winapi" ,rust-winapi))
+       #:cargo-development-inputs
+       (("rust-bincode" ,rust-bincode))))))
+
+(define-public rust-rand-0.4
+  (package
+    (inherit rust-rand)
+    (name "rust-rand")
+    (version "0.4.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "14qjfv3gggzhnma20k0sc1jf8y6pplsaq7n1j9ls5c8kf2wl0a2m"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
+        ("rust-libc" ,rust-libc)
+        ("rust-rand-core" ,rust-rand-core-0.3)
+        ("rust-rdrand" ,rust-rdrand-0.4)
+        ("rust-winapi" ,rust-winapi))))))
+
+(define-public rust-rand-0.3
+  (package
+    (inherit rust-rand)
+    (name "rust-rand")
+    (version "0.3.23")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0v679h38pjjqj5h4md7v2slsvj6686qgcn7p9fbw3h43iwnk1b34"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-libc" ,rust-libc)
+        ("rust-rand" ,rust-rand-0.4))))))
+
+(define-public rust-rand-chacha
+  (package
+    (name "rust-rand-chacha")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_chacha" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "178d36jfkc4v95s25scc2vibj2hd2hlk64cs6id4hvzg89whd4z1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-c2-chacha" ,rust-c2-chacha)
+         ("rust-rand-core" ,rust-rand-core))
+        #:cargo-development-inputs
+        (("rust-autocfg" ,rust-autocfg))))
+    (home-page
+      "https://crates.io/crates/rand_chacha")
+    (synopsis "ChaCha random number generator")
+    (description "ChaCha random number generator")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-chacha-0.1
+  (package
+    (inherit rust-rand-chacha)
+    (name "rust-rand-chacha")
+    (version "0.1.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_chacha" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1vxwyzs4fy1ffjc8l00fsyygpiss135irjf7nyxgq2v0lqf3lvam"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-autocfg" ,rust-autocfg)
+         ("rust-rand-core" ,rust-rand-core-0.3))))))
+
+(define-public rust-rand-core
+  (package
+    (name "rust-rand-core")
+    (version "0.5.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_core" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1jis94x9ri8xlxki2w2w5k29sjpfwgzkjylg7paganp74hrnhpk1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-getrandom" ,rust-getrandom)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://crates.io/crates/rand_core")
+    (synopsis
+      "Core random number generator traits and tools for implementation.")
+    (description
+      "Core random number generator traits and tools for implementation.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-core-0.4
+  (package
+    (inherit rust-rand-core)
+    (name "rust-rand-core")
+    (version "0.4.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_core" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1p09ynysrq1vcdlmcqnapq4qakl2yd1ng3kxh3qscpx09k2a6cww"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-serde" ,rust-serde)
+        ("rust-serde-derive" ,rust-serde-derive))))))
+
+(define-public rust-rand-core-0.3
+  (package
+    (inherit rust-rand-core)
+    (name "rust-rand-core")
+    (version "0.3.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_core" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0jzdgszfa4bliigiy4hi66k7fs3gfwi2qxn8vik84ph77fwdwvvs"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-rand-core" ,rust-rand-core-0.4))))))
+
+(define-public rust-rand-core-0.2
+  (package
+    (inherit rust-rand-core)
+    (name "rust-rand-core")
+    (version "0.2.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_core" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0wikbw2a36bz8ywjyycjrd7db6ra3yzj14zs1ysxz2fiqhia8q8r"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-rand-core" ,rust-rand-core-0.3))))))
+
+(define-public rust-rand-distr
+  (package
+    (name "rust-rand-distr")
+    (version "0.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_distr" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "08drhcw9k4a79pri3rd1vkv7v9cbm6cf4i342nai39f527c58zn3"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand" ,rust-rand))
+        #:cargo-development-inputs
+        (("rust-average" ,rust-average)
+         ("rust-rand-pcg" ,rust-rand-pcg))))
+    (home-page "https://crates.io/crates/rand_distr")
+    (synopsis
+      "Sampling from random number distributions")
+    (description
+      "Sampling from random number distributions")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-hc
+  (package
+    (name "rust-rand-hc")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_hc" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0g31sqwpmsirdlwr0svnacr4dbqyz339im4ssl9738cjgfpjjcfa"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core))))
+    (home-page "https://crates.io/crates/rand_hc")
+    (synopsis "HC128 random number generator")
+    (description "HC128 random number generator")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-hc-0.1
+  (package
+    (inherit rust-rand-hc)
+    (name "rust-rand-hc")
+    (version "0.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_hc" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1i0vl8q5ddvvy0x8hf1zxny393miyzxkwqnw31ifg6p0gdy6fh3v"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core-0.3))))))
+
+(define-public rust-rand-isaac
+  (package
+    (name "rust-rand-isaac")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_isaac" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0xlb9415x518ffkazxhvk8b04i9i548nva4i5l5s34crvjrv1xld"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))
+    (home-page "https://crates.io/crates/rand_isaac")
+    (synopsis "ISAAC random number generator")
+    (description "ISAAC random number generator")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-isaac-0.1
+  (package
+    (inherit rust-rand-isaac)
+    (name "rust-rand-isaac")
+    (version "0.1.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_isaac" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "027flpjr4znx2csxk7gxb7vrf9c7y5mydmvg5az2afgisp4rgnfy"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core-0.3)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))))
+
+(define-public rust-rand-jitter
+  (package
+    (name "rust-rand-jitter")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_jitter" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1mnjbfzj97g788jslz0k77bpsg6qjhz676cibk82ibbvgqp4sy43"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-libc" ,rust-libc)
+         ("rust-log" ,rust-log)
+         ("rust-rand-core" ,rust-rand-core)
+         ("rust-winapi" ,rust-winapi))))
+    (home-page "https://github.com/rust-random/rand")
+    (synopsis
+      "Random number generator based on timing jitter")
+    (description
+      "Random number generator based on timing jitter")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-jitter-0.1
+  (package
+    (inherit rust-rand-jitter)
+    (name "rust-rand-jitter")
+    (version "0.1.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_jitter" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "16z387y46bfz3csc42zxbjq89vcr1axqacncvv8qhyy93p4xarhi"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-libc" ,rust-libc)
+         ("rust-log" ,rust-log)
+         ("rust-rand-core" ,rust-rand-core-0.4)
+         ("rust-winapi" ,rust-winapi))))))
+
+(define-public rust-rand-pcg
+  (package
+    (name "rust-rand-pcg")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_pcg" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1dljwilv3640l1c5vlg4isiq7qz8gqa2cjbvgv3p0p5wrd36669y"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-autocfg" ,rust-autocfg)
+         ("rust-rand-core" ,rust-rand-core)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))
+    (home-page "https://crates.io/crates/rand_pcg")
+    (synopsis
+      "Selected PCG random number generators")
+    (description
+      "Selected PCG random number generators")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-pcg-0.1
+  (package
+    (inherit rust-rand-pcg)
+    (name "rust-rand-pcg")
+    (version "0.1.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_pcg" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0i0bdla18a8x4jn1w0fxsbs3jg7ajllz6azmch1zw33r06dv1ydb"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-autocfg" ,rust-autocfg)
+        ("rust-rand-core" ,rust-rand-core-0.4)
+        ("rust-serde" ,rust-serde)
+        ("rust-serde" ,rust-serde-derive))
+       #:cargo-development-inputs
+       (("rust-bincode" ,rust-bincode))))))
+
+(define-public rust-rand-xorshift
+  (package
+    (name "rust-rand-xorshift")
+    (version "0.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_xorshift" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1a6wy76lc5fimm1n9n8fzhp4cfjwfwxh4hx63bg3vlh1d2w1dm3p"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))
+    (home-page
+      "https://crates.io/crates/rand_xorshift")
+    (synopsis "Xorshift random number generator")
+    (description
+      "Xorshift random number generator")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-xorshift-0.1
+  (package
+    (inherit rust-rand-xorshift)
+    (name "rust-rand-xorshift")
+    (version "0.1.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_xorshift" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0p2x8nr00hricpi2m6ca5vysiha7ybnghz79yqhhx6sl4gkfkxyb"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core-0.3)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde" ,rust-serde-derive))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))))
+
+(define-public rust-rand-xoshiro
+  (package
+    (name "rust-rand-xoshiro")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_xoshiro" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "07w3qgrac8r356lz5vqff42rly6yd9vs3g5lx5pbn13rcmb05rqb"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-rand-core" ,rust-rand-core)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))
+    (home-page
+      "https://crates.io/crates/rand_xoshiro")
+    (synopsis
+      "Xoshiro, xoroshiro and splitmix64 random number generators")
+    (description
+      "Xoshiro, xoroshiro and splitmix64 random number generators")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rand-xoshiro-0.1
+  (package
+    (inherit rust-rand-xoshiro)
+    (name "rust-rand-xoshiro")
+    (version "0.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rand_xoshiro" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0ac9ha6ll8b6l1930bd99k29jrjpsbpddvr6ycrnbi5rkwb1id03"))))
+    (arguments
+     `(#:cargo-inputs
+       (("rust-byteorder" ,rust-byteorder)
+        ("rust-rand-core" ,rust-rand-core-0.3))
+       #:cargo-development-inputs
+       (("rust-rand" ,rust-rand-0.6))))))
+
+(define-public rust-rayon
+  (package
+    (name "rust-rayon")
+    (version "1.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rayon" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "190hkbcdfvcphyyzkdg52zdia2y9d9yanpm072bmnzbn49p1ic54"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-crossbeam-deque" ,rust-crossbeam-deque-0.6)
+         ("rust-either" ,rust-either)
+         ("rust-rayon-core" ,rust-rayon-core))
+        #:cargo-development-inputs
+        (("rust-doc-comment" ,rust-doc-comment)
+         ("rust-docopt" ,rust-docopt)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-rand" ,rust-rand-0.6)
+         ("rust-rand-xorshift" ,rust-rand-xorshift)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://github.com/rayon-rs/rayon")
+    (synopsis
+      "Simple work-stealing parallelism for Rust")
+    (description
+      "Simple work-stealing parallelism for Rust")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rayon-1.0
+  (package
+    (inherit rust-rayon)
+    (name "rust-rayon")
+    (version "1.0.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rayon" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0wq41f15y05nlarijn9c1vxscxj5sazn3lhd6mmnicj5fzr18f1p"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-crossbeam-deque" ,rust-crossbeam-deque-0.2)
+         ("rust-either" ,rust-either)
+         ("rust-rand" ,rust-rand-0.5)
+         ("rust-rayon-core" ,rust-rayon-core))
+        #:cargo-development-inputs
+        (("rust-docopt" ,rust-docopt)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))))))
+
+(define-public rust-rayon-core
+  (package
+    (name "rust-rayon-core")
+    (version "1.5.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rayon-core" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1ljva6blaf1wmzvg77h1i9pd0hsmsbbcmdk7sjbw7h2s8gw0vgpb"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-crossbeam-deque" ,rust-crossbeam-deque-0.6)
+         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
+         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-num-cpus" ,rust-num-cpus))
+        #:cargo-development-inputs
+        (("rust-libc" ,rust-libc)
+         ("rust-rand" ,rust-rand)
+         ("rust-rand-xorshift" ,rust-rand-xorshift)
+         ("rust-scoped-tls" ,rust-scoped-tls))))
+    (home-page "https://github.com/rayon-rs/rayon")
+    (synopsis "Core APIs for Rayon")
+    (description "Core APIs for Rayon")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rdrand
+  (package
+    (name "rust-rdrand")
+    (version "0.5.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rdrand" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "02dsyibvl1iygkmljr0ld9vjyp525q4mjy5j9yazrrkyvhvw7gvp"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core))))
+    (home-page
+      "https://github.com/nagisa/rust_rdrand/")
+    (synopsis
+      "An implementation of random number generator based on rdrand and rdseed instructions")
+    (description
+      "An implementation of random number generator based on rdrand and rdseed instructions")
+    (license license:isc)))
+
+(define-public rust-rdrand-0.4
+  (package
+    (inherit rust-rdrand)
+    (name "rust-rdrand")
+    (version "0.4.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rdrand" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1cjq0kwx1bk7jx3kzyciiish5gqsj7620dm43dc52sr8fzmm9037"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-rand-core" ,rust-rand-core-0.3))))))
+
+(define-public rust-redox-syscall ; guix upstreamable
+  (package
+    (name "rust-redox-syscall")
+    (version "0.1.56")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "redox_syscall" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "110y7dyfm2vci4x5vk7gr0q551dvp31npl99fnsx2fb17wzwcf94"))))
+    (build-system cargo-build-system)
+    (home-page "https://gitlab.redox-os.org/redox-os/syscall")
+    (synopsis "Rust library to access raw Redox system calls")
+    (description "This package provides a Rust library to access raw Redox
+system calls.")
+    (license license:expat)))
+
+(define-public rust-redox-users
+  (package
+    (name "rust-redox-users")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "redox_users" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0a1q5jv76vj1mwmqf2mmhknmkpw5wndx91gjfgg7vs8p79621r9z"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-argon2rs" ,rust-argon2rs)
+         ("rust-failure" ,rust-failure)
+         ("rust-rand-os" ,rust-rand-os)
+         ("rust-redox-syscall" ,rust-redox-syscall))))
+    (home-page
+      "https://gitlab.redox-os.org/redox-os/users")
+    (synopsis
+      "A Rust library to access Redox users and groups functionality")
+    (description
+      "This package provides a Rust library to access Redox users and groups functionality")
+    (license #f)))
+
+(define-public rust-ref-cast
+  (package
+    (name "rust-ref-cast")
+    (version "0.2.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ref-cast" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0jgj1zxaikqm030flpifbp517fy4z21lly6ysbwyciii39bkzcf1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-ref-cast-impl" ,rust-ref-cast-impl))))
+    (home-page "https://github.com/dtolnay/ref-cast")
+    (synopsis
+      "Safely cast &T to &U where the struct U contains a single field of type T.")
+    (description
+      "Safely cast &T to &U where the struct U contains a single field of type T.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-ref-cast-impl
+  (package
+    (name "rust-ref-cast-impl")
+    (version "0.2.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ref-cast-impl" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0hw0frpzna5rf5szix56zyzd0vackcb3svj94ndj629xi75dkb32"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/dtolnay/ref-cast")
+    (synopsis
+      "Derive implementation for ref_cast::RefCast.")
+    (description
+      "Derive implementation for ref_cast::RefCast.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-regex
+  (package
+    (name "rust-regex")
+    (version "1.2.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "regex" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1k6jpx0bqlg6vb8rsdnlmcw2szczbl51j047w3blpa4qzn6xl8vb"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-aho-corasick" ,rust-aho-corasick)
+         ("rust-memchr" ,rust-memchr)
+         ("rust-regex-syntax" ,rust-regex-syntax)
+         ("rust-thread-local" ,rust-thread-local)
+         ("rust-utf8-ranges" ,rust-utf8-ranges))
+        #:cargo-development-inputs
+        (("rust-doc-comment" ,rust-doc-comment)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-quickcheck" ,rust-quickcheck)
+         ("rust-rand" ,rust-rand))))
+    (home-page "https://github.com/rust-lang/regex")
+    (synopsis
+      "An implementation of regular expressions for Rust. This implementation uses
+      finite automata and guarantees linear time matching on all inputs.")
+    (description
+      "An implementation of regular expressions for Rust.  This implementation uses
+      finite automata and guarantees linear time matching on all inputs.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-regex-0.2
+  (package
+    (inherit rust-regex)
+    (name "rust-regex")
+    (version "0.2.11")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "regex" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1163ir1k5zjspirfjl4wqbviwrxlhmfwy95xxb69y4irkv4snack"))))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-aho-corasick" ,rust-aho-corasick-0.6)
+         ("rust-memchr" ,rust-memchr)
+         ("rust-regex-syntax" ,rust-regex-syntax)
+         ("rust-thread-local" ,rust-thread-local)
+         ("rust-utf8-ranges" ,rust-utf8-ranges))
+        #:cargo-development-inputs
+        (("rust-lazy-static" ,rust-lazy-static)
+         ("rust-quickcheck" ,rust-quickcheck-0.6)
+         ("rust-rand" ,rust-rand-0.4))))))
+
+(define-public rust-regex-syntax
+  (package
+    (name "rust-regex-syntax")
+    (version "0.6.10")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "regex-syntax" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0p47lf38yj2g2fnmvnraccqlxwk35zr76hlnqi8yva932nzqam6d"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-ucd-util" ,rust-ucd-util))))
+    (home-page "https://github.com/rust-lang/regex")
+    (synopsis "A regular expression parser.")
+    (description
+      "This package provides a regular expression parser.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-remove-dir-all
+  (package
+    (name "rust-remove-dir-all")
+    (version "0.5.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "remove_dir_all" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0bkrlyg26mgizpiy1yb2hhpgscxcag8r5fnckqsvk25608vzm0sa"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-winapi" ,rust-winapi))
+        #:cargo-development-inputs
+        (("rust-doc-comment" ,rust-doc-comment))))
+    (home-page
+      "https://github.com/XAMPPRocky/remove_dir_all.git")
+    (synopsis
+      "A safe, reliable implementation of remove_dir_all for Windows")
+    (description
+      "This package provides a safe, reliable implementation of remove_dir_all for Windows")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-reqwest
+  (package
+    (name "rust-reqwest")
+    (version "0.9.20")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "reqwest" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0y4wvzl3pspd8drr2hf9kk107cjw455cb6p529sh90x58dhqjv8g"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-base64" ,rust-base64)
+         ("rust-bytes" ,rust-bytes)
+         ("rust-cookie" ,rust-cookie)
+         ("rust-cookie-store" ,rust-cookie-store)
+         ("rust-encoding-rs" ,rust-encoding-rs)
+         ("rust-flate2" ,rust-flate2)
+         ("rust-futures" ,rust-futures)
+         ("rust-http" ,rust-http)
+         ("rust-hyper" ,rust-hyper)
+         ("rust-log" ,rust-log)
+         ("rust-mime" ,rust-mime)
+         ("rust-mime-guess" ,rust-mime-guess)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-serde-urlencoded" ,rust-urlencoded)
+         ("rust-time" ,rust-time)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-threadpool" ,rust-tokio-threadpool)
+         ("rust-tokio-timer" ,rust-tokio-timer)
+         ("rust-url" ,rust-url)
+         ("rust-uuid" ,rust-uuid)
+         ("rust-winreg" ,rust-winreg)
+         ("rust-hyper-old-types" ,rust-hyper-old-types)
+         ("rust-hyper-rustls" ,rust-hyper-rustls)
+         ("rust-hyper-tls" ,rust-hyper-tls)
+         ("rust-native-tls" ,rust-native-tls)
+         ("rust-rustls" ,rust-rustls)
+         ("rust-socks" ,rust-socks)
+         ("rust-tokio-rustls" ,rust-tokio-rustls)
+         ("rust-trust-dns-resolver" ,rust-trust-dns-resolver)
+         ("rust-webpki-roots" ,rust-webpki-roots))
+        #:cargo-development-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-doc-comment" ,rust-doc-comment)
+         ("rust-env-logger" ,rust-env-logger)
+         ("rust-libflate" ,rust-libflate)
+         ("rust-serde" ,rust-serde)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-tcp" ,rust-tokio-tcp))))
+    (home-page
+      "https://github.com/seanmonstar/reqwest")
+    (synopsis
+      "An ergonomic, batteries-included HTTP Client for Rust.")
+    (description
+      "An ergonomic, batteries-included HTTP Client for Rust.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-resolv-conf
+  (package
+    (name "rust-resolv-conf")
+    (version "0.6.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "resolv-conf" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1jvdsmksdf6yiipm3aqahyv8n1cjd7wqc8sa0p0gzsax3fmb8qxj"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-quick-error" ,rust-quick-error)
+         ("rust-hostname" ,rust-hostname))))
+    (home-page
+      "https://github.com/tailhook/resolv-conf")
+    (synopsis
+      "A /etc/resolv.conf parser crate for rust.")
+    (description
+      "A /etc/resolv.conf parser crate for rust.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-ring
+  (package
+    (name "rust-ring")
+    (version "0.16.7")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ring" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0mzpk6zmvlvzy021fh8b3xs2zl6c8mqdqfwqn7zlvc07g8qyhskr"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-cc" ,rust-cc)
+         ("rust-libc" ,rust-libc)
+         ("rust-spin" ,rust-spin)
+         ("rust-untrusted" ,rust-untrusted)
+         ("rust-web-sys" ,rust-web-sys)
+         ("rust-winapi" ,rust-winapi)
+         ("rust-lazy-static" ,rust-lazy-static))
+        #:cargo-development-inputs
+        (("rust-libc" ,rust-libc)
+         ("rust-wasm-bindgen-test" ,rust-wasm-bindgen-test))))
+    (home-page "https://github.com/briansmith/ring")
+    (synopsis
+      "Safe, fast, small crypto using Rust")
+    (description
+      "Safe, fast, small crypto using Rust")
+    (license (license:non-copyleft "file://LICENSE"))))
+
+(define-public rust-ron
+  (package
+    (name "rust-ron")
+    (version "0.5.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ron" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1mb2bavvp8jg5wx0kx9n45anrsbjwhjzddim987bjaa11hg45kif"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-base64" ,rust-base64)
+         ("rust-bitflags" ,rust-bitflags)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-serde-bytes" ,rust-serde-bytes)
+         ("rust-serde-json" ,rust-serde-json))))
+    (home-page "https://github.com/ron-rs/ron")
+    (synopsis "Rusty Object Notation")
+    (description "Rusty Object Notation")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rustc-demangle
+  (package
+    (name "rust-rustc-demangle")
+    (version "0.1.15")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rustc-demangle" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1brqf2bknkxsdzn3kd3wfifvzfc33bmvdy9r1k6fp4a8dz7xrx57"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-compiler-builtins"
+          ,rust-compiler-builtins)
+         ("rust-rustc-std-workspace-core"
+          ,rust-rustc-std-workspace-core))))
+    (home-page
+      "https://github.com/alexcrichton/rustc-demangle")
+    (synopsis "Rust compiler symbol demangling.")
+    (description
+      "Rust compiler symbol demangling.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rustc-serialize
+  (package
+    (name "rust-rustc-serialize")
+    (version "0.3.24")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rustc-serialize" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1nkg3vasg7nk80ffkazizgiyv3hb1l9g3d8h17cajbkx538jiwfw"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-development-inputs
+        (("rust-rand" ,rust-rand-0.3))))
+    (home-page
+      "https://github.com/rust-lang/rustc-serialize")
+    (synopsis
+      "Generic serialization/deserialization support corresponding to the `derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes support for hex, base64, and json encoding and decoding.")
+    (description
+      "Generic serialization/deserialization support corresponding to the `derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes support for hex, base64, and json encoding and decoding.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rustc-test
+  (package
+    (name "rust-rustc-test")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rustc-test" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0a27mlcg0ck0hgsdvwk792x9z1k1qq1wj091f1l5yggbdbcsnx5w"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-getopts" ,rust-getopts)
+         ("rust-libc" ,rust-libc)
+         ("rust-rustc-serialize" ,rust-rustc-serialize)
+         ("rust-term" ,rust-term)
+         ("rust-time" ,rust-time))
+        #:cargo-development-inputs
+        (("rust-rustc-version" ,rust-rustc-version))))
+    (home-page
+      "https://github.com/SimonSapin/rustc-test")
+    (synopsis
+      "A fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
+    (description
+      "This package provides a fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rustc-version
+  (package
+    (name "rust-rustc-version")
+    (version "0.2.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rustc_version" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "02h3x57lcr8l2pm0a645s9whdh33pn5cnrwvn5cb57vcrc53x3hk"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs (("rust-semver" ,rust-semver))))
+    (home-page
+      "https://github.com/Kimundi/rustc-version-rs")
+    (synopsis
+      "A library for querying the version of a installed rustc compiler")
+    (description
+      "This package provides a library for querying the version of a installed rustc compiler")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-rustls
+  (package
+    (name "rust-rustls")
+    (version "0.16.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "rustls" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "17n0fx3fpkg4fhpdplrdhkissnl003kj90vzbqag11vkpyqihnmj"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-base64" ,rust-base64)
+         ("rust-log" ,rust-log)
+         ("rust-ring" ,rust-ring)
+         ("rust-sct" ,rust-sct)
+         ("rust-webpki" ,rust-webpki))
+        #:cargo-development-inputs
+        (("rust-criterion" ,rust-criterion)
+         ("rust-env-logger" ,rust-env-logger)
+         ("rust-log" ,rust-log)
+         ("rust-tempfile" ,rust-tempfile)
+         ("rust-webpki-roots" ,rust-webpki-roots))))
+    (home-page "https://github.com/ctz/rustls")
+    (synopsis
+      "Rustls is a modern TLS library written in Rust.")
+    (description
+      "Rustls is a modern TLS library written in Rust.")
+    (license (list license:asl2.0
+                   license:isc
+                   license:expat))))
+
+(define-public rust-ryu
+  (package
+    (name "rust-ryu")
+    (version "1.0.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ryu" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "15r9z2wzgbj04pks4jz7y6wif5xqhf1wqkl2nd7qrvn08ys68969"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-no-panic" ,rust-no-panic))
+        #:cargo-development-inputs
+        (("rust-num-cpus" ,rust-num-cpus)
+         ("rust-rand" ,rust-rand))))
+    (home-page "https://github.com/dtolnay/ryu")
+    (synopsis
+      "Fast floating point to string conversion")
+    (description
+      "Fast floating point to string conversion")
+    (license (list license:asl2.0
+                   license:boost1.0))))
+
+(define-public rust-same-file
+  (package
+    (name "rust-same-file")
+    (version "1.0.5")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "same-file" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "08a4zy10pjindf2rah320s6shgswk13mqw7s61m8i1y1xpf8spjq"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-winapi-util" ,rust-winapi-util))))
+    (home-page
+      "https://github.com/BurntSushi/same-file")
+    (synopsis
+      "A simple crate for determining whether two file paths point to the same file.")
+    (description
+      "This package provides a simple crate for determining whether two file paths point to the same file.")
+    (license (list license:unlicense
+                   license:expat))))
+
+(define-public rust-schannel
+  (package
+    (name "rust-schannel")
+    (version "0.1.15")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "schannel" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0f9k4pm8yc3z0n1n8hazvnrvg52f0sfxjc91bhf3r76rb3rapxpj"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-lazy-static" ,rust-lazy-static)
+         ("rust-winapi" ,rust-winapi))))
+    (home-page "https://github.com/steffengy/schannel-rs")
+    (synopsis
+      "Rust bindings to the Windows SChannel APIs providing TLS client and server functionality.")
+    (description
+      "Rust bindings to the Windows SChannel APIs providing TLS client and server functionality.")
+    (license license:expat)))
+
+(define-public rust-scopeguard-0.3
+  (package
+    (inherit rust-scopeguard)
+    (name "rust-scopeguard")
+    (version "0.3.3")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "scopeguard" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "09sy9wbqp409pkwmqni40qmwa99ldqpl48pp95m1xw8sc19qy9cl"))))))
+
+(define-public rust-scroll
+  (package
+    (name "rust-scroll")
+    (version "0.9.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "scroll" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "10q3w86bn22xrjlfg1c90dfi9c26qjkzn26nad0i9z8pxwad311g"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-scroll-derive" ,rust-scroll-derive)
+         ("rust-rustc-version" ,rust-rustc-version))
+        #:cargo-development-inputs
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-rayon" ,rust-rayon))))
+    (home-page "https://github.com/m4b/scroll")
+    (synopsis
+      "A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers")
+    (description
+      "This package provides a suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers")
+    (license license:expat)))
+
+(define-public rust-scroll-derive
+  (package
+    (name "rust-scroll-derive")
+    (version "0.9.5")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "scroll_derive" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1jqg5mm8nvii6avl1z1rc89agzh2kwkppgpsnwfakxg78mnaj6lg"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))
+        #:cargo-development-inputs
+        (("rust-scroll" ,rust-scroll))))
+    (home-page
+      "https://github.com/m4b/scroll_derive")
+    (synopsis
+      "A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate")
+    (description
+      "This package provides a macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate")
+    (license license:expat)))
+
+(define-public rust-sct
+  (package
+    (name "rust-sct")
+    (version "0.6.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "sct" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0g4dz7las43kcpi9vqv9c6l1afjkdv3g3w3s7d2w7a7w77wjl173"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-ring" ,rust-ring)
+         ("rust-untrusted" ,rust-untrusted))))
+    (home-page "https://github.com/ctz/sct.rs")
+    (synopsis
+      "Certificate transparency SCT verification library")
+    (description
+      "Certificate transparency SCT verification library")
+    (license (list license:asl2.0
+                   license:isc
+                   license:expat))))
+
+(define-public rust-seahash ; guix upstreamable
+  (package
+    (name "rust-seahash")
+    (version "3.0.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "seahash" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1pr8ijnxnp68ki4m4740yc5mr01zijf86yx07wbsqzwiyhghdmhq"))))
+    (build-system cargo-build-system)
+    (home-page "https://gitlab.redox-os.org/redox-os/seahash")
+    (synopsis "Hash function with proven statistical guarantees")
+    (description "This package provides a blazingly fast, portable hash
+function with proven statistical guarantees.")
+    (license license:expat)))
+
+(define-public rust-security-framework
+  (package
+    (name "rust-security-framework")
+    (version "0.3.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "security-framework" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1hmdsdj061wk76g3fajbfjnw74p0q45hy8hfngp7diwy987kvrpf"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-core-foundation" ,rust-core-foundation)
+         ("rust-core-foundation-sys"
+          ,rust-core-foundation-sys)
+         ("rust-libc" ,rust-libc)
+         ("rust-security-framework-sys"
+          ,rust-security-framework-sys))
+        #:cargo-development-inputs
+        (("rust-hex" ,rust-hex)
+         ("rust-tempdir" ,rust-tempdir))))
+    (home-page
+      "https://lib.rs/crates/security_framework")
+    (synopsis
+      "Security.framework bindings for macOS and iOS")
+    (description
+      "Security.framework bindings for macOS and iOS")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-security-framework-sys
+  (package
+    (name "rust-security-framework-sys")
+    (version "0.3.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "security-framework-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0mlsakq9kmqyc0fg2hcbgm6rjk55mb0rhjw2wid3hqdzkjcghdln"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-core-foundation-sys"
+          ,rust-core-foundation-sys))))
+    (home-page
+      "https://lib.rs/crates/security-framework-sys")
+    (synopsis
+      "Apple `Security.framework` low-level FFI bindings")
+    (description
+      "Apple `Security.framework` low-level FFI bindings")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-select-rustc
+  (package
+    (name "rust-select-rustc")
+    (version "0.1.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "select-rustc" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0daqd56smi93g59nz43n4mh3d8whr6j5pa8dmwlf8bd76mdy3cpx"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))))
+    (home-page
+      "https://github.com/dtolnay/select-rustc")
+    (synopsis
+      "Conditional compilation according to rustc compiler version")
+    (description
+      "Conditional compilation according to rustc compiler version")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-semver
+  (package
+    (name "rust-semver")
+    (version "0.9.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "semver" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "00q4lkcj0rrgbhviv9sd4p6qmdsipkwkbra7rh11jrhq5kpvjzhx"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-semver-parser" ,rust-semver-parser-0.7)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-crates-index" ,rust-crates-index)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-tempdir" ,rust-tempdir))))
+    (home-page "https://docs.rs/crate/semver/")
+    (synopsis
+      "Semantic version parsing and comparison.")
+    (description
+      "Semantic version parsing and comparison.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-semver-parser-0.7
+  (package
+    (inherit rust-semver-parser)
+    (name "rust-semver-parser")
+    (version "0.7.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "semver-parser" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "18vhypw6zgccnrlm5ps1pwa0khz7ry927iznpr88b87cagr1v2iq"))))))
+
+(define-public rust-serde
+  (package
+    (name "rust-serde")
+    (version "1.0.97")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0wlvfs82flb3di86m3nzf1m4vkc78vqcwrk865s0ldhrvgz3ssyl"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde-derive" ,rust-serde-derive))
+        #:cargo-development-inputs
+        (("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://serde.rs")
+    (synopsis
+      "A generic serialization/deserialization framework")
+    (description
+      "This package provides a generic serialization/deserialization framework")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-big-array
+  (package
+    (name "rust-serde-big-array")
+    (version "0.1.5")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde-big-array" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0gkyqxk760mp1lfcg6lhjk95ajc89nr0qdd0vl4ic0g8pyxcy9mr"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))
+        #:cargo-development-inputs
+        (("rust-serde-json" ,rust-serde-json))))
+    (home-page
+      "https://github.com/est31/serde-big-array")
+    (synopsis "Big array helper for serde.")
+    (description "Big array helper for serde.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-bytes
+  (package
+    (name "rust-serde-bytes")
+    (version "0.11.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_bytes" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0sc5n336i7q4fiij4l8f892zcirgybrbxzl8bp51qxzqdvdlgzxa"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-test" ,rust-serde-test))))
+    (home-page "https://github.com/serde-rs/bytes")
+    (synopsis
+      "Optimized handling of `&[u8]` and `Vec<u8>` for Serde")
+    (description
+      "Optimized handling of `&[u8]` and `Vec<u8>` for Serde")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-cbor
+  (package
+    (name "rust-serde-cbor")
+    (version "0.10.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_cbor" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0jcb4j637vdlqk2z38jixaqmp6f92h36r17kclv5brjay32911ii"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-half" ,rust-half)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://github.com/pyfisch/cbor")
+    (synopsis "CBOR support for serde.")
+    (description "CBOR support for serde.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-derive
+  (package
+    (name "rust-serde-derive")
+    (version "1.0.97")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_derive" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0zq2qm2gabmpa57wxfxb09jl41nxccsk454715xjabzymlh0han2"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))
+        #:cargo-development-inputs
+        (("rust-serde" ,rust-serde))))
+    (home-page "https://serde.rs")
+    (synopsis
+      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
+    (description
+      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-json
+  (package
+    (name "rust-serde-json")
+    (version "1.0.40")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_json" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "010pa89zx07aqx1cwgw2a603wcp3q5n2iy0k71ppqbr8kwi4j705"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-indexmap" ,rust-indexmap)
+        ("rust-itoa" ,rust-itoa)
+        ("rust-ryu" ,rust-ryu)
+        ("rust-serde" ,rust-serde))
+       #:cargo-development-inputs
+       (("rust-automod" ,rust-automod)
+        ("rust-select-rustc" ,rust-select-rustc)
+        ("rust-serde-bytes" ,rust-serde-bytes)
+        ("rust-serde-derive" ,rust-serde-derive)
+        ("rust-serde-stacker" ,rust-serde-stacker)
+        ("rust-trybuild" ,rust-trybuild))))
+    (home-page "https://github.com/serde-rs/json")
+    (synopsis "A JSON serialization file format")
+    (description
+      "This package provides a JSON serialization file format")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-json-1.0.39
+  (package
+    (inherit rust-serde-json)
+    (name "rust-serde-json")
+    (version "1.0.39")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_json" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "03fl9l680gij0hrsr2csfm8nm858igvfy05czbdkzm54siqsl8ss"))))))
+
+(define-public rust-serde-stacker
+  (package
+    (name "rust-serde-stacker")
+    (version "0.1.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_stacker" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1jn54i5m1mlc6nm47f96k85fgjs9mhpbbqa4dvd5xjbivkdw55ic"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde" ,rust-serde)
+         ("rust-stacker" ,rust-stacker))
+        #:cargo-development-inputs
+        (("rust-serde-json" ,rust-serde-json))))
+    (home-page
+      "https://github.com/dtolnay/serde-stacker")
+    (synopsis
+      "Serde adapter that avoids stack overflow by dynamically growing the stack")
+    (description
+      "Serde adapter that avoids stack overflow by dynamically growing the stack")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-test
+  (package
+    (name "rust-serde-test")
+    (version "1.0.97")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_test" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0i17jdgy18rcp19v6h4shim27l99q3vc7pzr2xaa2g0rjq9p6lr2"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://serde.rs")
+    (synopsis
+      "Token De/Serializer for testing De/Serialize implementations")
+    (description
+      "Token De/Serializer for testing De/Serialize implementations")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-serde-yaml
+  (package
+    (name "rust-serde-yaml")
+    (version "0.8.9")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "serde_yaml" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "10mmjpnshgrwij01a13679nxy1hnh5yfr0343kh0y9p5j2d8mc1q"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-dtoa" ,rust-dtoa)
+         ("rust-linked-hash-map" ,rust-linked-hash-map)
+         ("rust-serde" ,rust-serde)
+         ("rust-yaml-rust" ,rust-yaml-rust))
+        #:cargo-development-inputs
+        (("rust-serde-derive" ,rust-serde-derive)
+         ("rust-unindent" ,rust-unindent)
+         ("rust-version-sync" ,rust-version-sync))))
+    (home-page
+      "https://github.com/dtolnay/serde-yaml")
+    (synopsis "YAML support for Serde")
+    (description "YAML support for Serde")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-sha-1
+  (package
+    (name "rust-sha-1")
+    (version "0.8.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "sha-1" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0s6fdy5wp3x4h2z4fcl2d9vjvrpzr87v4h49r51xcq8nm4qj35i3"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-block-buffer" ,rust-block-buffer)
+         ("rust-digest" ,rust-digest)
+         ("rust-fake-simd" ,rust-fake-simd)
+         ("rust-opaque-debug" ,rust-opaque-debug)
+         ("rust-sha1-asm" ,rust-sha1-asm))
+        #:cargo-development-inputs
+        (("rust-digest" ,rust-digest)
+         ("rust-hex-literal" ,rust-hex-literal))))
+    (home-page
+      "https://github.com/RustCrypto/hashes")
+    (synopsis "SHA-1 hash function")
+    (description "SHA-1 hash function")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-sha1
   (package
-    (name "rust-redox-syscall")
-    (version "0.1.56")
+    (name "rust-sha1")
+    (version "0.6.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "redox_syscall" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "sha1" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "110y7dyfm2vci4x5vk7gr0q551dvp31npl99fnsx2fb17wzwcf94"))))
+          (base32
+            "03gs2q4m67rn2p8xcdfxhip6mpgahdwm12bnb3vh90ahv9grhy95"))))
     (build-system cargo-build-system)
-    (home-page "https://gitlab.redox-os.org/redox-os/syscall")
-    (synopsis "Rust library to access raw Redox system calls")
-    (description "This package provides a Rust library to access raw Redox
-system calls.")
-    (license license:expat)))
+    (arguments
+      `(#:cargo-inputs
+        (("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-openssl" ,rust-openssl)
+         ("rust-rand" ,rust-rand)
+         ("rust-serde-json" ,rust-serde-json))))
+    (home-page
+      "https://github.com/mitsuhiko/rust-sha1")
+    (synopsis
+      "Minimal implementation of SHA1 for Rust.")
+    (description
+      "Minimal implementation of SHA1 for Rust.")
+    (license license:bsd-3)))
 
-(define-public rust-redox-users
+(define-public rust-sleef-sys
   (package
-    (name "rust-redox-users")
-    (version "0.3.0")
+    (name "rust-sleef-sys")
+    (version "0.1.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "redox_users" version))
+        (uri (crate-uri "sleef-sys" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0a1q5jv76vj1mwmqf2mmhknmkpw5wndx91gjfgg7vs8p79621r9z"))))
+            "1881q2yc17j2m1yvh01447c93ws1mspnrj3k2nbvwbvcm8z81kkv"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-argon2rs" ,rust-argon2rs)
-         ("rust-failure" ,rust-failure)
-         ("rust-rand-os" ,rust-rand-os)
-         ("rust-redox-syscall" ,rust-redox-syscall))))
-    (home-page
-      "https://gitlab.redox-os.org/redox-os/users")
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-libc" ,rust-libc))
+        #:cargo-development-inputs
+        (("rust-bindgen" ,rust-bindgen)
+         ("rust-cmake" ,rust-cmake)
+         ("rust-env-logger" ,rust-env-logger))))
+    (home-page "https://github.com/gnzlbg/sleef-sys")
     (synopsis
-      "A Rust library to access Redox users and groups functionality")
+      "Rust FFI bindings to the SLEEF Vectorized Math Library")
     (description
-      "This package provides a Rust library to access Redox users and groups functionality")
-    (license #f)))
+      "Rust FFI bindings to the SLEEF Vectorized Math Library")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-ref-cast
+(define-public rust-slog
   (package
-    (name "rust-ref-cast")
-    (version "0.2.6")
+    (name "rust-slog")
+    (version "2.5.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "ref-cast" version))
+        (uri (crate-uri "slog" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0jgj1zxaikqm030flpifbp517fy4z21lly6ysbwyciii39bkzcf1"))))
+            "16bv6zrdn1sm315vbnia02g31xvsmbjyz5gv3z0vrgxdli0cdj8w"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-ref-cast-impl" ,rust-ref-cast-impl))))
-    (home-page "https://github.com/dtolnay/ref-cast")
+        (("rust-erased-serde" ,rust-erased-serde))))
+    (home-page "https://github.com/slog-rs/slog")
     (synopsis
-      "Safely cast &T to &U where the struct U contains a single field of type T.")
+      "Structured, extensible, composable logging for Rust")
     (description
-      "Safely cast &T to &U where the struct U contains a single field of type T.")
+      "Structured, extensible, composable logging for Rust")
     (license (list license:asl2.0
+                   license:mpl2.0
                    license:expat))))
 
-(define-public rust-ref-cast-impl
+(define-public rust-smallvec
   (package
-    (name "rust-ref-cast-impl")
-    (version "0.2.6")
+    (name "rust-smallvec")
+    (version "0.6.10")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "ref-cast-impl" version))
+        (uri (crate-uri "smallvec" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0hw0frpzna5rf5szix56zyzd0vackcb3svj94ndj629xi75dkb32"))))
+            "1dyl43rgzny79jjpgzi07y0ly2ggx1xwsn64csxj0j91bsf6lq5b"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))))
-    (home-page "https://github.com/dtolnay/ref-cast")
+        (("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-bincode" ,rust-bincode))))
+    (home-page
+      "https://github.com/servo/rust-smallvec")
     (synopsis
-      "Derive implementation for ref_cast::RefCast.")
+      "'Small vector' optimization for Rust: store up to a small number of items on the stack")
     (description
-      "Derive implementation for ref_cast::RefCast.")
+      "'Small vector' optimization for Rust: store up to a small number of items on the stack")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-regex
+(define-public rust-socket2
   (package
-    (name "rust-regex")
-    (version "1.2.0")
+    (name "rust-socket2")
+    (version "0.3.11")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "regex" version))
+        (uri (crate-uri "socket2" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1k6jpx0bqlg6vb8rsdnlmcw2szczbl51j047w3blpa4qzn6xl8vb"))))
+            "11bdcz04i106g4q7swkll0qxrb4287srqd2k3aq2q6i22zjlvdz8"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-aho-corasick" ,rust-aho-corasick)
-         ("rust-memchr" ,rust-memchr)
-         ("rust-regex-syntax" ,rust-regex-syntax)
-         ("rust-thread-local" ,rust-thread-local)
-         ("rust-utf8-ranges" ,rust-utf8-ranges))
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-libc" ,rust-libc)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-winapi" ,rust-winapi))
         #:cargo-development-inputs
-        (("rust-doc-comment" ,rust-doc-comment)
-         ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-quickcheck" ,rust-quickcheck)
-         ("rust-rand" ,rust-rand))))
-    (home-page "https://github.com/rust-lang/regex")
+        (("rust-tempdir" ,rust-tempdir))))
+    (home-page
+      "https://github.com/alexcrichton/socket2-rs")
     (synopsis
-      "An implementation of regular expressions for Rust. This implementation uses
-      finite automata and guarantees linear time matching on all inputs.")
+      "Utilities for handling networking sockets with a maximal amount of configuration possible intended.")
     (description
-      "An implementation of regular expressions for Rust.  This implementation uses
-      finite automata and guarantees linear time matching on all inputs.")
+      "Utilities for handling networking sockets with a maximal amount of configuration possible intended.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-regex-syntax
+(define-public rust-socks
   (package
-    (name "rust-regex-syntax")
-    (version "0.6.10")
+    (name "rust-socks")
+    (version "0.3.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "regex-syntax" version))
+        (uri (crate-uri "socks" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0p47lf38yj2g2fnmvnraccqlxwk35zr76hlnqi8yva932nzqam6d"))))
+            "1hnbw4c4j7dn9n3bd1v7ddkdzlxlzkfw3z29da1nxlj6jgx4r9p6"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-ucd-util" ,rust-ucd-util))))
-    (home-page "https://github.com/rust-lang/regex")
-    (synopsis "A regular expression parser.")
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-libc" ,rust-libc)
+         ("rust-winapi" ,rust-winapi)
+         ("rust-ws2-32-sys" ,rust-ws2-32-sys))))
+    (home-page "https://github.com/sfackler/rust-socks")
+    (synopsis
+      "SOCKS proxy support for Rust.")
     (description
-      "This package provides a regular expression parser.")
+      "SOCKS proxy support for Rust.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-remove-dir-all
+(define-public rust-sourcefile
   (package
-    (name "rust-remove-dir-all")
-    (version "0.5.2")
+    (name "rust-sourcefile")
+    (version "0.1.4")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "remove_dir_all" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "sourcefile" version))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0bkrlyg26mgizpiy1yb2hhpgscxcag8r5fnckqsvk25608vzm0sa"))))
+         (base32
+          "1lwa6973zs4bgj29my7agfjgk4nw9hp6j7dfnr13nid85fw7rxsb"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-winapi" ,rust-winapi))
-        #:cargo-development-inputs
-        (("rust-doc-comment" ,rust-doc-comment))))
-    (home-page
-      "https://github.com/XAMPPRocky/remove_dir_all.git")
+     `(#:cargo-development-inputs
+       (("rust-tempfile" ,rust-tempfile))))
+    (home-page "https://github.com/derekdreery/sourcefile-rs")
     (synopsis
-      "A safe, reliable implementation of remove_dir_all for Windows")
+      "A library for concatenating source from multiple files, whilst keeping track of where each new file and line starts.")
     (description
-      "This package provides a safe, reliable implementation of remove_dir_all for Windows")
+      "A library for concatenating source from multiple files, whilst keeping track of where each new file and line starts.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-ron
+(define-public rust-spmc
   (package
-    (name "rust-ron")
-    (version "0.5.1")
+    (name "rust-spmc")
+    (version "0.3.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "ron" version))
+        (uri (crate-uri "spmc" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1mb2bavvp8jg5wx0kx9n45anrsbjwhjzddim987bjaa11hg45kif"))))
+            "1rgcqgj6b3d0cshi7277akr2xk0cx11rkmviaahy7a3pla6l5a02"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-base64" ,rust-base64)
-         ("rust-bitflags" ,rust-bitflags)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-serde-bytes" ,rust-serde-bytes)
-         ("rust-serde-json" ,rust-serde-json))))
-    (home-page "https://github.com/ron-rs/ron")
-    (synopsis "Rusty Object Notation")
-    (description "Rusty Object Notation")
+      `(#:cargo-development-inputs
+        (("rust-loom" ,rust-loom))))
+    (home-page
+      "https://github.com/seanmonstar/spmc")
+    (synopsis
+      "Simple SPMC channel")
+    (description
+      "Simple SPMC channel")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rustc-demangle
+(define-public rust-stable-deref-trait
   (package
-    (name "rust-rustc-demangle")
-    (version "0.1.15")
+    (name "rust-stable-deref-trait")
+    (version "1.1.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rustc-demangle" version))
+        (uri (crate-uri "stable_deref_trait" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1brqf2bknkxsdzn3kd3wfifvzfc33bmvdy9r1k6fp4a8dz7xrx57"))))
+            "1j2lkgakksmz4vc5hfawcch2ipiskrhjs1sih0f3br7s7rys58fv"))))
     (build-system cargo-build-system)
-    (arguments
-      `(#:cargo-inputs
-        (("rust-compiler-builtins"
-          ,rust-compiler-builtins)
-         ("rust-rustc-std-workspace-core"
-          ,rust-rustc-std-workspace-core))))
     (home-page
-      "https://github.com/alexcrichton/rustc-demangle")
-    (synopsis "Rust compiler symbol demangling.")
+      "https://github.com/storyyeller/stable_deref_trait0")
+    (synopsis
+      "This crate defines an unsafe marker trait, StableDeref, for container types which deref to a fixed address which is valid even when the containing type is moved. For example, Box, Vec, Rc, Arc and String implement this trait. Additionally, it defines CloneStableDeref for types like Rc where clones deref to the same address.")
     (description
-      "Rust compiler symbol demangling.")
+      "This crate defines an unsafe marker trait, StableDeref, for container types which deref to a fixed address which is valid even when the containing type is moved. For example, Box, Vec, Rc, Arc and String implement this trait. Additionally, it defines CloneStableDeref for types like Rc where clones deref to the same address.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rustc-serialize
+(define-public rust-stacker
   (package
-    (name "rust-rustc-serialize")
-    (version "0.3.24")
+    (name "rust-stacker")
+    (version "0.1.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rustc-serialize" version))
+        (uri (crate-uri "stacker" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1nkg3vasg7nk80ffkazizgiyv3hb1l9g3d8h17cajbkx538jiwfw"))))
+            "0js0axz5nla1mkr2dm2vrv9rj964ng1lrv4l43sqlnfgawplhygv"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-development-inputs
-        (("rust-rand" ,rust-rand-0.3))))
+      `(#:cargo-inputs
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-libc" ,rust-libc)
+         ("rust-winapi" ,rust-winapi)
+         ("rust-cc" ,rust-cc))))
     (home-page
-      "https://github.com/rust-lang/rustc-serialize")
+      "https://github.com/alexcrichton/stacker")
     (synopsis
-      "Generic serialization/deserialization support corresponding to the `derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes support for hex, base64, and json encoding and decoding.")
+      "A stack growth library useful when implementing deeply recursive algorithms that
+      may accidentally blow the stack.")
     (description
-      "Generic serialization/deserialization support corresponding to the `derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes support for hex, base64, and json encoding and decoding.")
+      "This package provides a stack growth library useful when implementing deeply recursive algorithms that
+      may accidentally blow the stack.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rustc-test
+(define-public rust-stdweb
   (package
-    (name "rust-rustc-test")
-    (version "0.3.0")
+    (name "rust-stdweb")
+    (version "0.4.18")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rustc-test" version))
+        (uri (crate-uri "stdweb" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0a27mlcg0ck0hgsdvwk792x9z1k1qq1wj091f1l5yggbdbcsnx5w"))))
+            "1srsjarj36f57ibr63n70bgy250yb72a73g14b80wh7piki0r356"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-getopts" ,rust-getopts)
-         ("rust-libc" ,rust-libc)
-         ("rust-rustc-serialize" ,rust-rustc-serialize)
-         ("rust-term" ,rust-term)
-         ("rust-time" ,rust-time))
+        (("rust-discard" ,rust-discard)
+         ("rust-futures-channel-preview"
+          ,rust-futures-channel-preview)
+         ("rust-futures-core-preview"
+          ,rust-futures-core-preview)
+         ("rust-futures-executor-preview"
+          ,rust-futures-executor-preview)
+         ("rust-futures-util-preview"
+          ,rust-futures-util-preview)
+         ("rust-rustc-version" ,rust-rustc-version)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-stdweb-derive" ,rust-stdweb-derive)
+         ("rust-stdweb-internal-macros"
+          ,rust-stdweb-internal-macros)
+         ("rust-stdweb-internal-runtime"
+          ,rust-stdweb-internal-runtime)
+         ("rust-wasm-bindgen" ,rust-wasm-bindgen))
         #:cargo-development-inputs
-        (("rust-rustc-version" ,rust-rustc-version))))
-    (home-page
-      "https://github.com/SimonSapin/rustc-test")
+        (("rust-rustc-version" ,rust-rustc-version)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-stdweb-internal-test-macro"
+          ,rust-stdweb-internal-test-macro)
+         ("rust-wasm-bindgen-test"
+          ,rust-wasm-bindgen-test))))
+    (home-page "https://github.com/koute/stdweb")
     (synopsis
-      "A fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
+      "A standard library for the client-side Web")
     (description
-      "This package provides a fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
+      "This package provides a standard library for the client-side Web")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-rustc-version
+(define-public rust-stdweb-derive
   (package
-    (name "rust-rustc-version")
-    (version "0.2.3")
+    (name "rust-stdweb-derive")
+    (version "0.5.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "rustc_version" version))
+        (uri (crate-uri "stdweb-derive" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "02h3x57lcr8l2pm0a645s9whdh33pn5cnrwvn5cb57vcrc53x3hk"))))
+            "0c1rxx6rqcc4iic5hx320ki3vshpi8k58m5600iqzq4x2zcyn88f"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs (("rust-semver" ,rust-semver))))
-    (home-page
-      "https://github.com/Kimundi/rustc-version-rs")
-    (synopsis
-      "A library for querying the version of a installed rustc compiler")
+      `(#:cargo-inputs
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/koute/stdweb")
+    (synopsis "Derive macros for the `stdweb` crate")
     (description
-      "This package provides a library for querying the version of a installed rustc compiler")
+      "Derive macros for the `stdweb` crate")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-ryu
+(define-public rust-stdweb-internal-macros
   (package
-    (name "rust-ryu")
-    (version "1.0.0")
+    (name "rust-stdweb-internal-macros")
+    (version "0.2.7")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "ryu" version))
+        (uri (crate-uri "stdweb-internal-macros" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "15r9z2wzgbj04pks4jz7y6wif5xqhf1wqkl2nd7qrvn08ys68969"))))
+            "1yjrmkc6sb1035avic383pa3avk2s9k3n17yjcza8yb9nw47v3z6"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-no-panic" ,rust-no-panic))
-        #:cargo-development-inputs
-        (("rust-num-cpus" ,rust-num-cpus)
-         ("rust-rand" ,rust-rand))))
-    (home-page "https://github.com/dtolnay/ryu")
+        (("rust-base-x" ,rust-base-x)
+         ("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-sha1" ,rust-sha1)
+         ("rust-syn" ,rust-syn))))
+    (home-page "https://github.com/koute/stdweb")
     (synopsis
-      "Fast floating point to string conversion")
+      "Internal procedural macros for the `stdweb` crate")
     (description
-      "Fast floating point to string conversion")
+      "Internal procedural macros for the `stdweb` crate")
     (license (list license:asl2.0
-                   license:boost1.0))))
+                   license:expat))))
 
-(define-public rust-same-file
+(define-public rust-stdweb-internal-test-macro
   (package
-    (name "rust-same-file")
-    (version "1.0.5")
+    (name "rust-stdweb-internal-test-macro")
+    (version "0.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "same-file" version))
+        (uri (crate-uri "stdweb-internal-test-macro" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "08a4zy10pjindf2rah320s6shgswk13mqw7s61m8i1y1xpf8spjq"))))
+            "12rrm7p77xnm3xacgn3rgniiyyjb4gq7902wpbljsvbx045z69l2"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-winapi-util" ,rust-winapi-util))))
-    (home-page
-      "https://github.com/BurntSushi/same-file")
-    (synopsis
-      "A simple crate for determining whether two file paths point to the same file.")
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote))))
+    (home-page "https://github.com/koute/stdweb")
+    (synopsis "Internal crate of the `stdweb` crate")
     (description
-      "This package provides a simple crate for determining whether two file paths point to the same file.")
-    (license (list license:unlicense
+      "Internal crate of the `stdweb` crate")
+    (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-scopeguard-0.3
+(define-public rust-stream-cipher
   (package
-    (inherit rust-scopeguard)
-    (name "rust-scopeguard")
-    (version "0.3.3")
+    (name "rust-stream-cipher")
+    (version "0.3.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "scopeguard" version))
+        (uri (crate-uri "stream-cipher" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "09sy9wbqp409pkwmqni40qmwa99ldqpl48pp95m1xw8sc19qy9cl"))))))
+          (base32
+            "1g1nd8r6pph70rzk5yyvg7a9ji7pkap9ddiqpp4v9xa9ys0bqqc8"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-blobby" ,rust-blobby)
+         ("rust-generic-array" ,rust-generic-array))))
+    (home-page
+      "https://github.com/RustCrypto/traits")
+    (synopsis "Stream cipher traits")
+    (description "Stream cipher traits")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-scroll
+(define-public rust-streaming-stats
   (package
-    (name "rust-scroll")
-    (version "0.9.2")
+    (name "rust-streaming-stats")
+    (version "0.2.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "scroll" version))
+        (uri (crate-uri "streaming-stats" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "10q3w86bn22xrjlfg1c90dfi9c26qjkzn26nad0i9z8pxwad311g"))))
+            "0l7xz4g6709s80zqpvlhrg0qhgz64r94cwhmfsg8xhabgznbp2px"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-scroll-derive" ,rust-scroll-derive)
-         ("rust-rustc-version" ,rust-rustc-version))
-        #:cargo-development-inputs
-        (("rust-byteorder" ,rust-byteorder)
-         ("rust-rayon" ,rust-rayon))))
-    (home-page "https://github.com/m4b/scroll")
+        (("rust-num-traits" ,rust-num-traits))))
+    (home-page
+      "https://github.com/BurntSushi/rust-stats")
     (synopsis
-      "A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers")
+      "Experimental crate for computing basic statistics on streams.")
     (description
-      "This package provides a suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers")
-    (license license:expat)))
+      "Experimental crate for computing basic statistics on streams.")
+    (license (list license:unlicense
+                   license:expat))))
 
-(define-public rust-scroll-derive
+(define-public rust-string
   (package
-    (name "rust-scroll-derive")
-    (version "0.9.5")
+    (name "rust-string")
+    (version "0.2.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "scroll_derive" version))
+        (uri (crate-uri "string" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1jqg5mm8nvii6avl1z1rc89agzh2kwkppgpsnwfakxg78mnaj6lg"))))
+            "0vaxz85ja52fn66akgvggb29wqa5bpj3y38syykpr1pbrjzi8hfj"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))
-        #:cargo-development-inputs
-        (("rust-scroll" ,rust-scroll))))
+      `(#:cargo-inputs (("rust-bytes" ,rust-bytes))))
     (home-page
-      "https://github.com/m4b/scroll_derive")
+      "https://github.com/carllerche/string")
     (synopsis
-      "A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate")
+      "A UTF-8 encoded string with configurable byte storage.")
     (description
-      "This package provides a macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate")
+      "This package provides a UTF-8 encoded string with configurable byte storage.")
     (license license:expat)))
 
-(define-public rust-seahash ; guix upstreamable
+(define-public rust-strsim-0.8
   (package
-    (name "rust-seahash")
-    (version "3.0.6")
+    (inherit rust-strsim)
+    (name "rust-strsim")
+    (version "0.8.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "seahash" version))
+        (uri (crate-uri "strsim" version))
         (file-name (string-append name "-" version ".tar.gz"))
         (sha256
          (base32
-          "1pr8ijnxnp68ki4m4740yc5mr01zijf86yx07wbsqzwiyhghdmhq"))))
-    (build-system cargo-build-system)
-    (home-page "https://gitlab.redox-os.org/redox-os/seahash")
-    (synopsis "Hash function with proven statistical guarantees")
-    (description "This package provides a blazingly fast, portable hash
-function with proven statistical guarantees.")
-    (license license:expat)))
+          "0sjsm7hrvjdifz661pjxq5w4hf190hx53fra8dfvamacvff139cf"))))))
 
-(define-public rust-select-rustc
+(define-public rust-structopt
   (package
-    (name "rust-select-rustc")
-    (version "0.1.2")
+    (name "rust-structopt")
+    (version "0.2.18")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "select-rustc" version))
+        (uri (crate-uri "structopt" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0daqd56smi93g59nz43n4mh3d8whr6j5pa8dmwlf8bd76mdy3cpx"))))
+         (base32
+          "1mvfv1l8vp3y402fkl2wcl34hi7gmr4bqha13dfz2xf3kjzwvhhn"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))))
+        (("rust-clap" ,rust-clap)
+         ("rust-structopt-derive" ,rust-structopt-derive))))
     (home-page
-      "https://github.com/dtolnay/select-rustc")
+      "https://github.com/TeXitoi/structopt")
     (synopsis
-      "Conditional compilation according to rustc compiler version")
+      "Parse command line argument by defining a struct.")
     (description
-      "Conditional compilation according to rustc compiler version")
+      "Parse command line argument by defining a struct.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-semver
+(define-public rust-structopt-derive
   (package
-    (name "rust-semver")
-    (version "0.9.0")
+    (name "rust-structopt-derive")
+    (version "0.2.18")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "semver" version))
+        (uri (crate-uri "structopt-derive" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "00q4lkcj0rrgbhviv9sd4p6qmdsipkwkbra7rh11jrhq5kpvjzhx"))))
+            "01sis9z5kqmyhvzbnmlzpdxcry99a0b9blypksgnhdsbm1hh40ak"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-semver-parser" ,rust-semver-parser-0.7)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-crates-index" ,rust-crates-index)
-         ("rust-serde-derive" ,rust-serde-derive)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-tempdir" ,rust-tempdir))))
-    (home-page "https://docs.rs/crate/semver/")
+        (("rust-heck" ,rust-heck)
+         ("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn))))
+    (home-page
+      "https://github.com/TeXitoi/structopt")
     (synopsis
-      "Semantic version parsing and comparison.")
+      "Parse command line argument by defining a struct, derive crate.")
     (description
-      "Semantic version parsing and comparison.")
+      "Parse command line argument by defining a struct, derive crate.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-semver-parser-0.7
+(define-public rust-syn
   (package
-    (inherit rust-semver-parser)
-    (name "rust-semver-parser")
-    (version "0.7.0")
+    (name "rust-syn")
+    (version "0.15.42")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "semver-parser" version))
-        (file-name (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "syn" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "18vhypw6zgccnrlm5ps1pwa0khz7ry927iznpr88b87cagr1v2iq"))))))
+          (base32
+            "0png5pz7jjjj39xy8w7qr65y3s9qam0jpz6nbmal06m5dhq0kp7a"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-unicode-xid" ,rust-unicode-xid))
+        #:cargo-development-inputs
+        (("rust-insta" ,rust-insta)
+         ("rust-rayon" ,rust-rayon)
+         ("rust-ref-cast" ,rust-ref-cast)
+         ("rust-regex" ,rust-regex)
+         ("rust-termcolor" ,rust-termcolor)
+         ("rust-walkdir" ,rust-walkdir))))
+    (home-page "https://github.com/dtolnay/syn")
+    (synopsis "Parser for Rust source code")
+    (description "Parser for Rust source code")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-serde
+(define-public rust-synstructure
   (package
-    (name "rust-serde")
-    (version "1.0.97")
+    (name "rust-synstructure")
+    (version "0.11.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde" version))
+        (uri (crate-uri "synstructure" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0wlvfs82flb3di86m3nzf1m4vkc78vqcwrk865s0ldhrvgz3ssyl"))))
+            "1spqy31qcss57mciklc4nky4v778fvqs9qwdjgvnmf0hr5ichcca"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-serde-derive" ,rust-serde-derive))
+        (("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn)
+         ("rust-unicode-xid" ,rust-unicode-xid))
         #:cargo-development-inputs
-        (("rust-serde-derive" ,rust-serde-derive))))
-    (home-page "https://serde.rs")
+        (("rust-synstructure-test-traits"
+          ,rust-synstructure-test-traits))))
+    (home-page
+      "https://github.com/mystor/synstructure")
     (synopsis
-      "A generic serialization/deserialization framework")
+      "Helper methods and macros for custom derives")
     (description
-      "This package provides a generic serialization/deserialization framework")
-    (license (list license:asl2.0
-                   license:expat))))
+      "Helper methods and macros for custom derives")
+    (license license:expat)))
 
-(define-public rust-serde-big-array
+(define-public rust-tar
   (package
-    (name "rust-serde-big-array")
-    (version "0.1.5")
+    (name "rust-tar")
+    (version "0.4.26")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde-big-array" version))
+        (uri (crate-uri "tar" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0gkyqxk760mp1lfcg6lhjk95ajc89nr0qdd0vl4ic0g8pyxcy9mr"))))
+            "1lr6v3cpkfxd2lk5ll2jd8wr1xdskwj35smnh5sfb8xvzzxnn6dk"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))
+        (("rust-filetime" ,rust-filetime)
+         ("rust-libc" ,rust-libc)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-xattr" ,rust-xattr))
         #:cargo-development-inputs
-        (("rust-serde-json" ,rust-serde-json))))
+        (("rust-tempdir" ,rust-tempdir))))
     (home-page
-      "https://github.com/est31/serde-big-array")
-    (synopsis "Big array helper for serde.")
-    (description "Big array helper for serde.")
+      "https://github.com/alexcrichton/tar-rs")
+    (synopsis
+      "A Rust implementation of a TAR file reader and writer. This library does not
+      currently handle compression, but it is abstract over all I/O readers and
+      writers. Additionally, great lengths are taken to ensure that the entire
+      contents are never required to be entirely resident in memory all at once.")
+    (description
+      "This package provides a Rust implementation of a TAR file reader and writer.  This library does not
+        currently handle compression, but it is abstract over all I/O readers and
+        writers.  Additionally, great lengths are taken to ensure that the entire
+        contents are never required to be entirely resident in memory all at once.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-serde-bytes
+(define-public rust-target-lexicon
   (package
-    (name "rust-serde-bytes")
-    (version "0.11.1")
+    (name "rust-target-lexicon")
+    (version "0.4.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_bytes" version))
+        (uri (crate-uri "target-lexicon" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0sc5n336i7q4fiij4l8f892zcirgybrbxzl8bp51qxzqdvdlgzxa"))))
+            "1jrdch22pvm8r9fwx6d051l4yhac16lq6sn4q5fc6ic95fcb82hv"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-bincode" ,rust-bincode)
-         ("rust-serde-derive" ,rust-serde-derive)
-         ("rust-serde-test" ,rust-serde-test))))
-    (home-page "https://github.com/serde-rs/bytes")
+     `(#:cargo-inputs
+       (("rust-failure" ,rust-failure)
+        ("rust-failure-derive" ,rust-failure-derive)
+        ("rust-serde-json" ,rust-serde-json))))
+    (home-page "https://github.com/CraneStation/target-lexicon")
     (synopsis
-      "Optimized handling of `&[u8]` and `Vec<u8>` for Serde")
+      "This is a library for managing targets for compilers and related tools.")
     (description
-      "Optimized handling of `&[u8]` and `Vec<u8>` for Serde")
-    (license (list license:asl2.0
-                   license:expat))))
+      "This is a library for managing targets for compilers and related tools.")
+    (license license:asl2.0))) ; with LLVM exception
 
-(define-public rust-serde-cbor
+(define-public rust-tempdir
   (package
-    (name "rust-serde-cbor")
-    (version "0.10.1")
+    (name "rust-tempdir")
+    (version "0.3.7")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_cbor" version))
+        (uri (crate-uri "tempdir" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0jcb4j637vdlqk2z38jixaqmp6f92h36r17kclv5brjay32911ii"))))
+            "1n5n86zxpgd85y0mswrp5cfdisizq2rv3la906g6ipyc03xvbwhm"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-byteorder" ,rust-byteorder)
-         ("rust-half" ,rust-half)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-serde-derive" ,rust-serde-derive))))
-    (home-page "https://github.com/pyfisch/cbor")
-    (synopsis "CBOR support for serde.")
-    (description "CBOR support for serde.")
+        (("rust-rand" ,rust-rand-0.4)
+         ("rust-remove-dir-all" ,rust-remove-dir-all))))
+    (home-page
+      "https://github.com/rust-lang/tempdir")
+    (synopsis
+      "A library for managing a temporary directory and deleting all contents when it's dropped.")
+    (description
+      "This package provides a library for managing a temporary directory and deleting all contents when it's dropped.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-serde-derive
+(define-public rust-tempfile
   (package
-    (name "rust-serde-derive")
-    (version "1.0.97")
+    (name "rust-tempfile")
+    (version "3.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_derive" version))
+        (uri (crate-uri "tempfile" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0zq2qm2gabmpa57wxfxb09jl41nxccsk454715xjabzymlh0han2"))))
+            "1a9cfdqw70n7bcnkx05aih9xdba8lqazmqlkjpkmn2la6gcj8vks"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))
-        #:cargo-development-inputs
-        (("rust-serde" ,rust-serde))))
-    (home-page "https://serde.rs")
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-libc" ,rust-libc)
+         ("rust-rand" ,rust-rand)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-remove-dir-all" ,rust-remove-dir-all)
+         ("rust-winapi" ,rust-winapi))))
+    (home-page
+      "http://stebalien.com/projects/tempfile-rs")
     (synopsis
-      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
+      "A library for managing temporary files and directories.")
     (description
-      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
+      "This package provides a library for managing temporary files and directories.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-serde-json
+(define-public rust-term
   (package
-    (name "rust-serde-json")
-    (version "1.0.40")
+    (name "rust-term")
+    (version "0.5.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_json" version))
+        (uri (crate-uri "term" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "010pa89zx07aqx1cwgw2a603wcp3q5n2iy0k71ppqbr8kwi4j705"))))
+          (base32
+            "0hkgjrfisj6zjwz525639pmsvzhlc48a0h65nw87qrdp6jihdlgd"))))
     (build-system cargo-build-system)
     (arguments
-     `(#:cargo-inputs
-       (("rust-indexmap" ,rust-indexmap)
-        ("rust-itoa" ,rust-itoa)
-        ("rust-ryu" ,rust-ryu)
-        ("rust-serde" ,rust-serde))
-       #:cargo-development-inputs
-       (("rust-automod" ,rust-automod)
-        ("rust-select-rustc" ,rust-select-rustc)
-        ("rust-serde-bytes" ,rust-serde-bytes)
-        ("rust-serde-derive" ,rust-serde-derive)
-        ("rust-serde-stacker" ,rust-serde-stacker)
-        ("rust-trybuild" ,rust-trybuild))))
-    (home-page "https://github.com/serde-rs/json")
-    (synopsis "A JSON serialization file format")
+      `(#:cargo-inputs
+        (("rust-byteorder" ,rust-byteorder)
+         ("rust-dirs" ,rust-dirs)
+         ("rust-winapi" ,rust-winapi))))
+    (home-page "https://github.com/Stebalien/term")
+    (synopsis "A terminal formatting library")
     (description
-      "This package provides a JSON serialization file format")
+      "This package provides a terminal formatting library")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-serde-json-1.0.39
-  (package
-    (inherit rust-serde-json)
-    (name "rust-serde-json")
-    (version "1.0.39")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (crate-uri "serde_json" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
-        (sha256
-         (base32
-          "03fl9l680gij0hrsr2csfm8nm858igvfy05czbdkzm54siqsl8ss"))))))
-
-(define-public rust-serde-stacker
+(define-public rust-term-size
   (package
-    (name "rust-serde-stacker")
-    (version "0.1.0")
+    (name "rust-term-size")
+    (version "1.0.0-beta1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_stacker" version))
+        (uri (crate-uri "term_size" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1jn54i5m1mlc6nm47f96k85fgjs9mhpbbqa4dvd5xjbivkdw55ic"))))
+            "13w9cqjhzh3mmx6zami8lxyf42xx53yy866zxhxqcm71k637v8d8"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-serde" ,rust-serde)
-         ("rust-stacker" ,rust-stacker))
-        #:cargo-development-inputs
-        (("rust-serde-json" ,rust-serde-json))))
+        (("rust-clippy" ,rust-clippy)
+         ;("rust-kernel32-sys" ,rust-kernel32-sys) ; windows
+         ("rust-libc" ,rust-libc)
+         ("rust-winapi" ,rust-winapi))))
     (home-page
-      "https://github.com/dtolnay/serde-stacker")
+      "https://github.com/kbknapp/term_size-rs.git")
     (synopsis
-      "Serde adapter that avoids stack overflow by dynamically growing the stack")
+      "functions for determining terminal sizes and dimensions")
     (description
-      "Serde adapter that avoids stack overflow by dynamically growing the stack")
+      "functions for determining terminal sizes and dimensions")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-serde-test
+(define-public rust-termcolor
   (package
-    (name "rust-serde-test")
-    (version "1.0.97")
+    (name "rust-termcolor")
+    (version "1.0.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_test" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "termcolor" version))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0i17jdgy18rcp19v6h4shim27l99q3vc7pzr2xaa2g0rjq9p6lr2"))))
+         (base32
+          "0vjfsn1a8zvqhnrbygrz1id6yckwv1dncw3w4zj65qdx0f00kmln"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive))))
-    (home-page "https://serde.rs")
-    (synopsis
-      "Token De/Serializer for testing De/Serialize implementations")
-    (description
-      "Token De/Serializer for testing De/Serialize implementations")
-    (license (list license:asl2.0
+     `(#:cargo-inputs
+       (("rust-wincolor" ,rust-wincolor))))
+    (home-page "https://github.com/BurntSushi/termcolor")
+    (synopsis "Library for writing colored text to a terminal")
+    (description "This package provides a simple cross platform library for
+writing colored text to a terminal.")
+    (license (list license:unlicense
                    license:expat))))
 
-(define-public rust-serde-yaml
+(define-public rust-termios
   (package
-    (name "rust-serde-yaml")
-    (version "0.8.9")
+    (name "rust-termios")
+    (version "0.3.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "serde_yaml" version))
+        (uri (crate-uri "termios" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "10mmjpnshgrwij01a13679nxy1hnh5yfr0343kh0y9p5j2d8mc1q"))))
+            "09any1p4jp4bphvb5ikagnvwjc3xn2djchy96nkpa782xb2j1dkj"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-dtoa" ,rust-dtoa)
-         ("rust-linked-hash-map" ,rust-linked-hash-map)
-         ("rust-serde" ,rust-serde)
-         ("rust-yaml-rust" ,rust-yaml-rust))
-        #:cargo-development-inputs
-        (("rust-serde-derive" ,rust-serde-derive)
-         ("rust-unindent" ,rust-unindent)
-         ("rust-version-sync" ,rust-version-sync))))
+      `(#:cargo-inputs (("rust-libc" ,rust-libc))))
     (home-page
-      "https://github.com/dtolnay/serde-yaml")
-    (synopsis "YAML support for Serde")
-    (description "YAML support for Serde")
-    (license (list license:asl2.0
-                   license:expat))))
+      "https://github.com/dcuddeback/termios-rs")
+    (synopsis
+      "Safe bindings for the termios library.")
+    (description
+      "Safe bindings for the termios library.")
+    (license license:expat)))
 
-(define-public rust-sha-1
-  (package
-    (name "rust-sha-1")
-    (version "0.8.1")
+(define-public rust-test-assembler
+  (package
+    (name "rust-test-assembler")
+    (version "0.1.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "sha-1" version))
+        (uri (crate-uri "test-assembler" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0s6fdy5wp3x4h2z4fcl2d9vjvrpzr87v4h49r51xcq8nm4qj35i3"))))
+            "1sdx9hk0dk3z9crm8834ysyxsi92chls8arpd0gs796kis6lik2w"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-block-buffer" ,rust-block-buffer)
-         ("rust-digest" ,rust-digest)
-         ("rust-fake-simd" ,rust-fake-simd)
-         ("rust-opaque-debug" ,rust-opaque-debug)
-         ("rust-sha1-asm" ,rust-sha1-asm))
-        #:cargo-development-inputs
-        (("rust-digest" ,rust-digest)
-         ("rust-hex-literal" ,rust-hex-literal))))
+        (("rust-byteorder" ,rust-byteorder))))
     (home-page
-      "https://github.com/RustCrypto/hashes")
-    (synopsis "SHA-1 hash function")
-    (description "SHA-1 hash function")
-    (license (list license:asl2.0
-                   license:expat))))
+      "https://github.com/luser/rust-test-assembler")
+    (synopsis
+      "A set of types for building complex binary streams.")
+    (description
+      "This package provides a set of types for building complex binary streams.")
+    (license license:expat)))
 
-(define-public rust-sha1
+(define-public rust-textwrap
   (package
-    (name "rust-sha1")
-    (version "0.6.0")
+    (name "rust-textwrap")
+    (version "0.11.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "sha1" version))
+        (uri (crate-uri "textwrap" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "03gs2q4m67rn2p8xcdfxhip6mpgahdwm12bnb3vh90ahv9grhy95"))))
+            "0q5hky03ik3y50s9sz25r438bc4nwhqc6dqwynv4wylc807n29nk"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-serde" ,rust-serde))
+        (("rust-hyphenation" ,rust-hyphenation)
+         ("rust-term-size" ,rust-term-size)
+         ("rust-unicode-width" ,rust-unicode-width))
         #:cargo-development-inputs
-        (("rust-openssl" ,rust-openssl)
+        (("rust-lipsum" ,rust-lipsum)
          ("rust-rand" ,rust-rand)
-         ("rust-serde-json" ,rust-serde-json))))
+         ("rust-rand-xorshift" ,rust-rand-xorshift)
+         ("rust-version-sync" ,rust-version-sync))))
     (home-page
-      "https://github.com/mitsuhiko/rust-sha1")
+      "https://github.com/mgeisler/textwrap")
     (synopsis
-      "Minimal implementation of SHA1 for Rust.")
+      "Textwrap is a small library for word wrapping, indenting, and
+      dedenting strings.
+
+      You can use it to format strings (such as help and error messages) for
+      display in commandline applications. It is designed to be efficient
+      and handle Unicode characters correctly.")
     (description
-      "Minimal implementation of SHA1 for Rust.")
-    (license license:bsd-3)))
+      "Textwrap is a small library for word wrapping, indenting, and
+      dedenting strings.
 
-(define-public rust-sleef-sys
+      You can use it to format strings (such as help and error messages) for
+      display in commandline applications.  It is designed to be efficient
+      and handle Unicode characters correctly.")
+    (license license:expat)))
+
+(define-public rust-thread-id
   (package
-    (name "rust-sleef-sys")
-    (version "0.1.2")
+    (name "rust-thread-id")
+    (version "3.3.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "sleef-sys" version))
+        (uri (crate-uri "thread-id" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1881q2yc17j2m1yvh01447c93ws1mspnrj3k2nbvwbvcm8z81kkv"))))
+            "1h90v19fjz3x9b25ywh68z5yf2zsmm6h5zb4rl302ckbsp4z9yy7"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-cfg-if" ,rust-cfg-if)
-         ("rust-libc" ,rust-libc))
-        #:cargo-development-inputs
-        (("rust-bindgen" ,rust-bindgen)
-         ("rust-cmake" ,rust-cmake)
-         ("rust-env-logger" ,rust-env-logger))))
-    (home-page "https://github.com/gnzlbg/sleef-sys")
+        (("rust-libc" ,rust-libc)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-winapi" ,rust-winapi))))
+    (home-page
+      "https://github.com/ruuda/thread-id")
     (synopsis
-      "Rust FFI bindings to the SLEEF Vectorized Math Library")
+      "Get a unique ID for the current thread in Rust.")
     (description
-      "Rust FFI bindings to the SLEEF Vectorized Math Library")
+      "Get a unique ID for the current thread in Rust.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-slog
+(define-public rust-thread-local
   (package
-    (name "rust-slog")
-    (version "2.5.2")
+    (name "rust-thread-local")
+    (version "0.3.6")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "slog" version))
+        (uri (crate-uri "thread_local" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "16bv6zrdn1sm315vbnia02g31xvsmbjyz5gv3z0vrgxdli0cdj8w"))))
+            "06rzik99p8c5js8238yhc8rk6np543ylb1dy9nrw5v80j0r3xdf6"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-erased-serde" ,rust-erased-serde))))
-    (home-page "https://github.com/slog-rs/slog")
-    (synopsis
-      "Structured, extensible, composable logging for Rust")
-    (description
-      "Structured, extensible, composable logging for Rust")
+        (("rust-lazy-static" ,rust-lazy-static))))
+    (home-page
+      "https://github.com/Amanieu/thread_local-rs")
+    (synopsis "Per-object thread-local storage")
+    (description "Per-object thread-local storage")
     (license (list license:asl2.0
-                   license:mpl2.0
                    license:expat))))
 
-(define-public rust-stacker
+(define-public rust-threadpool
   (package
-    (name "rust-stacker")
-    (version "0.1.5")
+    (name "rust-threadpool")
+    (version "1.7.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "stacker" version))
+        (uri (crate-uri "threadpool" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0js0axz5nla1mkr2dm2vrv9rj964ng1lrv4l43sqlnfgawplhygv"))))
+            "0rd89n1q7vy47w4c32cnynibffv9kj3jy3dwr0536n9lbw5ckw72"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-cfg-if" ,rust-cfg-if)
-         ("rust-libc" ,rust-libc)
-         ("rust-winapi" ,rust-winapi)
-         ("rust-cc" ,rust-cc))))
+        (("rust-num-cpus" ,rust-num-cpus))))
     (home-page
-      "https://github.com/alexcrichton/stacker")
+      "https://github.com/rust-threadpool/rust-threadpool")
     (synopsis
-      "A stack growth library useful when implementing deeply recursive algorithms that
-      may accidentally blow the stack.")
+      "A thread pool for running a number of jobs on a fixed set of worker threads.")
     (description
-      "This package provides a stack growth library useful when implementing deeply recursive algorithms that
-      may accidentally blow the stack.")
+      "This package provides a thread pool for running a number of jobs on a fixed set of worker threads.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-stdweb
+(define-public rust-time
   (package
-    (name "rust-stdweb")
-    (version "0.4.18")
+    (name "rust-time")
+    (version "0.1.42")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "stdweb" version))
+        (uri (crate-uri "time" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1srsjarj36f57ibr63n70bgy250yb72a73g14b80wh7piki0r356"))))
+            "0vsbvsz0ryxb35dy9j4anxvy8zlaplmjmi0a4z4l64bc135cz3fv"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-discard" ,rust-discard)
-         ("rust-futures-channel-preview"
-          ,rust-futures-channel-preview)
-         ("rust-futures-core-preview"
-          ,rust-futures-core-preview)
-         ("rust-futures-executor-preview"
-          ,rust-futures-executor-preview)
-         ("rust-futures-util-preview"
-          ,rust-futures-util-preview)
-         ("rust-rustc-version" ,rust-rustc-version)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-stdweb-derive" ,rust-stdweb-derive)
-         ("rust-stdweb-internal-macros"
-          ,rust-stdweb-internal-macros)
-         ("rust-stdweb-internal-runtime"
-          ,rust-stdweb-internal-runtime)
-         ("rust-wasm-bindgen" ,rust-wasm-bindgen))
+        (("rust-libc" ,rust-libc)
+         ("rust-redox-syscall" ,rust-redox-syscall)
+         ("rust-rustc-serialize" ,rust-rustc-serialize)
+         ("rust-winapi" ,rust-winapi))
         #:cargo-development-inputs
-        (("rust-rustc-version" ,rust-rustc-version)
-         ("rust-serde-derive" ,rust-serde-derive)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-stdweb-internal-test-macro"
-          ,rust-stdweb-internal-test-macro)
-         ("rust-wasm-bindgen-test"
-          ,rust-wasm-bindgen-test))))
-    (home-page "https://github.com/koute/stdweb")
+        (("rust-log" ,rust-log)
+         ("rust-winapi" ,rust-winapi))))
+    (home-page "https://github.com/rust-lang/time")
     (synopsis
-      "A standard library for the client-side Web")
+      "Utilities for working with time-related functions in Rust.")
     (description
-      "This package provides a standard library for the client-side Web")
+      "Utilities for working with time-related functions in Rust.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-stdweb-derive
+(define-public rust-tokio
   (package
-    (name "rust-stdweb-derive")
-    (version "0.5.1")
+    (name "rust-tokio")
+    (version "0.1.22")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "stdweb-derive" version))
+        (uri (crate-uri "tokio" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0c1rxx6rqcc4iic5hx320ki3vshpi8k58m5600iqzq4x2zcyn88f"))))
+            "1xhaadfmm6m37f79xv5020gc3np9wqza3bq95ymp522qpfsw02as"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-mio" ,rust-mio)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-tokio-codec" ,rust-tokio-codec)
+         ("rust-tokio-current-thread"
+          ,rust-tokio-current-thread)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-fs" ,rust-tokio-fs)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor)
+         ("rust-tokio-sync" ,rust-tokio-sync)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-tokio-threadpool" ,rust-tokio-threadpool)
+         ("rust-tokio-timer" ,rust-tokio-timer)
+         ("rust-tokio-udp" ,rust-tokio-udp)
+         ("rust-tokio-uds" ,rust-tokio-uds)
+         ("rust-tracing-core" ,rust-tracing-core))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-flate2" ,rust-flate2)
+         ("rust-futures-cpupool" ,rust-futures-cpupool)
+         ("rust-http" ,rust-http)
+         ("rust-httparse" ,rust-httparse)
+         ("rust-libc" ,rust-libc)
+         ("rust-num-cpus" ,rust-num-cpus)
          ("rust-serde" ,rust-serde)
          ("rust-serde-derive" ,rust-serde-derive)
-         ("rust-syn" ,rust-syn))))
-    (home-page "https://github.com/koute/stdweb")
-    (synopsis "Derive macros for the `stdweb` crate")
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-time" ,rust-time))))
+    (home-page "https://tokio.rs")
+    (synopsis
+      "An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.")
     (description
-      "Derive macros for the `stdweb` crate")
-    (license (list license:asl2.0
-                   license:expat))))
+      "An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.")
+    (license license:expat)))
 
-(define-public rust-stdweb-internal-macros
+(define-public rust-tokio-buf
   (package
-    (name "rust-stdweb-internal-macros")
-    (version "0.2.7")
+    (name "rust-tokio-buf")
+    (version "0.2.0-alpha.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "stdweb-internal-macros" version))
+        (uri (crate-uri "tokio-buf" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1yjrmkc6sb1035avic383pa3avk2s9k3n17yjcza8yb9nw47v3z6"))))
+            "1bz2yb77kxq4006j6cjdkl14n21pi0c0mdw20ywj9yd70y7lap2z"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-base-x" ,rust-base-x)
-         ("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-sha1" ,rust-sha1)
-         ("rust-syn" ,rust-syn))))
-    (home-page "https://github.com/koute/stdweb")
+        (("rust-bytes" ,rust-bytes)
+         ("rust-either" ,rust-either))
+        #:cargo-development-inputs
+        (("rust-tokio-mock-task" ,rust-tokio-mock-task))))
+    (home-page "https://tokio.rs")
     (synopsis
-      "Internal procedural macros for the `stdweb` crate")
+      "Asynchronous stream of byte buffers")
     (description
-      "Internal procedural macros for the `stdweb` crate")
-    (license (list license:asl2.0
-                   license:expat))))
+      "Asynchronous stream of byte buffers")
+    (license license:expat)))
+
+(define-public rust-tokio-codec
+  (package
+    (name "rust-tokio-codec")
+    (version "0.1.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "tokio-codec" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "17y3hi3dd0bdfkrzshx9qhwcf49xv9iynszj7iwy3w4nmz71wl2w"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-tokio-io" ,rust-tokio-io))))
+    (home-page "https://tokio.rs")
+    (synopsis
+      "Utilities for encoding and decoding frames.")
+    (description
+      "Utilities for encoding and decoding frames.")
+    (license license:expat)))
 
-(define-public rust-stdweb-internal-test-macro
+(define-public rust-tokio-core
   (package
-    (name "rust-stdweb-internal-test-macro")
-    (version "0.1.0")
+    (name "rust-tokio-core")
+    (version "0.1.17")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "stdweb-internal-test-macro" version))
+        (uri (crate-uri "tokio-core" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "12rrm7p77xnm3xacgn3rgniiyyjb4gq7902wpbljsvbx045z69l2"))))
+            "0wbgg59mxfvrhzv97y56nh3gmnmw3jj9dhgkmvz27410jjxzpvxf"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote))))
-    (home-page "https://github.com/koute/stdweb")
-    (synopsis "Internal crate of the `stdweb` crate")
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-iovec" ,rust-iovec)
+         ("rust-log" ,rust-log)
+         ("rust-mio" ,rust-mio)
+         ("rust-scoped-tls" ,rust-scoped-tls)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor)
+         ("rust-tokio-timer" ,rust-tokio-timer))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-flate2" ,rust-flate2)
+         ("rust-futures-cpupool" ,rust-futures-cpupool)
+         ("rust-http" ,rust-http)
+         ("rust-httparse" ,rust-httparse)
+         ("rust-libc" ,rust-libc)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-time" ,rust-time))))
+    (home-page "https://tokio.rs")
+    (synopsis
+      "Core I/O and event loop primitives for asynchronous I/O in Rust. Foundation for
+      the rest of the tokio crates.")
     (description
-      "Internal crate of the `stdweb` crate")
+      "Core I/O and event loop primitives for asynchronous I/O in Rust.  Foundation for
+      the rest of the tokio crates.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-stream-cipher
+(define-public rust-tokio-current-thread
   (package
-    (name "rust-stream-cipher")
-    (version "0.3.0")
+    (name "rust-tokio-current-thread")
+    (version "0.1.6")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "stream-cipher" version))
+        (uri (crate-uri "tokio-current-thread" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1g1nd8r6pph70rzk5yyvg7a9ji7pkap9ddiqpp4v9xa9ys0bqqc8"))))
+            "0hx4c8v88kk0ih8x5s564gsgwwf8n11kryvxm72l1f7isz51fqni"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-blobby" ,rust-blobby)
-         ("rust-generic-array" ,rust-generic-array))))
-    (home-page
-      "https://github.com/RustCrypto/traits")
-    (synopsis "Stream cipher traits")
-    (description "Stream cipher traits")
-    (license (list license:asl2.0
-                   license:expat))))
+        (("rust-futures" ,rust-futures)
+         ("rust-tokio-executor" ,rust-tokio-executor))))
+    (home-page "https://github.com/tokio-rs/tokio")
+    (synopsis
+      "Single threaded executor which manage many tasks concurrently on the current thread.")
+    (description
+      "Single threaded executor which manage many tasks concurrently on the current thread.")
+    (license license:expat)))
 
-(define-public rust-streaming-stats
+(define-public rust-tokio-executor
   (package
-    (name "rust-streaming-stats")
-    (version "0.2.2")
+    (name "rust-tokio-executor")
+    (version "0.1.8")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "streaming-stats" version))
+        (uri (crate-uri "tokio-executor" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0l7xz4g6709s80zqpvlhrg0qhgz64r94cwhmfsg8xhabgznbp2px"))))
+            "1b5n6barppmhfyb1m2cvswp7nqvyrr3lb0kk545my75hdl7fw9qg"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-num-traits" ,rust-num-traits))))
-    (home-page
-      "https://github.com/BurntSushi/rust-stats")
-    (synopsis
-      "Experimental crate for computing basic statistics on streams.")
-    (description
-      "Experimental crate for computing basic statistics on streams.")
-    (license (list license:unlicense
-                   license:expat))))
-
-(define-public rust-strsim-0.8
-  (package
-    (inherit rust-strsim)
-    (name "rust-strsim")
-    (version "0.8.0")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (crate-uri "strsim" version))
-        (file-name (string-append name "-" version ".tar.gz"))
-        (sha256
-         (base32
-          "0sjsm7hrvjdifz661pjxq5w4hf190hx53fra8dfvamacvff139cf"))))))
+        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
+         ("rust-futures" ,rust-futures))
+        #:cargo-development-inputs
+        (("rust-tokio" ,rust-tokio))))
+    (home-page "https://github.com/tokio-rs/tokio")
+    (synopsis "Future execution primitives")
+    (description "Future execution primitives")
+    (license license:expat)))
 
-(define-public rust-structopt
+(define-public rust-tokio-fs
   (package
-    (name "rust-structopt")
-    (version "0.2.18")
+    (name "rust-tokio-fs")
+    (version "0.1.6")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "structopt" version))
+        (uri (crate-uri "tokio-fs" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-         (base32
-          "1mvfv1l8vp3y402fkl2wcl34hi7gmr4bqha13dfz2xf3kjzwvhhn"))))
+          (base32
+            "1bxp8585pi4j5g39ci2gkk99qnyilyhhila7cs8r6scdn0idrriz"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-clap" ,rust-clap)
-         ("rust-structopt-derive" ,rust-structopt-derive))))
-    (home-page
-      "https://github.com/TeXitoi/structopt")
-    (synopsis
-      "Parse command line argument by defining a struct.")
-    (description
-      "Parse command line argument by defining a struct.")
-    (license (list license:asl2.0
-                   license:expat))))
+        (("rust-futures" ,rust-futures)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-threadpool" ,rust-tokio-threadpool))
+        #:cargo-development-inputs
+        (("rust-rand" ,rust-rand)
+         ("rust-tempdir" ,rust-tempdir)
+         ("rust-tempfile" ,rust-tempfile)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-codec" ,rust-tokio-codec)
+         ("rust-tokio-io" ,rust-tokio-io))))
+    (home-page "https://tokio.rs")
+    (synopsis "Filesystem API for Tokio.")
+    (description "Filesystem API for Tokio.")
+    (license license:expat)))
 
-(define-public rust-structopt-derive
+(define-public rust-tokio-io
   (package
-    (name "rust-structopt-derive")
-    (version "0.2.18")
+    (name "rust-tokio-io")
+    (version "0.1.12")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "structopt-derive" version))
+        (uri (crate-uri "tokio-io" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "01sis9z5kqmyhvzbnmlzpdxcry99a0b9blypksgnhdsbm1hh40ak"))))
+            "09jrz1hh4h1vj45qy09y7m7m8jsy1hl6g32clnky25mdim3dp42h"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-heck" ,rust-heck)
-         ("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn))))
-    (home-page
-      "https://github.com/TeXitoi/structopt")
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-log" ,rust-log))
+        #:cargo-development-inputs
+        (("rust-tokio-current-thread"
+          ,rust-tokio-current-thread))))
+    (home-page "https://tokio.rs")
     (synopsis
-      "Parse command line argument by defining a struct, derive crate.")
+      "Core I/O primitives for asynchronous I/O in Rust.")
     (description
-      "Parse command line argument by defining a struct, derive crate.")
-    (license (list license:asl2.0
-                   license:expat))))
+      "Core I/O primitives for asynchronous I/O in Rust.")
+    (license license:expat)))
 
-(define-public rust-syn
+(define-public rust-tokio-io-pool
   (package
-    (name "rust-syn")
-    (version "0.15.42")
+    (name "rust-tokio-io-pool")
+    (version "0.1.6")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "syn" version))
+        (uri (crate-uri "tokio-io-pool" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0png5pz7jjjj39xy8w7qr65y3s9qam0jpz6nbmal06m5dhq0kp7a"))))
+            "17lrjj7lcw13wchpbvr8cynmypd29h40clf9qxabh6fxva40kwm5"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-unicode-xid" ,rust-unicode-xid))
+        (("rust-futures" ,rust-futures)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-executor" ,rust-tokio-executor))
         #:cargo-development-inputs
-        (("rust-insta" ,rust-insta)
-         ("rust-rayon" ,rust-rayon)
-         ("rust-ref-cast" ,rust-ref-cast)
-         ("rust-regex" ,rust-regex)
-         ("rust-termcolor" ,rust-termcolor)
-         ("rust-walkdir" ,rust-walkdir))))
-    (home-page "https://github.com/dtolnay/syn")
-    (synopsis "Parser for Rust source code")
-    (description "Parser for Rust source code")
+        (("rust-tokio-current-thread"
+          ,rust-tokio-current-thread))))
+    (home-page
+      "https://github.com/jonhoo/tokio-io-pool")
+    (synopsis
+      "Alternative tokio thread pool for executing short, I/O-heavy futures efficiently")
+    (description
+      "Alternative tokio thread pool for executing short, I/O-heavy futures efficiently")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-synstructure
+(define-public rust-tokio-reactor
   (package
-    (name "rust-synstructure")
-    (version "0.11.0")
+    (name "rust-tokio-reactor")
+    (version "0.1.9")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "synstructure" version))
+        (uri (crate-uri "tokio-reactor" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1spqy31qcss57mciklc4nky4v778fvqs9qwdjgvnmf0hr5ichcca"))))
+            "1khip64cn63xvayq1db68kxcnhgw3cb449a4n2lbw4p1qzx6pwba"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-proc-macro2" ,rust-proc-macro2)
-         ("rust-quote" ,rust-quote)
-         ("rust-syn" ,rust-syn)
-         ("rust-unicode-xid" ,rust-unicode-xid))
+        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
+         ("rust-futures" ,rust-futures)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-log" ,rust-log)
+         ("rust-mio" ,rust-mio)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-parking-lot" ,rust-parking-lot)
+         ("rust-slab" ,rust-slab)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-sync" ,rust-tokio-sync))
         #:cargo-development-inputs
-        (("rust-synstructure-test-traits"
-          ,rust-synstructure-test-traits))))
-    (home-page
-      "https://github.com/mystor/synstructure")
+        (("rust-num-cpus" ,rust-num-cpus)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-io-pool" ,rust-tokio-io-pool))))
+    (home-page "https://tokio.rs")
     (synopsis
-      "Helper methods and macros for custom derives")
+      "Event loop that drives Tokio I/O resources.")
     (description
-      "Helper methods and macros for custom derives")
+      "Event loop that drives Tokio I/O resources.")
     (license license:expat)))
 
-(define-public rust-tempdir
+(define-public rust-tokio-mock-task
   (package
-    (name "rust-tempdir")
-    (version "0.3.7")
+    (name "rust-tokio-mock-task")
+    (version "0.1.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tempdir" version))
+        (uri (crate-uri "tokio-mock-task" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1n5n86zxpgd85y0mswrp5cfdisizq2rv3la906g6ipyc03xvbwhm"))))
+            "1y7q83qfk9ljjfvs82b453pmz9x1v3d6kr4x55j8mal01s6790dw"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-rand" ,rust-rand-0.4)
-         ("rust-remove-dir-all" ,rust-remove-dir-all))))
+      `(#:cargo-inputs (("rust-futures" ,rust-futures))))
     (home-page
-      "https://github.com/rust-lang/tempdir")
-    (synopsis
-      "A library for managing a temporary directory and deleting all contents when it's dropped.")
-    (description
-      "This package provides a library for managing a temporary directory and deleting all contents when it's dropped.")
-    (license (list license:asl2.0
-                   license:expat))))
+      "https://github.com/carllerche/tokio-mock-task")
+    (synopsis "Mock a Tokio task")
+    (description "Mock a Tokio task")
+    (license license:expat)))
 
-(define-public rust-tempfile
+(define-public rust-tokio-mockstream
   (package
-    (name "rust-tempfile")
-    (version "3.1.0")
+    (name "rust-tokio-mockstream")
+    (version "1.1.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tempfile" version))
+        (uri (crate-uri "tokio-mockstream" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1a9cfdqw70n7bcnkx05aih9xdba8lqazmqlkjpkmn2la6gcj8vks"))))
+            "0mg1i39cl8x32wxwbn74hlirks8a6f3g0gfzkb0n0zwbxwvc9gs1"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-cfg-if" ,rust-cfg-if)
-         ("rust-libc" ,rust-libc)
-         ("rust-rand" ,rust-rand)
-         ("rust-redox-syscall" ,rust-redox-syscall)
-         ("rust-remove-dir-all" ,rust-remove-dir-all)
-         ("rust-winapi" ,rust-winapi))))
+        (("rust-futures" ,rust-futures)
+         ("rust-tokio-io" ,rust-tokio-io))
+        #:cargo-development-inputs
+        (("rust-bytes" ,rust-bytes))))
     (home-page
-      "http://stebalien.com/projects/tempfile-rs")
+      "https://github.com/aatxe/tokio-mockstream")
     (synopsis
-      "A library for managing temporary files and directories.")
+      "A fake stream for testing network applications backed by buffers.")
     (description
-      "This package provides a library for managing temporary files and directories.")
+      "A fake stream for testing network applications backed by buffers.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-term
+(define-public rust-tokio-openssl
   (package
-    (name "rust-term")
-    (version "0.5.2")
+    (name "rust-tokio-openssl")
+    (version "0.4.0-alpha.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "term" version))
+        (uri (crate-uri "tokio-openssl" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0hkgjrfisj6zjwz525639pmsvzhlc48a0h65nw87qrdp6jihdlgd"))))
+            "0zzhb720bmjkcg5q53yp9mimx8frnbrk9il6rya16zc6pwmzbfw8"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-byteorder" ,rust-byteorder)
-         ("rust-dirs" ,rust-dirs)
-         ("rust-winapi" ,rust-winapi))))
-    (home-page "https://github.com/Stebalien/term")
-    (synopsis "A terminal formatting library")
+        (("rust-openssl" ,rust-openssl)
+         ("rust-tokio-io" ,rust-tokio-io))
+        #:cargo-development-inputs
+        (("rust-futures-preview" ,rust-futures-preview)
+         ("rust-tokio" ,rust-tokio))))
+    (home-page
+      "https://github.com/alexcrichton/tokio-openssl")
+    (synopsis
+      "An implementation of SSL streams for Tokio backed by OpenSSL")
     (description
-      "This package provides a terminal formatting library")
+      "An implementation of SSL streams for Tokio backed by OpenSSL")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-term-size
+(define-public rust-tokio-rustls
   (package
-    (name "rust-term-size")
-    (version "1.0.0-beta1")
+    (name "rust-tokio-rustls")
+    (version "0.12.0-alpha.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "term_size" version))
+        (uri (crate-uri "tokio-rustls" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "13w9cqjhzh3mmx6zami8lxyf42xx53yy866zxhxqcm71k637v8d8"))))
+            "0vmjqdpvvwi5xga8lrp9pr29i7jd77zzlbbv4vi2mnsqxjafdcji"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-clippy" ,rust-clippy)
-         ;("rust-kernel32-sys" ,rust-kernel32-sys) ; windows
-         ("rust-libc" ,rust-libc)
-         ("rust-winapi" ,rust-winapi))))
+        (("rust-futures-core-preview"
+          ,rust-futures-core-preview)
+         ("rust-rustls" ,rust-rustls)
+         ("rust-smallvec" ,rust-smallvec)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-webpki" ,rust-webpki))
+        #:cargo-development-inputs
+        (("rust-futures-util-preview"
+          ,rust-futures-util-preview)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-webpki-roots" ,rust-webpki-roots))))
     (home-page
-      "https://github.com/kbknapp/term_size-rs.git")
+      "https://github.com/quininer/tokio-rustls")
     (synopsis
-      "functions for determining terminal sizes and dimensions")
+      "Asynchronous TLS/SSL streams for Tokio using Rustls.")
     (description
-      "functions for determining terminal sizes and dimensions")
+      "Asynchronous TLS/SSL streams for Tokio using Rustls.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-termcolor
-  (package
-    (name "rust-termcolor")
-    (version "1.0.5")
-    (source
-      (origin
-        (method url-fetch)
-        (uri (crate-uri "termcolor" version))
-        (file-name (string-append name "-" version ".tar.gz"))
-        (sha256
-         (base32
-          "0vjfsn1a8zvqhnrbygrz1id6yckwv1dncw3w4zj65qdx0f00kmln"))))
-    (build-system cargo-build-system)
-    (arguments
-     `(#:cargo-inputs
-       (("rust-wincolor" ,rust-wincolor))))
-    (home-page "https://github.com/BurntSushi/termcolor")
-    (synopsis "Library for writing colored text to a terminal")
-    (description "This package provides a simple cross platform library for
-writing colored text to a terminal.")
-    (license (list license:unlicense
-                   license:expat))))
-
-(define-public rust-termios
+(define-public rust-tokio-sync
   (package
-    (name "rust-termios")
-    (version "0.3.1")
+    (name "rust-tokio-sync")
+    (version "0.1.6")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "termios" version))
+        (uri (crate-uri "tokio-sync" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "09any1p4jp4bphvb5ikagnvwjc3xn2djchy96nkpa782xb2j1dkj"))))
+            "1ryalh7dcmnz46xj1va8aaw3if6vd4mj87r67dqvrqhpyf7j8qi1"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs (("rust-libc" ,rust-libc))))
-    (home-page
-      "https://github.com/dcuddeback/termios-rs")
-    (synopsis
-      "Safe bindings for the termios library.")
-    (description
-      "Safe bindings for the termios library.")
+      `(#:cargo-inputs
+        (("rust-fnv" ,rust-fnv)
+         ("rust-futures" ,rust-futures))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-loom" ,rust-loom)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-mock-task" ,rust-tokio-mock-task))))
+    (home-page "https://tokio.rs")
+    (synopsis "Synchronization utilities.")
+    (description "Synchronization utilities.")
     (license license:expat)))
 
-(define-public rust-textwrap
+(define-public rust-tokio-tcp
   (package
-    (name "rust-textwrap")
-    (version "0.11.0")
+    (name "rust-tokio-tcp")
+    (version "0.1.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "textwrap" version))
+        (uri (crate-uri "tokio-tcp" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0q5hky03ik3y50s9sz25r438bc4nwhqc6dqwynv4wylc807n29nk"))))
+            "06a15vg8bcd33ng3h9ldzlq7wl4jsw0p9qpy7v22ls5yah3b250x"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-hyphenation" ,rust-hyphenation)
-         ("rust-term-size" ,rust-term-size)
-         ("rust-unicode-width" ,rust-unicode-width))
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-iovec" ,rust-iovec)
+         ("rust-mio" ,rust-mio)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor))
         #:cargo-development-inputs
-        (("rust-lipsum" ,rust-lipsum)
-         ("rust-rand" ,rust-rand)
-         ("rust-rand-xorshift" ,rust-rand-xorshift)
-         ("rust-version-sync" ,rust-version-sync))))
-    (home-page
-      "https://github.com/mgeisler/textwrap")
-    (synopsis
-      "Textwrap is a small library for word wrapping, indenting, and
-      dedenting strings.
-
-      You can use it to format strings (such as help and error messages) for
-      display in commandline applications. It is designed to be efficient
-      and handle Unicode characters correctly.")
-    (description
-      "Textwrap is a small library for word wrapping, indenting, and
-      dedenting strings.
-
-      You can use it to format strings (such as help and error messages) for
-      display in commandline applications.  It is designed to be efficient
-      and handle Unicode characters correctly.")
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-tokio" ,rust-tokio))))
+    (home-page "https://tokio.rs")
+    (synopsis "TCP bindings for tokio.")
+    (description "TCP bindings for tokio.")
     (license license:expat)))
 
-(define-public rust-thread-local
+(define-public rust-tokio-threadpool
   (package
-    (name "rust-thread-local")
-    (version "0.3.6")
+    (name "rust-tokio-threadpool")
+    (version "0.1.15")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "thread_local" version))
+        (uri (crate-uri "tokio-threadpool" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "06rzik99p8c5js8238yhc8rk6np543ylb1dy9nrw5v80j0r3xdf6"))))
+            "06av6vdkgb48v6xaaci5agfydg9fsj9c338y01m3f7paklqh3jlh"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-lazy-static" ,rust-lazy-static))))
-    (home-page
-      "https://github.com/Amanieu/thread_local-rs")
-    (synopsis "Per-object thread-local storage")
-    (description "Per-object thread-local storage")
-    (license (list license:asl2.0
-                   license:expat))))
+        (("rust-crossbeam-deque" ,rust-crossbeam-deque)
+         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
+         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
+         ("rust-futures" ,rust-futures)
+         ("rust-log" ,rust-log)
+         ("rust-num-cpus" ,rust-num-cpus)
+         ("rust-rand" ,rust-rand)
+         ("rust-slab" ,rust-slab)
+         ("rust-tokio-executor" ,rust-tokio-executor))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-futures-cpupool" ,rust-futures-cpupool)
+         ("rust-threadpool" ,rust-threadpool))))
+    (home-page "https://github.com/tokio-rs/tokio")
+    (synopsis
+      "A task scheduler backed by a work-stealing thread pool.")
+    (description
+      "This package provides a task scheduler backed by a work-stealing thread pool.")
+    (license license:expat)))
 
-(define-public rust-time
+(define-public rust-tokio-timer
   (package
-    (name "rust-time")
-    (version "0.1.42")
+    (name "rust-tokio-timer")
+    (version "0.2.11")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "time" version))
+        (uri (crate-uri "tokio-timer" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0vsbvsz0ryxb35dy9j4anxvy8zlaplmjmi0a4z4l64bc135cz3fv"))))
+            "03m68ainkdy3b5pf20rjyknhk2ppx35bjdc2yfj2bv80sl96h47j"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-libc" ,rust-libc)
-         ("rust-redox-syscall" ,rust-redox-syscall)
-         ("rust-rustc-serialize" ,rust-rustc-serialize)
-         ("rust-winapi" ,rust-winapi))
+        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
+         ("rust-futures" ,rust-futures)
+         ("rust-slab" ,rust-slab)
+         ("rust-tokio-executor" ,rust-tokio-executor))
         #:cargo-development-inputs
-        (("rust-log" ,rust-log)
-         ("rust-winapi" ,rust-winapi))))
-    (home-page "https://github.com/rust-lang/time")
-    (synopsis
-      "Utilities for working with time-related functions in Rust.")
-    (description
-      "Utilities for working with time-related functions in Rust.")
-    (license (list license:asl2.0
-                   license:expat))))
+        (("rust-rand" ,rust-rand)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-mock-task" ,rust-tokio-mock-task))))
+    (home-page "https://github.com/tokio-rs/tokio")
+    (synopsis "Timer facilities for Tokio")
+    (description "Timer facilities for Tokio")
+    (license license:expat)))
 
-(define-public rust-tokio
+(define-public rust-tokio-tls
   (package
-    (name "rust-tokio")
-    (version "0.1.22")
+    (name "rust-tokio-tls")
+    (version "0.3.0-alpha.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio" version))
+        (uri (crate-uri "tokio-tls" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1xhaadfmm6m37f79xv5020gc3np9wqza3bq95ymp522qpfsw02as"))))
+            "1z9bbxkd646lsn1fr1a5znxdz8afbpy31iq1knxd424v57lxf29p"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-bytes" ,rust-bytes)
-         ("rust-futures" ,rust-futures)
-         ("rust-mio" ,rust-mio)
-         ("rust-num-cpus" ,rust-num-cpus)
-         ("rust-tokio-codec" ,rust-tokio-codec)
-         ("rust-tokio-current-thread"
-          ,rust-tokio-current-thread)
-         ("rust-tokio-executor" ,rust-tokio-executor)
-         ("rust-tokio-fs" ,rust-tokio-fs)
-         ("rust-tokio-io" ,rust-tokio-io)
-         ("rust-tokio-reactor" ,rust-tokio-reactor)
-         ("rust-tokio-sync" ,rust-tokio-sync)
-         ("rust-tokio-tcp" ,rust-tokio-tcp)
-         ("rust-tokio-threadpool" ,rust-tokio-threadpool)
-         ("rust-tokio-timer" ,rust-tokio-timer)
-         ("rust-tokio-udp" ,rust-tokio-udp)
-         ("rust-tokio-uds" ,rust-tokio-uds)
-         ("rust-tracing-core" ,rust-tracing-core))
-        #:cargo-development-inputs
-        (("rust-env-logger" ,rust-env-logger)
-         ("rust-flate2" ,rust-flate2)
-         ("rust-futures-cpupool" ,rust-futures-cpupool)
-         ("rust-http" ,rust-http)
-         ("rust-httparse" ,rust-httparse)
-         ("rust-libc" ,rust-libc)
-         ("rust-num-cpus" ,rust-num-cpus)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-derive" ,rust-serde-derive)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-time" ,rust-time))))
+        (("rust-native-tls" ,rust-native-tls)
+         ("rust-tokio-io" ,rust-tokio-io))))
     (home-page "https://tokio.rs")
     (synopsis
-      "An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.")
+      "An implementation of TLS/SSL streams for Tokio giving an implementation of TLS for nonblocking I/O streams.")
     (description
-      "An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications.")
+      "An implementation of TLS/SSL streams for Tokio giving an implementation of TLS for nonblocking I/O streams.")
     (license license:expat)))
 
-(define-public rust-tokio-codec
+(define-public rust-tokio-udp
   (package
-    (name "rust-tokio-codec")
-    (version "0.1.1")
+    (name "rust-tokio-udp")
+    (version "0.1.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-codec" version))
+        (uri (crate-uri "tokio-udp" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "17y3hi3dd0bdfkrzshx9qhwcf49xv9iynszj7iwy3w4nmz71wl2w"))))
+            "14kfj35s465czcspayacnzlxrazfvxzhhggq1rqlljhgp1sqa9k6"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
         (("rust-bytes" ,rust-bytes)
          ("rust-futures" ,rust-futures)
-         ("rust-tokio-io" ,rust-tokio-io))))
+         ("rust-log" ,rust-log)
+         ("rust-mio" ,rust-mio)
+         ("rust-tokio-codec" ,rust-tokio-codec)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger))))
     (home-page "https://tokio.rs")
-    (synopsis
-      "Utilities for encoding and decoding frames.")
-    (description
-      "Utilities for encoding and decoding frames.")
+    (synopsis "UDP bindings for tokio.")
+    (description "UDP bindings for tokio.")
     (license license:expat)))
 
-(define-public rust-tokio-current-thread
+(define-public rust-tokio-uds
   (package
-    (name "rust-tokio-current-thread")
-    (version "0.1.6")
+    (name "rust-tokio-uds")
+    (version "0.2.5")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-current-thread" version))
+        (uri (crate-uri "tokio-uds" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0hx4c8v88kk0ih8x5s564gsgwwf8n11kryvxm72l1f7isz51fqni"))))
+            "0i94kxma6l7iy5hd5k7nvn7v9pnyw0s54bm9mjs0lap1l0xzqzq3"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-futures" ,rust-futures)
-         ("rust-tokio-executor" ,rust-tokio-executor))))
+        (("rust-bytes" ,rust-bytes)
+         ("rust-futures" ,rust-futures)
+         ("rust-iovec" ,rust-iovec)
+         ("rust-libc" ,rust-libc)
+         ("rust-log" ,rust-log)
+         ("rust-mio" ,rust-mio)
+         ("rust-mio-uds" ,rust-mio-uds)
+         ("rust-tokio-codec" ,rust-tokio-codec)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor))
+        #:cargo-development-inputs
+        (("rust-tempfile" ,rust-tempfile)
+         ("rust-tokio" ,rust-tokio))))
     (home-page "https://github.com/tokio-rs/tokio")
-    (synopsis
-      "Single threaded executor which manage many tasks concurrently on the current thread.")
-    (description
-      "Single threaded executor which manage many tasks concurrently on the current thread.")
+    (synopsis "Unix Domain sockets for Tokio")
+    (description "Unix Domain sockets for Tokio")
     (license license:expat)))
 
-(define-public rust-tokio-executor
+(define-public rust-toml
   (package
-    (name "rust-tokio-executor")
-    (version "0.1.8")
+    (name "rust-toml")
+    (version "0.5.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-executor" version))
+        (uri (crate-uri "toml" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1b5n6barppmhfyb1m2cvswp7nqvyrr3lb0kk545my75hdl7fw9qg"))))
+            "0fdhfyv20qn29cxq1f9j9wav92c3qhxdm71sxfyzhzpsfdw6vjdq"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
-         ("rust-futures" ,rust-futures))
+        (("rust-linked-hash-map" ,rust-linked-hash-map)
+         ("rust-serde" ,rust-serde))
         #:cargo-development-inputs
-        (("rust-tokio" ,rust-tokio))))
-    (home-page "https://github.com/tokio-rs/tokio")
-    (synopsis "Future execution primitives")
-    (description "Future execution primitives")
-    (license license:expat)))
+        (("rust-serde-derive" ,rust-serde-derive)
+         ("rust-serde-json" ,rust-serde-json))))
+    (home-page
+      "https://github.com/alexcrichton/toml-rs")
+    (synopsis
+      "A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.")
+    (description
+      "A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-fs
+(define-public rust-tracing-core
   (package
-    (name "rust-tokio-fs")
-    (version "0.1.6")
+    (name "rust-tracing-core")
+    (version "0.1.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-fs" version))
+        (uri (crate-uri "tracing-core" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1bxp8585pi4j5g39ci2gkk99qnyilyhhila7cs8r6scdn0idrriz"))))
+            "01fa73wzw2m5ybi3kkd52dgrw97mgc3i6inmhwys46ab28giwnxi"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-futures" ,rust-futures)
-         ("rust-tokio-io" ,rust-tokio-io)
-         ("rust-tokio-threadpool" ,rust-tokio-threadpool))
-        #:cargo-development-inputs
-        (("rust-rand" ,rust-rand)
-         ("rust-tempdir" ,rust-tempdir)
-         ("rust-tempfile" ,rust-tempfile)
-         ("rust-tokio" ,rust-tokio)
-         ("rust-tokio-codec" ,rust-tokio-codec)
-         ("rust-tokio-io" ,rust-tokio-io))))
+        (("rust-lazy-static" ,rust-lazy-static))))
     (home-page "https://tokio.rs")
-    (synopsis "Filesystem API for Tokio.")
-    (description "Filesystem API for Tokio.")
-    (license license:expat)))
+    (synopsis
+      "Core primitives for application-level tracing.")
+    (description
+      "Core primitives for application-level tracing.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-io
+(define-public rust-trust-dns-https
   (package
-    (name "rust-tokio-io")
-    (version "0.1.12")
+    (name "rust-trust-dns-https")
+    (version "0.4.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-io" version))
+        (uri (crate-uri "trust-dns-https" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "09jrz1hh4h1vj45qy09y7m7m8jsy1hl6g32clnky25mdim3dp42h"))))
+            "1ypkbgm5p7smjfkca3gaszhvknbr2ykf8skw8pyvpn0sq95lv5ia"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
         (("rust-bytes" ,rust-bytes)
+         ("rust-data-encoding" ,rust-data-encoding)
+         ("rust-failure" ,rust-failure)
          ("rust-futures" ,rust-futures)
-         ("rust-log" ,rust-log))
+         ("rust-h2" ,rust-h2)
+         ("rust-http" ,rust-http)
+         ("rust-log" ,rust-log)
+         ("rust-rustls" ,rust-rustls)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-reactor" ,rust-tokio-reactor)
+         ("rust-tokio-rustls" ,rust-tokio-rustls)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-trust-dns-proto" ,rust-trust-dns-proto)
+         ("rust-trust-dns-rustls" ,rust-trust-dns-rustls)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-reactor" ,rust-tokio-reactor)
+         ("rust-tokio-rustls" ,rust-tokio-rustls)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-trust-dns-proto" ,rust-trust-dns-proto)
+         ("rust-trust-dns-rustls" ,rust-trust-dns-rustls)
+         ("rust-typed-headers" ,rust-typed-headers)
+         ("rust-webpki" ,rust-webpki)
+         ("rust-webpki-roots" ,rust-webpki-roots))
         #:cargo-development-inputs
-        (("rust-tokio-current-thread"
-          ,rust-tokio-current-thread))))
-    (home-page "https://tokio.rs")
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-tokio" ,rust-tokio))))
+    (home-page "http://www.trust-dns.org/index.html")
     (synopsis
-      "Core I/O primitives for asynchronous I/O in Rust.")
+      "Trust-DNS is a safe and secure DNS library. This is an extension for the Trust-DNS client to use DNS over HTTPS.")
     (description
-      "Core I/O primitives for asynchronous I/O in Rust.")
-    (license license:expat)))
+      "Trust-DNS is a safe and secure DNS library.  This is an extension for the Trust-DNS client to use DNS over HTTPS.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-reactor
+(define-public rust-trust-dns-native-tls
   (package
-    (name "rust-tokio-reactor")
-    (version "0.1.9")
+    (name "rust-trust-dns-native-tls")
+    (version "0.7.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-reactor" version))
+        (uri (crate-uri "trust-dns-native-tls" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1khip64cn63xvayq1db68kxcnhgw3cb449a4n2lbw4p1qzx6pwba"))))
+            "0dkwfqxjjmbikm3mav71zjymgy8wmqr4mca64x49qzknvc4qwy6z"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
-         ("rust-futures" ,rust-futures)
-         ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-log" ,rust-log)
-         ("rust-mio" ,rust-mio)
-         ("rust-num-cpus" ,rust-num-cpus)
-         ("rust-parking-lot" ,rust-parking-lot)
-         ("rust-slab" ,rust-slab)
-         ("rust-tokio-executor" ,rust-tokio-executor)
-         ("rust-tokio-io" ,rust-tokio-io)
-         ("rust-tokio-sync" ,rust-tokio-sync))
+        (("rust-futures" ,rust-futures)
+         ("rust-native-tls" ,rust-native-tls)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-tokio-tls" ,rust-tokio-tls)
+         ("rust-trust-dns-proto" ,rust-trust-dns-proto))
         #:cargo-development-inputs
-        (("rust-num-cpus" ,rust-num-cpus)
-         ("rust-tokio" ,rust-tokio)
-         ("rust-tokio-io-pool" ,rust-tokio-io-pool))))
-    (home-page "https://tokio.rs")
+        (("rust-tokio" ,rust-tokio))))
+    (home-page "http://www.trust-dns.org/index.html")
     (synopsis
-      "Event loop that drives Tokio I/O resources.")
+      "Trust-DNS is a safe and secure DNS library. This is an extension for the Trust-DNS client to use native-tls for TLS.")
     (description
-      "Event loop that drives Tokio I/O resources.")
-    (license license:expat)))
+      "Trust-DNS is a safe and secure DNS library.  This is an extension for the Trust-DNS client to use native-tls for TLS.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-mock-task
+(define-public rust-trust-dns-openssl
   (package
-    (name "rust-tokio-mock-task")
-    (version "0.1.1")
+    (name "rust-trust-dns-openssl")
+    (version "0.7.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-mock-task" version))
+        (uri (crate-uri "trust-dns-openssl" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1y7q83qfk9ljjfvs82b453pmz9x1v3d6kr4x55j8mal01s6790dw"))))
+            "19qxi4y33wd2g55r4v9d6b06d20bdhqhvsrsmbpz5ir3i7l5psp7"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs (("rust-futures" ,rust-futures))))
-    (home-page
-      "https://github.com/carllerche/tokio-mock-task")
-    (synopsis "Mock a Tokio task")
-    (description "Mock a Tokio task")
-    (license license:expat)))
+      `(#:cargo-inputs
+        (("rust-futures" ,rust-futures)
+         ("rust-openssl" ,rust-openssl)
+         ("rust-tokio-openssl" ,rust-tokio-openssl)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-trust-dns-proto" ,rust-trust-dns-proto))
+        #:cargo-development-inputs
+        (("rust-openssl" ,rust-openssl)
+         ("rust-tokio" ,rust-tokio))))
+    (home-page "http://www.trust-dns.org/index.html")
+    (synopsis
+      "Trust-DNS is a safe and secure DNS library. This is an extension for the Trust-DNS client to use tokio-openssl for TLS.")
+    (description
+      "Trust-DNS is a safe and secure DNS library.  This is an extension for the Trust-DNS client to use tokio-openssl for TLS.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-sync
+(define-public rust-trust-dns-proto
   (package
-    (name "rust-tokio-sync")
-    (version "0.1.6")
+    (name "rust-trust-dns-proto")
+    (version "0.8.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-sync" version))
+        (uri (crate-uri "trust-dns-proto" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "1ryalh7dcmnz46xj1va8aaw3if6vd4mj87r67dqvrqhpyf7j8qi1"))))
+            "1f9xjyz7fsa83dj00zif7lmljd4x420c0vmniinhb7c35777wi85"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-fnv" ,rust-fnv)
-         ("rust-futures" ,rust-futures))
+        (("rust-data-encoding" ,rust-data-encoding)
+         ("rust-enum-as-inner" ,rust-enum-as-inner)
+         ("rust-failure" ,rust-failure)
+         ("rust-futures" ,rust-futures)
+         ("rust-idna" ,rust-idna)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-log" ,rust-log)
+         ("rust-openssl" ,rust-openssl)
+         ("rust-rand" ,rust-rand)
+         ("rust-ring" ,rust-ring)
+         ("rust-serde" ,rust-serde)
+         ("rust-smallvec" ,rust-smallvec)
+         ("rust-socket2" ,rust-socket2)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-io" ,rust-tokio-io)
+         ("rust-tokio-reactor" ,rust-tokio-reactor)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-tokio-timer" ,rust-tokio-timer)
+         ("rust-tokio-udp" ,rust-tokio-udp)
+         ("rust-url" ,rust-url))
         #:cargo-development-inputs
         (("rust-env-logger" ,rust-env-logger)
-         ("rust-loom" ,rust-loom)
-         ("rust-tokio" ,rust-tokio)
-         ("rust-tokio-mock-task" ,rust-tokio-mock-task))))
-    (home-page "https://tokio.rs")
-    (synopsis "Synchronization utilities.")
-    (description "Synchronization utilities.")
-    (license license:expat)))
+         ("rust-tokio" ,rust-tokio))))
+    (home-page "http://www.trust-dns.org/index.html")
+    (synopsis
+      "Trust-DNS is a safe and secure DNS library. This is the foundational DNS protocol library for all Trust-DNS projects.")
+    (description
+      "Trust-DNS is a safe and secure DNS library.  This is the foundational DNS protocol library for all Trust-DNS projects.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-tcp
+(define-public rust-trust-dns-resolver
   (package
-    (name "rust-tokio-tcp")
-    (version "0.1.3")
+    (name "rust-trust-dns-resolver")
+    (version "0.12.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-tcp" version))
+        (uri (crate-uri "trust-dns-resolver" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "06a15vg8bcd33ng3h9ldzlq7wl4jsw0p9qpy7v22ls5yah3b250x"))))
+            "0cjkz3rcisk7v354l5hqb3j5x9x389pjqd6da6h8skvqxr0kl6yb"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-bytes" ,rust-bytes)
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-failure" ,rust-failure)
          ("rust-futures" ,rust-futures)
-         ("rust-iovec" ,rust-iovec)
-         ("rust-mio" ,rust-mio)
-         ("rust-tokio-io" ,rust-tokio-io)
-         ("rust-tokio-reactor" ,rust-tokio-reactor))
+         ("rust-ipconfig" ,rust-ipconfig)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-log" ,rust-log)
+         ("rust-lru-cache" ,rust-lru-cache)
+         ("rust-resolv-conf" ,rust-resolv-conf)
+         ("rust-rustls" ,rust-rustls)
+         ("rust-serde" ,rust-serde)
+         ("rust-smallvec" ,rust-smallvec)
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-tokio-udp" ,rust-tokio-udp)
+         ("rust-trust-dns-https" ,rust-trust-dns-https)
+         ("rust-trust-dns-native-tls"
+          ,rust-trust-dns-native-tls)
+         ("rust-trust-dns-openssl"
+          ,rust-trust-dns-openssl)
+         ("rust-trust-dns-proto" ,rust-trust-dns-proto)
+         ("rust-trust-dns-rustls" ,rust-trust-dns-rustls)
+         ("rust-webpki-roots" ,rust-webpki-roots))
         #:cargo-development-inputs
         (("rust-env-logger" ,rust-env-logger)
-         ("rust-tokio" ,rust-tokio))))
-    (home-page "https://tokio.rs")
-    (synopsis "TCP bindings for tokio.")
-    (description "TCP bindings for tokio.")
-    (license license:expat)))
+         ("rust-tokio" ,rust-tokio)
+         ("rust-tokio-io" ,rust-tokio-io))))
+    (home-page "http://www.trust-dns.org/index.html")
+    (synopsis
+      "Trust-DNS is a safe and secure DNS library. This Resolver library  uses the Client library to perform all DNS queries. The Resolver is intended to be a high-level library for any DNS record resolution see Resolver and AsyncResolver for supported resolution types. The Client can be used for other queries.
+      ")
+         (description
+           "Trust-DNS is a safe and secure DNS library.  This Resolver library  uses the Client library to perform all DNS queries.  The Resolver is intended to be a high-level library for any DNS record resolution see Resolver and AsyncResolver for supported resolution types.  The Client can be used for other queries.
+           ")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-threadpool
+(define-public rust-trust-dns-rustls
   (package
-    (name "rust-tokio-threadpool")
-    (version "0.1.15")
+    (name "rust-trust-dns-rustls")
+    (version "0.7.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-threadpool" version))
+        (uri (crate-uri "trust-dns-rustls" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "06av6vdkgb48v6xaaci5agfydg9fsj9c338y01m3f7paklqh3jlh"))))
+            "0glpggq31764q7lp19h5l6implsr7ik015qkm5rg7pqwy93krsb3"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-crossbeam-deque" ,rust-crossbeam-deque)
-         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
-         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
-         ("rust-futures" ,rust-futures)
+        (("rust-futures" ,rust-futures)
          ("rust-log" ,rust-log)
-         ("rust-num-cpus" ,rust-num-cpus)
-         ("rust-rand" ,rust-rand)
-         ("rust-slab" ,rust-slab)
-         ("rust-tokio-executor" ,rust-tokio-executor))
+         ("rust-rustls" ,rust-rustls)
+         ("rust-tokio-rustls" ,rust-tokio-rustls)
+         ("rust-tokio-tcp" ,rust-tokio-tcp)
+         ("rust-trust-dns-proto" ,rust-trust-dns-proto)
+         ("rust-webpki" ,rust-webpki))
         #:cargo-development-inputs
-        (("rust-env-logger" ,rust-env-logger)
-         ("rust-futures-cpupool" ,rust-futures-cpupool)
-         ("rust-threadpool" ,rust-threadpool))))
-    (home-page "https://github.com/tokio-rs/tokio")
+        (("rust-openssl" ,rust-openssl)
+         ("rust-tokio" ,rust-tokio))))
+    (home-page "http://www.trust-dns.org/index.html")
     (synopsis
-      "A task scheduler backed by a work-stealing thread pool.")
+      "Trust-DNS is a safe and secure DNS library. This is an extension for the Trust-DNS client to use rustls for TLS.")
     (description
-      "This package provides a task scheduler backed by a work-stealing thread pool.")
-    (license license:expat)))
+      "Trust-DNS is a safe and secure DNS library.  This is an extension for the Trust-DNS client to use rustls for TLS.")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-tokio-timer
+(define-public rust-try-from
   (package
-    (name "rust-tokio-timer")
-    (version "0.2.11")
+    (name "rust-try-from")
+    (version "0.3.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-timer" version))
-        (file-name
-          (string-append name "-" version ".tar.gz"))
+        (uri (crate-uri "try_from" version))
+        (file-name (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "03m68ainkdy3b5pf20rjyknhk2ppx35bjdc2yfj2bv80sl96h47j"))))
+         (base32
+          "12wdd4ja7047sd3rx70hv2056hyc8gcdllcx3a41g1rnw64kng98"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
-         ("rust-futures" ,rust-futures)
-         ("rust-slab" ,rust-slab)
-         ("rust-tokio-executor" ,rust-tokio-executor))
-        #:cargo-development-inputs
-        (("rust-rand" ,rust-rand)
-         ("rust-tokio" ,rust-tokio)
-         ("rust-tokio-mock-task" ,rust-tokio-mock-task))))
-    (home-page "https://github.com/tokio-rs/tokio")
-    (synopsis "Timer facilities for Tokio")
-    (description "Timer facilities for Tokio")
+     `(#:cargo-inputs
+      (("rust-cfg-if" ,rust-cfg-if))))
+    (home-page "https://github.com/derekjw/try_from")
+    (synopsis
+      "TryFrom and TryInto traits for failable conversions that return a Result.")
+    (description
+      "TryFrom and TryInto traits for failable conversions that return a Result.")
     (license license:expat)))
 
-(define-public rust-tokio-udp
+(define-public rust-try-lock
   (package
-    (name "rust-tokio-udp")
-    (version "0.1.3")
+    (name "rust-try-lock")
+    (version "0.2.2")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-udp" version))
+        (uri (crate-uri "try-lock" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "14kfj35s465czcspayacnzlxrazfvxzhhggq1rqlljhgp1sqa9k6"))))
+            "10p36rx6pqi9d0zr876xa8vksx2m66ha45myakl50rn08dxyn176"))))
     (build-system cargo-build-system)
-    (arguments
-      `(#:cargo-inputs
-        (("rust-bytes" ,rust-bytes)
-         ("rust-futures" ,rust-futures)
-         ("rust-log" ,rust-log)
-         ("rust-mio" ,rust-mio)
-         ("rust-tokio-codec" ,rust-tokio-codec)
-         ("rust-tokio-io" ,rust-tokio-io)
-         ("rust-tokio-reactor" ,rust-tokio-reactor))
-        #:cargo-development-inputs
-        (("rust-env-logger" ,rust-env-logger))))
-    (home-page "https://tokio.rs")
-    (synopsis "UDP bindings for tokio.")
-    (description "UDP bindings for tokio.")
+    (home-page
+      "https://github.com/seanmonstar/try-lock")
+    (synopsis "A lightweight atomic lock.")
+    (description
+      "This package provides a lightweight atomic lock.")
     (license license:expat)))
 
-(define-public rust-tokio-uds
+(define-public rust-trybuild
   (package
-    (name "rust-tokio-uds")
-    (version "0.2.5")
+    (name "rust-trybuild")
+    (version "1.0.9")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tokio-uds" version))
+        (uri (crate-uri "trybuild" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0i94kxma6l7iy5hd5k7nvn7v9pnyw0s54bm9mjs0lap1l0xzqzq3"))))
+            "0df6ipayif05xn61iavdb0dcshm9y6wmcd140pp7dl91mirygs7j"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-bytes" ,rust-bytes)
-         ("rust-futures" ,rust-futures)
-         ("rust-iovec" ,rust-iovec)
-         ("rust-libc" ,rust-libc)
-         ("rust-log" ,rust-log)
-         ("rust-mio" ,rust-mio)
-         ("rust-mio-uds" ,rust-mio-uds)
-         ("rust-tokio-codec" ,rust-tokio-codec)
-         ("rust-tokio-io" ,rust-tokio-io)
-         ("rust-tokio-reactor" ,rust-tokio-reactor))
-        #:cargo-development-inputs
-        (("rust-tempfile" ,rust-tempfile)
-         ("rust-tokio" ,rust-tokio))))
-    (home-page "https://github.com/tokio-rs/tokio")
-    (synopsis "Unix Domain sockets for Tokio")
-    (description "Unix Domain sockets for Tokio")
-    (license license:expat)))
+        (("rust-glob" ,rust-glob)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-serde" ,rust-serde)
+         ("rust-serde-json" ,rust-serde-json)
+         ("rust-termcolor" ,rust-termcolor)
+         ("rust-toml" ,rust-toml))))
+    (home-page "https://github.com/dtolnay/trybuild")
+    (synopsis
+      "Test harness for ui tests of compiler diagnostics")
+    (description
+      "Test harness for ui tests of compiler diagnostics")
+    (license (list license:asl2.0
+                   license:expat))))
 
-(define-public rust-toml
+(define-public rust-typed-arena
   (package
-    (name "rust-toml")
-    (version "0.5.1")
+    (name "rust-typed-arena")
+    (version "1.5.0")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "toml" version))
+        (uri (crate-uri "typed-arena" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "0fdhfyv20qn29cxq1f9j9wav92c3qhxdm71sxfyzhzpsfdw6vjdq"))))
+            "0im62vrmyzbr8xq66bcyr86ka4z2x8psn9z4982bq4fc8v1zaw3z"))))
     (build-system cargo-build-system)
     (arguments
-      `(#:cargo-inputs
-        (("rust-linked-hash-map" ,rust-linked-hash-map)
-         ("rust-serde" ,rust-serde))
-        #:cargo-development-inputs
-        (("rust-serde-derive" ,rust-serde-derive)
-         ("rust-serde-json" ,rust-serde-json))))
+      `(#:cargo-development-inputs
+        (("rust-criterion" ,rust-byteorder))))
     (home-page
-      "https://github.com/alexcrichton/toml-rs")
+      "https://github.com/SimonSapin/rust-typed-arena")
     (synopsis
-      "A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.")
+      "The arena, a fast but limited type of allocator")
     (description
-      "A native Rust encoder and decoder of TOML-formatted files and streams. Provides implementations of the standard Serialize/Deserialize traits for TOML data to facilitate deserializing and serializing Rust structures.")
-    (license (list license:asl2.0
-                   license:expat))))
+      "The arena, a fast but limited type of allocator")
+    (license license:expat)))
 
-(define-public rust-tracing-core
+(define-public rust-typed-headers
   (package
-    (name "rust-tracing-core")
-    (version "0.1.2")
+    (name "rust-typed-headers")
+    (version "0.1.1")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "tracing-core" version))
+        (uri (crate-uri "typed-headers" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
           (base32
-            "01fa73wzw2m5ybi3kkd52dgrw97mgc3i6inmhwys46ab28giwnxi"))))
+            "0g40nlq5iw0zxhwb7nfmfbr9m86abgwwhxwhzrm10nfq6bsmlvxx"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-lazy-static" ,rust-lazy-static))))
-    (home-page "https://tokio.rs")
+        (("rust-base64" ,rust-base64)
+         ("rust-bytes" ,rust-bytes)
+         ("rust-chrono" ,rust-chrono)
+         ("rust-http" ,rust-http)
+         ("rust-mime" ,rust-mime))))
+    (home-page "https://github.com/sfackler/typed-headers")
     (synopsis
-      "Core primitives for application-level tracing.")
+      "Typed HTTP header serialization and deserialization.")
     (description
-      "Core primitives for application-level tracing.")
+      "Typed HTTP header serialization and deserialization.")
     (license (list license:asl2.0
                    license:expat))))
 
-(define-public rust-trybuild
+(define-public rust-typemap
   (package
-    (name "rust-trybuild")
-    (version "1.0.9")
+    (name "rust-typemap")
+    (version "0.3.3")
     (source
       (origin
         (method url-fetch)
-        (uri (crate-uri "trybuild" version))
+        (uri (crate-uri "typemap" version))
         (file-name
           (string-append name "-" version ".tar.gz"))
         (sha256
-          (base32
-            "0df6ipayif05xn61iavdb0dcshm9y6wmcd140pp7dl91mirygs7j"))))
+         (base32
+          "1xm1gbvz9qisj1l6d36hrl9pw8imr8ngs6qyanjnsad3h0yfcfv5"))))
     (build-system cargo-build-system)
     (arguments
       `(#:cargo-inputs
-        (("rust-glob" ,rust-glob)
-         ("rust-lazy-static" ,rust-lazy-static)
-         ("rust-serde" ,rust-serde)
-         ("rust-serde-json" ,rust-serde-json)
-         ("rust-termcolor" ,rust-termcolor)
-         ("rust-toml" ,rust-toml))))
-    (home-page "https://github.com/dtolnay/trybuild")
+        (("rust-unsafe-any" ,rust-base64))))
+    (home-page "https://github.com/reem/rust-typemap")
     (synopsis
-      "Test harness for ui tests of compiler diagnostics")
+      "A typesafe store for many value types.")
     (description
-      "Test harness for ui tests of compiler diagnostics")
-    (license (list license:asl2.0
-                   license:expat))))
+      "A typesafe store for many value types.")
+    (license license:expat)))
 
 (define-public rust-ucd-trie
   (package
@@ -7150,6 +10949,61 @@ writing colored text to a terminal.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-unicase
+  (package
+    (name "rust-unicase")
+    (version "2.4.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "unicase" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1xmpmkakhhblq7dzab1kwyv925kv7fqjkjsxjspg6ix9n88makm8"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs (("rust-version-check" ,rust-version-check))))
+    (home-page
+      "https://github.com/seanmonstar/unicase")
+    (synopsis
+      "A case-insensitive wrapper around strings.")
+    (description
+      "A case-insensitive wrapper around strings.")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-unicode-bidi
+  (package
+    (name "rust-unicode-bidi")
+    (version "0.3.4")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "unicode-bidi" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1malx8ljgm7v1gbaazkn7iicy5wj0bwcyadj3l727a38ch6bvwj9"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-matches" ,rust-matches)
+        ("rust-flame" ,rust-flame)
+        ("rust-flamer" ,rust-flamer)
+        ("rust-serde" ,rust-serde))
+       #:cargo-development-inputs
+       (("rust-serde-test" ,rust-serde-test))))
+    (home-page "https://github.com/servo/unicode-bidi")
+    (synopsis
+      "Implementation of the Unicode Bidirectional Algorithm")
+    (description
+      "Implementation of the Unicode Bidirectional Algorithm")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-unicode-normalization
   (package
     (name "rust-unicode-normalization")
@@ -7204,6 +11058,27 @@ writing colored text to a terminal.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-untrusted
+  (package
+    (name "rust-untrusted")
+    (version "0.7.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "untrusted" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1kmfykcwif6ashkwg54gcnhxj03kpba2i9vc7z5rpr0xlgvrwdk0"))))
+    (build-system cargo-build-system)
+    (home-page
+      "https://github.com/briansmith/untrusted")
+    (synopsis
+      "Safe, fast, zero-panic, zero-crashing, zero-allocation parsing of untrusted inputs in Rust.")
+    (description
+      "Safe, fast, zero-panic, zero-crashing, zero-allocation parsing of untrusted inputs in Rust.")
+    (license license:isc)))
+
 (define-public rust-url
   (package
     (name "rust-url")
@@ -7236,6 +11111,33 @@ writing colored text to a terminal.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-urlencoded
+  (package
+    (name "rust-urlencoded")
+    (version "0.6.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "urlencoded" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1qrkblcj3gpz256d5fci9g9ig20mxlavy25gj6p612qi740zalha"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-bodyparser" ,rust-bodyparser)
+         ("rust-iron" ,rust-iron)
+         ("rust-plugin" ,rust-plugin)
+         ("rust-url" ,rust-url))))
+    (home-page "https://github.com/iron/urlencoded")
+    (synopsis
+      "URL Encoded middleware for the Iron web framework. Decode URL Encoded data from GET request queries and POST request bodies.")
+    (description
+      "URL Encoded middleware for the Iron web framework. Decode URL Encoded data from GET request queries and POST request bodies.")
+    (license license:expat)))
+
 (define-public rust-utf8-ranges
   (package
     (name "rust-utf8-ranges")
@@ -7350,6 +11252,28 @@ writing colored text to a terminal.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-version-check
+  (package
+    (name "rust-version-check")
+    (version "0.9.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "version_check" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1kikqlnggii1rvnxrbls55sc46lxvinz5k3giscgncjj4p87b1q7"))))
+    (build-system cargo-build-system)
+    (home-page
+      "https://github.com/SergioBenitez/version_check")
+    (synopsis
+      "This tiny crate checks that the running or installed rustc meets some version requirements. The version is queried by calling the Rust compiler with --version. The path to the compiler is determined first via the RUSTC environment variable. If it is not set, then rustc is used. If that fails, no determination is made, and calls return None.")
+    (description
+      "This tiny crate checks that the running or installed rustc meets some version requirements. The version is queried by calling the Rust compiler with --version. The path to the compiler is determined first via the RUSTC environment variable. If it is not set, then rustc is used. If that fails, no determination is made, and calls return None.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-version-sync
   (package
     (name "rust-version-sync")
@@ -7377,11 +11301,32 @@ writing colored text to a terminal.")
     (home-page
       "https://github.com/mgeisler/version-sync")
     (synopsis
-      "Simple crate for ensuring that version numbers in README files are
-      updated when the crate version changes.")
+      "Simple crate for ensuring that version numbers in README files are
+      updated when the crate version changes.")
+    (description
+      "Simple crate for ensuring that version numbers in README files are
+      updated when the crate version changes.")
+    (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
+      "The uninhabited void type for use in statically impossible cases.")
     (description
-      "Simple crate for ensuring that version numbers in README files are
-      updated when the crate version changes.")
+      "The uninhabited void type for use in statically impossible cases.")
     (license license:expat)))
 
 (define-public rust-walkdir
@@ -7412,6 +11357,34 @@ writing colored text to a terminal.")
     (license (list license:unlicense
                    license:expat))))
 
+(define-public rust-want
+  (package
+    (name "rust-want")
+    (version "0.3.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "want" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "181b2zmwfq389x9n2g1n37cvcvvdand832zz6v8i1l8wrdlaks0w"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-log" ,rust-bytes)
+         ("rust-try-lock" ,rust-try-lock))
+        #:cargo-development-inputs
+        (("rust-tokio-executor" ,rust-tokio-executor)
+         ("rust-tokio-sync" ,rust-tokio-sync))))
+    (home-page "https://github.com/seanmonstar/want")
+    (synopsis
+      "Detect when another Future wants a result.")
+    (description
+      "Detect when another Future wants a result.")
+    (license license:expat)))
+
 (define-public rust-wasm-bindgen
   (package
     (name "rust-wasm-bindgen")
@@ -7473,6 +11446,44 @@ writing colored text to a terminal.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-wasm-bindgen-futures
+  (package
+    (name "rust-wasm-bindgen-futures")
+    (version "0.3.27")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "wasm-bindgen-futures" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "073p71skp91d9v2wczl6k7z9p0w25vn43br2v2g1ncbc6hvhnhl3"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-cfg-if" ,rust-cfg-if)
+         ("rust-futures" ,rust-futures)
+         ("rust-futures-channel-preview"
+          ,rust-futures-channel-preview)
+         ("rust-futures-util-preview"
+          ,rust-futures-util-preview)
+         ("rust-js-sys" ,rust-js-sys)
+         ("rust-lazy-static" ,rust-lazy-static)
+         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
+         ("rust-web-sys" ,rust-web-sys))
+        #:cargo-development-inputs
+        (("rust-wasm-bindgen-test"
+          ,rust-wasm-bindgen-test))))
+    (home-page
+      "https://rustwasm.github.io/wasm-bindgen/")
+    (synopsis
+      "Bridging the gap between Rust Futures and JavaScript Promises")
+    (description
+      "Bridging the gap between Rust Futures and JavaScript Promises")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-wasm-bindgen-macro
   (package
     (name "rust-wasm-bindgen-macro")
@@ -7598,6 +11609,128 @@ writing colored text to a terminal.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-wasm-bindgen-webidl
+  (package
+    (name "rust-wasm-bindgen-webidl")
+    (version "0.2.50")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "wasm-bindgen-webidl" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "057zak44nyrawipgi37m451fjkxz6ix5rzcw11d699rgpy4x4lxy"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-failure" ,rust-failure)
+         ("rust-heck" ,rust-heck)
+         ("rust-log" ,rust-log)
+         ("rust-proc-macro2" ,rust-proc-macro2)
+         ("rust-quote" ,rust-quote)
+         ("rust-syn" ,rust-syn)
+         ("rust-wasm-bindgen-backend"
+          ,rust-wasm-bindgen-backend)
+         ("rust-weedle" ,rust-weedle))))
+    (home-page
+      "https://rustwasm.github.io/wasm-bindgen/")
+    (synopsis
+      "Support for parsing WebIDL specific to wasm-bindgen")
+    (description
+      "Support for parsing WebIDL specific to wasm-bindgen")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-web-sys
+  (package
+    (name "rust-web-sys")
+    (version "0.3.27")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "web-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0lccdl3ihqh70s48dzvzpm09gpwvdjyw4wksk848dm0a41vw8db4"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-js-sys" ,rust-js-sys)
+         ("rust-wasm-bindgen" ,rust-wasm-bindgen))
+        #:cargo-development-inputs
+        (("rust-env-logger" ,rust-env-logger)
+         ("rust-failure" ,rust-failure)
+         ("rust-futures" ,rust-futures)
+         ("rust-sourcefile" ,rust-sourcefile)
+         ("rust-wasm-bindgen-futures"
+          ,rust-wasm-bindgen-futures)
+         ("rust-wasm-bindgen-test"
+          ,rust-wasm-bindgen-test)
+         ("rust-wasm-bindgen-webidl"
+          ,rust-wasm-bindgen-webidl))))
+    (home-page
+      "https://rustwasm.github.io/wasm-bindgen/web-sys/index.html")
+    (synopsis
+      "Bindings for all Web APIs, a procedurally generated crate from WebIDL")
+    (description
+      "Bindings for all Web APIs, a procedurally generated crate from WebIDL")
+    (license (list license:asl2.0
+                   license:expat))))
+
+(define-public rust-webpki
+  (package
+    (name "rust-webpki")
+    (version "0.21.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "webpki" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1d41gfai89q7drm92mgmh6fk57nikv2vqsa773i100dcf3kn9rnp"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-ring" ,rust-ring)
+         ("rust-untrusted" ,rust-untrusted))
+        #:cargo-development-inputs
+        (("rust-base64" ,rust-base64))))
+    (home-page "https://github.com/briansmith/webpki")
+    (synopsis
+      "webpki is a library that validates Web PKI (TLS/SSL) certificates. webpki is designed to provide a full implementation of the client side of the Web PKI to a diverse range of applications and devices, including embedded (IoT) applications, mobile apps, desktop applications, and server infrastructure. webpki is intended to not only be the best implementation of the Web PKI, but to also precisely define what the Web PKI is.")
+    (description
+      "webpki is a library that validates Web PKI (TLS/SSL) certificates. webpki is designed to provide a full implementation of the client side of the Web PKI to a diverse range of applications and devices, including embedded (IoT) applications, mobile apps, desktop applications, and server infrastructure. webpki is intended to not only be the best implementation of the Web PKI, but to also precisely define what the Web PKI is.")
+    (license license:isc))) ; I think
+
+(define-public rust-webpki-roots
+  (package
+    (name "rust-webpki-roots")
+    (version "0.17.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "webpki-roots" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "12vi8dh0yik0h4f0b9dnlw5i3gxyky7iblbksh6zcq4xvlvswqm2"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs (("rust-webpki" ,rust-webpki))))
+    (home-page "https://github.com/ctz/webpki-roots")
+    (synopsis
+      "Mozilla's CA root certificates for use with webpki")
+    (description
+      "Mozilla's CA root certificates for use with webpki")
+    (license license:mpl2.0)))
+
 (define-public rust-which
   (package
     (name "rust-which")
@@ -7626,6 +11759,49 @@ writing colored text to a terminal.")
       "This package provides a Rust equivalent of Unix command \"which\".  Locate installed execuable in cross platforms.")
     (license license:expat)))
 
+(define-public rust-widestring
+  (package
+    (name "rust-widestring")
+    (version "0.4.0")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "widestring" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "1dhx6dndjsz1y7c9w06922412kdxyrrkqblvggm76mh8z17hxz7g"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-development-inputs
+        (("rust-winapi" ,rust-winapi))))
+    (home-page "https://github.com/starkat99/widestring-rs.git")
+    (synopsis
+      "A wide string Rust FFI library for converting to and from wide strings, such as those often used in Windows API or other FFI libaries. Both UTF-16 and UTF-32 types are provided, including support for malformed encoding.")
+    (description
+      "A wide string Rust FFI library for converting to and from wide strings, such as those often used in Windows API or other FFI libaries. Both UTF-16 and UTF-32 types are provided, including support for malformed encoding.")
+    (license (list license:asl2.0
+                   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-winapi-util
   (package
     (name "rust-winapi-util")
@@ -7674,6 +11850,108 @@ winapi.")
     (license (list license:unlicense
                    license:expat))))
 
+(define-public rust-winreg
+  (package
+    (name "rust-winreg")
+    (version "0.6.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "winreg" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "1jdcqr6zmvwyrp87h48miasfdvv16gjsb60rc8dy2kqwb3mnv65j"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-winapi" ,rust-winapi)
+         ("rust-chrono" ,rust-chrono)
+         ("rust-serde" ,rust-serde))
+        #:cargo-development-inputs
+        (("rust-rand" ,rust-rand-0.3)
+         ("rust-serde-derive" ,rust-serde-derive))))
+    (home-page "https://github.com/gentoo90/winreg-rs")
+    (synopsis
+      "Rust bindings to MS Windows Registry API.")
+    (description
+      "Rust bindings to MS Windows Registry API.")
+    (license license:expat)))
+
+(define-public rust-winutil
+  (package
+    (name "rust-winutil")
+    (version "0.1.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "winutil" version))
+        (file-name (string-append name "-" version ".tar.gz"))
+        (sha256
+         (base32
+          "0vkyl3fbbf05n5ph5yz8sfaccrk9x3qsr25560w6w68ldf5i7bvx"))))
+    (build-system cargo-build-system)
+    (arguments
+     `(#:cargo-inputs
+       (("rust-winapi" ,rust-winapi))))
+    (home-page "https://bitbucket.org/DaveLancaster/winutil")
+    (synopsis "A simple library wrapping a handful of useful winapi functions.")
+    (description
+      "A simple library wrapping a handful of useful winapi functions.")
+    (license license:expat)))
+
+(define-public rust-ws2-32-sys
+  (package
+    (name "rust-ws2-32-sys")
+    (version "0.2.1")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "ws2_32-sys" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0ppscg5qfqaw0gzwv2a4nhn5bn01ff9iwn6ysqnzm4n8s3myz76m"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-winapi" ,rust-winapi)
+         ("rust-winapi-build" ,rust-winapi-build))))
+    (home-page "https://github.com/retep998/winapi-rs")
+    (synopsis
+      "Contains function definitions for the Windows API library ws2_32.")
+    (description
+      "Contains function definitions for the Windows API library ws2_32.")
+    (license license:expat)))
+
+(define-public rust-xattr
+  (package
+    (name "rust-xattr")
+    (version "0.2.2")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "xattr" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0k556fb6f5jc907975j9c8iynl2fqz3rf0w6fiig83i4yi0kfk14"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-libc" ,rust-libc))
+        #:cargo-development-inputs
+        (("rust-tempfile" ,rust-tempfile))))
+    (home-page
+      "https://github.com/Stebalien/xattr")
+    (synopsis "unix extended filesystem attributes")
+    (description "unix extended filesystem attributes")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-xdg
   (package
     (name "rust-xdg")
@@ -7697,6 +11975,40 @@ winapi.")
     (license (list license:asl2.0
                    license:expat))))
 
+(define-public rust-xz2
+  (package
+    (name "rust-xz2")
+    (version "0.1.6")
+    (source
+      (origin
+        (method url-fetch)
+        (uri (crate-uri "xz2" version))
+        (file-name
+          (string-append name "-" version ".tar.gz"))
+        (sha256
+          (base32
+            "0v4jb0193gx8s1kvd2ajsgh0ffmwhqhfmrrw1n1h2z7w6jgqcyf1"))))
+    (build-system cargo-build-system)
+    (arguments
+      `(#:cargo-inputs
+        (("rust-futures" ,rust-futures)
+         ("rust-lzma-sys" ,rust-lzma-sys)
+         ("rust-tokio-io" ,rust-tokio-io))
+        #:cargo-development-inputs
+        (("rust-quickcheck" ,rust-quickcheck)
+         ("rust-rand" ,rust-rand)
+         ("rust-tokio-core" ,rust-tokio-core))))
+    (home-page
+      "https://github.com/alexcrichton/xz2-rs")
+    (synopsis
+      "Rust bindings to liblzma providing Read/Write streams as well as low-level
+      in-memory encoding/decoding.")
+    (description
+      "Rust bindings to liblzma providing Read/Write streams as well as low-level
+      in-memory encoding/decoding.")
+    (license (list license:asl2.0
+                   license:expat))))
+
 (define-public rust-yaml-rust
   (package
     (name "rust-yaml-rust")
diff --git a/gn/packages/genenetwork.scm b/gn/packages/genenetwork.scm
index 7773fa5..dbd3abc 100644
--- a/gn/packages/genenetwork.scm
+++ b/gn/packages/genenetwork.scm
@@ -248,11 +248,11 @@ location of a putative QTL.")
     (license license:gpl2+))))
 
 (define-public rust-qtlreaper
-  (let ((commit "eacf6ff1c3d1cd16084a70a7a425bd77080c15de")
+  (let ((commit "2e7fed6d45b0b602d80fa2a55835f96ef1cba9e3")
         (revision "1"))
     (package
       (name "rust-qtlreaper")
-      (version (git-version "0.1.3" revision commit))
+      (version "0.1.4")
       (source
         (origin
           (method git-fetch)
@@ -262,7 +262,7 @@ location of a putative QTL.")
           (file-name (git-file-name name version))
           (sha256
            (base32
-            "0gr2z54i11zz94ra4w06fhfnwnmmhl5xyc8qhlk0v2qq18yfi7ji"))))
+            "0h70aalsplmc6xn1w7ha102n3bsi3gqkbnbrjvjm2za37c07gv0g"))))
       (build-system cargo-build-system)
       (arguments
        `(#:cargo-inputs
@@ -270,7 +270,8 @@ location of a putative QTL.")
           ("rust-structopt" ,rust-structopt)
           ("rust-rayon" ,rust-rayon-1.0)
           ("rust-serde" ,rust-serde)
-          ("rust-serde-json" ,rust-serde-json))))
+          ("rust-serde-json" ,rust-serde-json)
+          ("rust-ndarray" ,rust-ndarray))))
       (home-page "https://github.com/chfi/rust-qtlreaper")
       (synopsis "Reimplementation of genenetwork/QTLReaper in Rust")
       (description "Reimplementation of genenetwork/QTLReaper in Rust")
-- 
cgit v1.2.3