(define-module (hello-cli)
  #:use-module (guix build-system cargo)
  #:use-module (guix download)
  #:use-module ((guix licenses) #:prefix license:)
  #:use-module (guix packages))

(define-public rust-hello-cli
  (package
    (name "rust-hello-cli")
    (version "0.2.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "hello-cli" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0qilj9b94ig7z160kazk41k2iy1hprdk5qwaym4fnf5x9fiksild"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-clap" ,rust-clap))))
    (home-page
      "https://github.com/fpoli/rust-hello-cli")
    (synopsis "Prints a nice 'Hello World!' message")
    (description
      "Prints a nice 'Hello World!' message")
    (license license:expat)))

(define-public rust-clap
  (package
    (name "rust-clap")
    (version "2.33.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "clap" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1nf6ld3bims1n5vfzhkvcb55pdzh04bbhzf8nil5vvw05nxzarsh"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-ansi-term-0.11.0" ,rust-ansi-term-0.11.0)
         ("rust-atty" ,rust-atty)
         ("rust-bitflags" ,rust-bitflags)
         ("rust-clippy" ,rust-clippy)
         ("rust-strsim-0.8.0" ,rust-strsim-0.8.0)
         ("rust-term-size-0.3.1" ,rust-term-size-0.3.1)
         ("rust-textwrap" ,rust-textwrap)
         ("rust-unicode-width" ,rust-unicode-width)
         ("rust-vec-map" ,rust-vec-map)
         ("rust-yaml-rust-0.3.5" ,rust-yaml-rust-0.3.5))))
    (home-page "https://clap.rs/")
    (synopsis
      "A simple to use, efficient, and full-featured Command Line Argument Parser
")
    (description
      "This package provides a simple to use, efficient, and full-featured Command Line Argument Parser
")
    (license license:expat)))

(define-public rust-bitflags
  (package
    (name "rust-bitflags")
    (version "1.2.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "bitflags" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "14qnd5nq8p2almk79m4m8ydqhd413yaxsyjp5xd19g3mikzf47fg"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/bitflags/bitflags")
    (synopsis
      "A macro to generate structures which behave like bitflags.
")
    (description
      "This package provides a macro to generate structures which behave like bitflags.
")
    (license #f)))

(define-public rust-textwrap
  (package
    (name "rust-textwrap")
    (version "0.11.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "textwrap" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0q5hky03ik3y50s9sz25r438bc4nwhqc6dqwynv4wylc807n29nk"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-hyphenation" ,rust-hyphenation)
         ("rust-term-size-0.3.1" ,rust-term-size-0.3.1)
         ("rust-unicode-width" ,rust-unicode-width))))
    (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.
")
    (license license:expat)))

(define-public rust-unicode-width
  (package
    (name "rust-unicode-width")
    (version "0.1.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "unicode-width" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "082f9hv1r3gcd1xl33whjhrm18p0w9i77zhhhkiccb5r47adn1vh"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-compiler-builtins"
          ,rust-compiler-builtins)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core)
         ("rust-rustc-std-workspace-std"
          ,rust-rustc-std-workspace-std))))
    (home-page
      "https://github.com/unicode-rs/unicode-width")
    (synopsis
      "Determine displayed width of `char` and `str` types
according to Unicode Standard Annex #11 rules.
")
    (description
      "Determine displayed width of `char` and `str` types
according to Unicode Standard Annex #11 rules.
")
    (license #f)))

(define-public rust-ansi-term-0.11.0
  (package
    (name "rust-ansi-term")
    (version "0.11.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "ansi_term" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "16wpvrghvd0353584i1idnsgm0r3vchg8fyrm0x8ayv1rgvbljgf"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-winapi" ,rust-winapi))))
    (home-page
      "https://github.com/ogham/rust-ansi-term")
    (synopsis
      "Library for ANSI terminal colours and styles (bold, underline)")
    (description
      "Library for ANSI terminal colours and styles (bold, underline)")
    (license license:expat)))

(define-public rust-atty
  (package
    (name "rust-atty")
    (version "0.2.13")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "atty" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "140sswp1bwqwc4zk80bxkbnfb3g936hgrb77g9g0k1zcld3wc0qq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-libc" ,rust-libc)
         ("rust-winapi" ,rust-winapi))))
    (home-page "https://github.com/softprops/atty")
    (synopsis "A simple interface for querying atty")
    (description
      "This package provides a simple interface for querying atty")
    (license license:expat)))

(define-public rust-clippy
  (package
    (name "rust-clippy")
    (version "0.0.302")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "clippy" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1562x3sq9mgmc8j39gd34wqm7ybrdvpmj7cc1n450gwsawayw4fr"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-term-0.5.2" ,rust-term-0.5.2))))
    (home-page
      "https://github.com/rust-lang-nursery/rust-clippy")
    (synopsis
      "A bunch of helpful lints to avoid common pitfalls in Rust.")
    (description
      "This package provides a bunch of helpful lints to avoid common pitfalls in Rust.")
    (license #f)))

(define-public rust-strsim-0.8.0
  (package
    (name "rust-strsim")
    (version "0.8.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "strsim" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0sjsm7hrvjdifz661pjxq5w4hf190hx53fra8dfvamacvff139cf"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/dguo/strsim-rs")
    (synopsis
      "Implementations of string similarity metrics.
Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, and Jaro-Winkler.
")
    (description
      "Implementations of string similarity metrics.
Includes Hamming, Levenshtein, OSA, Damerau-Levenshtein, Jaro, and Jaro-Winkler.
")
    (license license:expat)))

(define-public rust-term-size-0.3.1
  (package
    (name "rust-term-size")
    (version "0.3.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "term_size" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "09wk3173ngmb710qs9rwgibq4w250q8lgnwjvb9cypc1vdk9lnwy"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-clippy" ,rust-clippy)
         ("rust-kernel32-sys" ,rust-kernel32-sys)
         ("rust-libc" ,rust-libc)
         ("rust-winapi-0.2.8" ,rust-winapi-0.2.8))))
    (home-page
      "https://github.com/kbknapp/term_size-rs.git")
    (synopsis
      "functions for determining terminal sizes and dimensions")
    (description
      "functions for determining terminal sizes and dimensions")
    (license #f)))

(define-public rust-vec-map
  (package
    (name "rust-vec-map")
    (version "0.8.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "vec_map" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "06n8hw4hlbcz328a3gbpvmy0ma46vg1lc0r5wf55900szf3qdiq5"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/contain-rs/vec-map")
    (synopsis
      "A simple map based on a vector for small integer keys")
    (description
      "This package provides a simple map based on a vector for small integer keys")
    (license #f)))

(define-public rust-yaml-rust-0.3.5
  (package
    (name "rust-yaml-rust")
    (version "0.3.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "yaml-rust" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "14m9dzwb8fb05f4jjb4nqp49rxd9c5vcmwpv3a04d2y5iphncqz6"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-clippy" ,rust-clippy)
         ("rust-linked-hash-map-0.3.0"
          ,rust-linked-hash-map-0.3.0))))
    (home-page
      "http://chyh1990.github.io/yaml-rust/")
    (synopsis "The missing YAML 1.2 parser for rust")
    (description
      "The missing YAML 1.2 parser for rust")
    (license #f)))

(define-public rust-hyphenation
  (package
    (name "rust-hyphenation")
    (version "0.7.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "hyphenation" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0k5msv8calmnfd5kw1rmq4bg5hn1vcd39kbsxl57sdld63xwd4q4"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-atlatl" ,rust-atlatl)
         ("rust-atlatl" ,rust-atlatl)
         ("rust-bincode" ,rust-bincode)
         ("rust-bincode" ,rust-bincode)
         ("rust-hyphenation-commons"
          ,rust-hyphenation-commons)
         ("rust-hyphenation-commons"
          ,rust-hyphenation-commons)
         ("rust-pocket-resources" ,rust-pocket-resources)
         ("rust-serde" ,rust-serde)
         ("rust-serde" ,rust-serde)
         ("rust-unicode-normalization"
          ,rust-unicode-normalization))))
    (home-page
      "https://github.com/tapeinosyne/hyphenation")
    (synopsis
      "Knuth-Liang hyphenation for a variety of languages")
    (description
      "Knuth-Liang hyphenation for a variety of languages")
    (license #f)))

(define-public rust-compiler-builtins
  (package
    (name "rust-compiler-builtins")
    (version "0.1.21")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "compiler_builtins" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "08z14y5yc4cxy2d57aaa83cp46xf7yx83y57jg785dd5fv9j1ifk"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cc" ,rust-cc)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core))))
    (home-page
      "https://github.com/rust-lang/compiler-builtins")
    (synopsis
      "Compiler intrinsics used by the Rust compiler. Also available for other targets
if necessary!
")
    (description
      "Compiler intrinsics used by the Rust compiler.  Also available for other targets
if necessary!
")
    (license #f)))

(define-public rust-rustc-std-workspace-core
  (package
    (name "rust-rustc-std-workspace-core")
    (version "1.0.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rustc-std-workspace-core" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1309xhwyai9xpz128xrfjqkmnkvgjwddznmj7brbd8i8f58zamhr"))))
    (build-system cargo-build-system)
    (home-page "")
    (synopsis
      "Explicitly empty crate for rust-lang/rust integration
")
    (description
      "Explicitly empty crate for rust-lang/rust integration
")
    (license #f)))

(define-public rust-rustc-std-workspace-std
  (package
    (name "rust-rustc-std-workspace-std")
    (version "1.0.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rustc-std-workspace-std" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1vq4vaclamwhk0alf4f7wq3i9wxa993sxpmhy6qfaimy1ai7d9mb"))))
    (build-system cargo-build-system)
    (home-page "")
    (synopsis "Workaround for rustbuild")
    (description "Workaround for rustbuild")
    (license #f)))

(define-public rust-winapi
  (package
    (name "rust-winapi")
    (version "0.3.8")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "winapi" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1ii9j9lzrhwri0902652awifzx9fpayimbp6hfhhc296xcg0k4w0"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-winapi-i686-pc-windows-gnu"
          ,rust-winapi-i686-pc-windows-gnu)
         ("rust-winapi-x86-64-pc-windows-gnu"
          ,rust-winapi-x86-64-pc-windows-gnu))))
    (home-page
      "https://github.com/retep998/winapi-rs")
    (synopsis
      "Raw FFI bindings for all of Windows API.")
    (description
      "Raw FFI bindings for all of Windows API.")
    (license #f)))

(define-public rust-libc
  (package
    (name "rust-libc")
    (version "0.2.66")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "libc" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0n0mwry21fxfwc063k33mvxk8xj7ia5ar8m42c9ymbam2ksb25fm"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core))))
    (home-page "https://github.com/rust-lang/libc")
    (synopsis
      "Raw FFI bindings to platform libraries like libc.
")
    (description
      "Raw FFI bindings to platform libraries like libc.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-term-0.5.2
  (package
    (name "rust-term")
    (version "0.5.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "term" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0hkgjrfisj6zjwz525639pmsvzhlc48a0h65nw87qrdp6jihdlgd"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-byteorder" ,rust-byteorder)
         ("rust-dirs-1.0.5" ,rust-dirs-1.0.5)
         ("rust-winapi" ,rust-winapi))))
    (home-page "https://github.com/Stebalien/term")
    (synopsis "A terminal formatting library
")
    (description
      "This package provides a terminal formatting library
")
    (license #f)))

(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 ".crate"))
        (sha256
          (base32
            "1389av0601a9yz8dvx5zha9vmkd6ik7ax0idpb032d28555n41vm"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-winapi-0.2.8" ,rust-winapi-0.2.8)
         ("rust-winapi-build" ,rust-winapi-build))))
    (home-page
      "https://github.com/retep998/winapi-rs")
    (synopsis
      "Contains function definitions for the Windows API library kernel32. See winapi for types and constants.")
    (description
      "Contains function definitions for the Windows API library kernel32.  See winapi for types and constants.")
    (license license:expat)))

(define-public rust-winapi-0.2.8
  (package
    (name "rust-winapi")
    (version "0.2.8")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "winapi" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0yh816lh6lf56dpsgxy189c2ai1z3j8mw9si6izqb6wsjkbcjz8n"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/retep998/winapi-rs")
    (synopsis
      "Raw FFI bindings for all of Windows API.")
    (description
      "Raw FFI bindings for all of Windows API.")
    (license license:expat)))

(define-public rust-serde
  (package
    (name "rust-serde")
    (version "1.0.103")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "serde" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "00ip3xy09nk6c2b47ky1m5379yjmwk6n3sr2vmblp478p1xgj5qj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-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:expat license:asl2.0))))

(define-public rust-linked-hash-map-0.3.0
  (package
    (name "rust-linked-hash-map")
    (version "0.3.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "linked-hash-map" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1kaf95grvfqchxn8pl0854g8ab0fzl56217hndhhhz5qqm2j09kd"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-clippy" ,rust-clippy)
         ("rust-serde-0.8.23" ,rust-serde-0.8.23)
         ("rust-serde-test-0.8.23"
          ,rust-serde-test-0.8.23))))
    (home-page
      "https://github.com/contain-rs/linked-hash-map")
    (synopsis
      "A HashMap wrapper that holds key-value pairs in insertion order")
    (description
      "This package provides a HashMap wrapper that holds key-value pairs in insertion order")
    (license #f)))

(define-public rust-atlatl
  (package
    (name "rust-atlatl")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "atlatl" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "18kyvdm56fdb52b1sryi80xgs3nkjdylynsv324aiqnj85l1bfrj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-fnv" ,rust-fnv)
         ("rust-num-traits" ,rust-num-traits)
         ("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/tapeinosyne/atlatl")
    (synopsis "Double-array tries.")
    (description "Double-array tries.")
    (license #f)))

(define-public rust-atlatl
  (package
    (name "rust-atlatl")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "atlatl" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "18kyvdm56fdb52b1sryi80xgs3nkjdylynsv324aiqnj85l1bfrj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-fnv" ,rust-fnv)
         ("rust-num-traits" ,rust-num-traits)
         ("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/tapeinosyne/atlatl")
    (synopsis "Double-array tries.")
    (description "Double-array tries.")
    (license #f)))

(define-public rust-bincode
  (package
    (name "rust-bincode")
    (version "1.2.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "bincode" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "14jzj61c145s9jwr1i213b7mdcmv1ny4z1lns9s8gvp34j9n7axq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-byteorder" ,rust-byteorder)
         ("rust-serde" ,rust-serde))))
    (home-page "https://github.com/servo/bincode")
    (synopsis
      "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!")
    (description
      "This package provides a binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!")
    (license license:expat)))

(define-public rust-bincode
  (package
    (name "rust-bincode")
    (version "1.2.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "bincode" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "14jzj61c145s9jwr1i213b7mdcmv1ny4z1lns9s8gvp34j9n7axq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-byteorder" ,rust-byteorder)
         ("rust-serde" ,rust-serde))))
    (home-page "https://github.com/servo/bincode")
    (synopsis
      "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!")
    (description
      "This package provides a binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!")
    (license license:expat)))

(define-public rust-hyphenation-commons
  (package
    (name "rust-hyphenation-commons")
    (version "0.7.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "hyphenation_commons" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1pasnbk3rbdgf30jjjh1h24a9pxpdrnn0ihcivmpnzqha6mn2d4y"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-atlatl" ,rust-atlatl)
         ("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/tapeinosyne/hyphenation")
    (synopsis
      "Proemial code for the `hyphenation` library")
    (description
      "Proemial code for the `hyphenation` library")
    (license #f)))

(define-public rust-hyphenation-commons
  (package
    (name "rust-hyphenation-commons")
    (version "0.7.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "hyphenation_commons" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1pasnbk3rbdgf30jjjh1h24a9pxpdrnn0ihcivmpnzqha6mn2d4y"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-atlatl" ,rust-atlatl)
         ("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/tapeinosyne/hyphenation")
    (synopsis
      "Proemial code for the `hyphenation` library")
    (description
      "Proemial code for the `hyphenation` library")
    (license #f)))

(define-public rust-pocket-resources
  (package
    (name "rust-pocket-resources")
    (version "0.3.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "pocket-resources" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1n2i5vmi8fdbw89wm5nz1ws1z9f1qax911p6ksg4scmdg23z6df1"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/tomaka/pocket-resources")
    (synopsis
      "Include resources in your applications.")
    (description
      "Include resources in your applications.")
    (license license:expat)))

(define-public rust-unicode-normalization
  (package
    (name "rust-unicode-normalization")
    (version "0.1.11")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "unicode-normalization" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1kxxb5ndb5dzyp1flajjdxnbwyjw6ml9xvy0pz7b8srjn9ky4qdm"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-smallvec" ,rust-smallvec))))
    (home-page
      "https://github.com/unicode-rs/unicode-normalization")
    (synopsis
      "This crate provides functions for normalization of
Unicode strings, including Canonical and Compatible
Decomposition and Recomposition, as described in
Unicode Standard Annex #15.
")
    (description
      "This crate provides functions for normalization of
Unicode strings, including Canonical and Compatible
Decomposition and Recomposition, as described in
Unicode Standard Annex #15.
")
    (license #f)))

(define-public rust-cc
  (package
    (name "rust-cc")
    (version "1.0.47")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "cc" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1f08560cwbalni1fc2jcmh1dszl3rc31azvr45bgz8vhrs6hb1xa"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-jobserver" ,rust-jobserver)
         ("rust-num-cpus" ,rust-num-cpus))))
    (home-page
      "https://github.com/alexcrichton/cc-rs")
    (synopsis
      "A build-time dependency for Cargo build scripts to assist in invoking the native
C compiler to compile native C code into a static archive to be linked into Rust
code.
")
    (description
      "This package provides a build-time dependency for Cargo build scripts to assist in invoking the native
C compiler to compile native C code into a static archive to be linked into Rust
code.
")
    (license #f)))

(define-public rust-winapi-i686-pc-windows-gnu
  (package
    (name "rust-winapi-i686-pc-windows-gnu")
    (version "0.4.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "winapi-i686-pc-windows-gnu" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1dmpa6mvcvzz16zg6d5vrfy4bxgg541wxrcip7cnshi06v38ffxc"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/retep998/winapi-rs")
    (synopsis
      "Import libraries for the i686-pc-windows-gnu target. Please don't use this crate directly, depend on winapi instead.")
    (description
      "Import libraries for the i686-pc-windows-gnu target.  Please don't use this crate directly, depend on winapi instead.")
    (license #f)))

(define-public rust-winapi-x86-64-pc-windows-gnu
  (package
    (name "rust-winapi-x86-64-pc-windows-gnu")
    (version "0.4.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri
               "winapi-x86_64-pc-windows-gnu"
               version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0gqq64czqb64kskjryj8isp62m2sgvx25yyj3kpc2myh85w24bki"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/retep998/winapi-rs")
    (synopsis
      "Import libraries for the x86_64-pc-windows-gnu target. Please don't use this crate directly, depend on winapi instead.")
    (description
      "Import libraries for the x86_64-pc-windows-gnu target.  Please don't use this crate directly, depend on winapi instead.")
    (license #f)))

(define-public rust-byteorder
  (package
    (name "rust-byteorder")
    (version "1.3.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "byteorder" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1xbwjlmq2ziqjmjvkqxdx1yh136xxhilxd40bky1w4d7hn4xvhx7"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/BurntSushi/byteorder")
    (synopsis
      "Library for reading/writing numbers in big-endian and little-endian.")
    (description
      "Library for reading/writing numbers in big-endian and little-endian.")
    (license (list license:unlicense license:expat))))

(define-public rust-dirs-1.0.5
  (package
    (name "rust-dirs")
    (version "1.0.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "dirs" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "009rrhzj9pxyncmm2vhlj70npg0cgggv2hjbbkiwdl9vccq8kmrz"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-libc" ,rust-libc)
         ("rust-redox-users" ,rust-redox-users)
         ("rust-winapi" ,rust-winapi))))
    (home-page "https://github.com/soc/dirs-rs")
    (synopsis
      "A tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms defined by the XDG base/user directory specifications on Linux, the Known Folder API on Windows, and the Standard Directory guidelines on macOS.")
    (description
      "This package provides a tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms defined by the XDG base/user directory specifications on Linux, the Known Folder API on Windows, and the Standard Directory guidelines on macOS.")
    (license (list license:expat license:asl2.0))))

(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 ".crate"))
        (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-serde-derive
  (package
    (name "rust-serde-derive")
    (version "1.0.103")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "serde_derive" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1l2icqq548dmq5bn278zb2vj725znj4h4ms89w3b0r1fkbpzmim8"))))
    (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://serde.rs")
    (synopsis
      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
    (description
      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
    (license (list license:expat license:asl2.0))))

(define-public rust-serde-0.8.23
  (package
    (name "rust-serde")
    (version "0.8.23")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "serde" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1j4ajipn0sf4ya0crgcb94s848qp7mfc35n6d0q2rf8rk5skzbcx"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-clippy" ,rust-clippy))))
    (home-page "https://serde.rs")
    (synopsis
      "A generic serialization/deserialization framework")
    (description
      "This package provides a generic serialization/deserialization framework")
    (license #f)))

(define-public rust-serde-test-0.8.23
  (package
    (name "rust-serde-test")
    (version "0.8.23")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "serde_test" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1m939j7cgs7i58r6vxf0ffp3nbr8advr8p9dqa9w8zk0z2yks2qi"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-serde-0.8.23" ,rust-serde-0.8.23))))
    (home-page "https://serde.rs")
    (synopsis
      "Token De/Serializer for testing De/Serialize implementations")
    (description
      "Token De/Serializer for testing De/Serialize implementations")
    (license #f)))

(define-public rust-fnv
  (package
    (name "rust-fnv")
    (version "1.0.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "fnv" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1ww56bi1r5b8id3ns9j3qxbi7w5h005rzhiryy0zi9h97raqbb9g"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/servo/rust-fnv")
    (synopsis
      "Fowlerâ\x80\x93Nollâ\x80\x93Vo hash function")
    (description
      "Fowlerâ\x80\x93Nollâ\x80\x93Vo hash function")
    (license #f)))

(define-public rust-num-traits
  (package
    (name "rust-num-traits")
    (version "0.2.10")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "num-traits" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1r079jbmrnrbvsz7dc5mcghijx7bhpfikjspfqrgl4n227y1zj6l"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-libm" ,rust-libm))))
    (home-page
      "https://github.com/rust-num/num-traits")
    (synopsis
      "Numeric traits for generic mathematics")
    (description
      "Numeric traits for generic mathematics")
    (license #f)))

(define-public rust-autocfg
  (package
    (name "rust-autocfg")
    (version "0.1.7")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "autocfg" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1chwgimpx5z7xbag7krr9d8asxfqbh683qhgl9kn3hxk2l0djj8x"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/cuviper/autocfg")
    (synopsis
      "Automatic cfg for Rust compiler features")
    (description
      "Automatic cfg for Rust compiler features")
    (license #f)))

(define-public rust-smallvec
  (package
    (name "rust-smallvec")
    (version "1.0.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "smallvec" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "11pwzjbkiw1jsy1q4w8bws3r61sk27dsp9asankvm2lfys2kpksf"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/servo/rust-smallvec")
    (synopsis
      "'Small vector' optimization: store up to a small number of items on the stack")
    (description
      "'Small vector' optimization: store up to a small number of items on the stack")
    (license #f)))

(define-public rust-jobserver
  (package
    (name "rust-jobserver")
    (version "0.1.17")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "jobserver" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0q61p39nw0bdx6w0wkjv1kcha5mbhcfdl4z1hxrhpcskyhpd9cgj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-getrandom" ,rust-getrandom)
         ("rust-libc" ,rust-libc)
         ("rust-log" ,rust-log))))
    (home-page
      "https://github.com/alexcrichton/jobserver-rs")
    (synopsis
      "An implementation of the GNU make jobserver for Rust
")
    (description
      "An implementation of the GNU make jobserver for Rust
")
    (license #f)))

(define-public rust-num-cpus
  (package
    (name "rust-num-cpus")
    (version "1.11.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "num_cpus" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0wlxs00cpg16z09fwchj1gdz1jxnf5dgg1cbidvq0sc75bnwbnkn"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-hermit-abi" ,rust-hermit-abi)
         ("rust-libc" ,rust-libc))))
    (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 #f)))

(define-public rust-redox-users
  (package
    (name "rust-redox-users")
    (version "0.3.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "redox_users" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0vdn688q9wg997b1x5abx2gf7406rn1lvd62ypcgh1gj7g5dpkjf"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-failure" ,rust-failure)
         ("rust-rand-os-0.1.3" ,rust-rand-os-0.1.3)
         ("rust-redox-syscall" ,rust-redox-syscall)
         ("rust-rust-argon2-0.5.1"
          ,rust-rust-argon2-0.5.1))))
    (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 license:expat)))

(define-public rust-proc-macro2
  (package
    (name "rust-proc-macro2")
    (version "1.0.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "proc-macro2" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "09rgb5ab0jgw39kyad0lgqs4nb9yaf7mwcrgxqnsxbn4il54g7lw"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-unicode-xid" ,rust-unicode-xid))))
    (home-page
      "https://github.com/alexcrichton/proc-macro2")
    (synopsis
      "A stable implementation of the upcoming new `proc_macro` API. Comes with an
option, off by default, to also reimplement itself in terms of the upstream
unstable API.
")
    (description
      "This package provides a stable implementation of the upcoming new `proc_macro` API.  Comes with an
option, off by default, to also reimplement itself in terms of the upstream
unstable API.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-quote
  (package
    (name "rust-quote")
    (version "1.0.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "quote" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1zkc46ryacf2jdkc6krsy2z615xbk1x8kp1830rcxz3irj5qqfh5"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2" ,rust-proc-macro2))))
    (home-page "https://github.com/dtolnay/quote")
    (synopsis "Quasi-quoting macro quote!(...)")
    (description "Quasi-quoting macro quote!(...)")
    (license (list license:expat license:asl2.0))))

(define-public rust-syn
  (package
    (name "rust-syn")
    (version "1.0.9")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "syn" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1h67q2bhp44zpkahdq3wz71vzy35s3ibv5pxjgggh0aj06p975pq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2" ,rust-proc-macro2)
         ("rust-quote" ,rust-quote)
         ("rust-unicode-xid" ,rust-unicode-xid))))
    (home-page "https://github.com/dtolnay/syn")
    (synopsis "Parser for Rust source code")
    (description "Parser for Rust source code")
    (license (list license:expat license:asl2.0))))

(define-public rust-libm
  (package
    (name "rust-libm")
    (version "0.2.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "libm" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0akh56sh51adhagmk9l84dyrlz60gv8ri05xhr13i1b18czkpmy7"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rand-0.6.5" ,rust-rand-0.6.5))))
    (home-page "https://github.com/rust-lang/libm")
    (synopsis "libm in pure Rust")
    (description "libm in pure Rust")
    (license (list license:expat license:asl2.0))))

(define-public rust-getrandom
  (package
    (name "rust-getrandom")
    (version "0.1.13")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "getrandom" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "01zlzhdbg8y6d1zrlihvm93s421g0nldiq7f1hch3kfl9slprnz7"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cfg-if" ,rust-cfg-if)
         ("rust-compiler-builtins"
          ,rust-compiler-builtins)
         ("rust-libc" ,rust-libc)
         ("rust-log" ,rust-log)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core)
         ("rust-stdweb" ,rust-stdweb)
         ("rust-wasi" ,rust-wasi)
         ("rust-wasm-bindgen" ,rust-wasm-bindgen))))
    (home-page
      "https://github.com/rust-random/getrandom")
    (synopsis
      "A small cross-platform library for retrieving random data from system source")
    (description
      "This package provides a small cross-platform library for retrieving random data from system source")
    (license (list license:expat license:asl2.0))))

(define-public rust-log
  (package
    (name "rust-log")
    (version "0.4.8")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "log" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1xz18ixccl5c6np4linv3ypc7hpmmgpc5zzd2ymp2ssfx0mhbdhl"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cfg-if" ,rust-cfg-if)
         ("rust-serde" ,rust-serde)
         ("rust-sval" ,rust-sval))))
    (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:expat license:asl2.0))))

(define-public rust-hermit-abi
  (package
    (name "rust-hermit-abi")
    (version "0.1.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "hermit-abi" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "087ibb7v4dxhx1h66jjffk4zrjlhy3n4fr0x9d9y6f3zjfgkqz1h"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-compiler-builtins"
          ,rust-compiler-builtins)
         ("rust-libc" ,rust-libc)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core))))
    (home-page
      "https://github.com/hermitcore/hermit-abi")
    (synopsis
      "hermit-abi is small interface to call functions from the unikernel RustyHermit.
It is used to build the target `x86_64-unknown-hermit`.
")
    (description
      "hermit-abi is small interface to call functions from the unikernel RustyHermit.
It is used to build the target `x86_64-unknown-hermit`.
")
    (license #f)))

(define-public rust-failure
  (package
    (name "rust-failure")
    (version "0.1.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "failure" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1nay5c2cgi40kp84rbiir1dgwlh9aap9jazbnxfmqrkpr49ky9zq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-backtrace" ,rust-backtrace)
         ("rust-failure-derive" ,rust-failure-derive))))
    (home-page
      "https://rust-lang-nursery.github.io/failure/")
    (synopsis
      "Experimental error handling abstraction.")
    (description
      "Experimental error handling abstraction.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rand-os-0.1.3
  (package
    (name "rust-rand-os")
    (version "0.1.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rand_os" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0wahppm0s64gkr2vmhcgwc0lij37in1lgfxg5rbgqlz0l5vgcxbv"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cloudabi" ,rust-cloudabi)
         ("rust-fuchsia-cprng" ,rust-fuchsia-cprng)
         ("rust-libc" ,rust-libc)
         ("rust-log" ,rust-log)
         ("rust-rand-core-0.4.2" ,rust-rand-core-0.4.2)
         ("rust-rdrand-0.4.0" ,rust-rdrand-0.4.0)
         ("rust-stdweb" ,rust-stdweb)
         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
         ("rust-winapi" ,rust-winapi))))
    (home-page "https://crates.io/crates/rand_os")
    (synopsis "OS backed Random Number Generator")
    (description "OS backed Random Number Generator")
    (license #f)))

(define-public rust-redox-syscall
  (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 ".crate"))
        (sha256
          (base32
            "110y7dyfm2vci4x5vk7gr0q551dvp31npl99fnsx2fb17wzwcf94"))))
    (build-system cargo-build-system)
    (home-page
      "https://gitlab.redox-os.org/redox-os/syscall")
    (synopsis
      "A 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-rust-argon2-0.5.1
  (package
    (name "rust-rust-argon2")
    (version "0.5.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rust-argon2" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1krjkmyfn37hy7sfs6lqia0fsvw130nn1z2850glsjcva7pym92c"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-base64-0.10.1" ,rust-base64-0.10.1)
         ("rust-blake2b-simd" ,rust-blake2b-simd)
         ("rust-crossbeam-utils-0.6.6"
          ,rust-crossbeam-utils-0.6.6))))
    (home-page
      "https://github.com/sru-systems/rust-argon2")
    (synopsis
      "Rust implementation of the Argon2 password hashing function.")
    (description
      "Rust implementation of the Argon2 password hashing function.")
    (license #f)))

(define-public rust-unicode-xid
  (package
    (name "rust-unicode-xid")
    (version "0.2.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "unicode-xid" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0z09fn515xm7zyr0mmdyxa9mx2f7azcpv74pqmg611iralwpcvl2"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/unicode-rs/unicode-xid")
    (synopsis
      "Determine whether characters have the XID_Start
or XID_Continue properties according to
Unicode Standard Annex #31.
")
    (description
      "Determine whether characters have the XID_Start
or XID_Continue properties according to
Unicode Standard Annex #31.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-rand-0.6.5
  (package
    (name "rust-rand")
    (version "0.6.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rand" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1jl4449jcl4wgmzld6ffwqj5gwxrp8zvx8w573g1z368qg6xlwbd"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-libc" ,rust-libc)
         ("rust-log" ,rust-log)
         ("rust-packed-simd" ,rust-packed-simd)
         ("rust-rand-chacha-0.1.1"
          ,rust-rand-chacha-0.1.1)
         ("rust-rand-core-0.4.2" ,rust-rand-core-0.4.2)
         ("rust-rand-hc-0.1.1" ,rust-rand-hc-0.1.1)
         ("rust-rand-isaac-0.1.2" ,rust-rand-isaac-0.1.2)
         ("rust-rand-jitter-0.1.4"
          ,rust-rand-jitter-0.1.4)
         ("rust-rand-os-0.1.3" ,rust-rand-os-0.1.3)
         ("rust-rand-pcg-0.1.2" ,rust-rand-pcg-0.1.2)
         ("rust-rand-xorshift-0.1.2"
          ,rust-rand-xorshift-0.1.2)
         ("rust-winapi" ,rust-winapi))))
    (home-page "https://crates.io/crates/rand")
    (synopsis
      "Random number generators and other randomness functionality.
")
    (description
      "Random number generators and other randomness functionality.
")
    (license #f)))

(define-public rust-cfg-if
  (package
    (name "rust-cfg-if")
    (version "0.1.10")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "cfg-if" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "08h80ihs74jcyp24cd75wwabygbbdgl05k6p5dmq8akbr78vv1a7"))))
    (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/cfg-if")
    (synopsis
      "A macro to ergonomically define an item depending on a large number of #[cfg]
parameters. Structured like an if-else chain, the first matching branch is the
item that gets emitted.
")
    (description
      "This package provides a macro to ergonomically define an item depending on a large number of #[cfg]
parameters.  Structured like an if-else chain, the first matching branch is the
item that gets emitted.
")
    (license #f)))

(define-public rust-wasi
  (package
    (name "rust-wasi")
    (version "0.7.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wasi" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "03apg3sa4hjn6xwa4pkyvzjiscya51wyrygadgxwdg8lrvj3r75q"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-compiler-builtins"
          ,rust-compiler-builtins)
         ("rust-rustc-std-workspace-alloc"
          ,rust-rustc-std-workspace-alloc)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core))))
    (home-page
      "https://github.com/CraneStation/rust-wasi")
    (synopsis
      "Experimental WASI API bindings for Rust")
    (description
      "Experimental WASI API bindings for Rust")
    (license (list #f license:expat))))

(define-public rust-stdweb
  (package
    (name "rust-stdweb")
    (version "0.4.20")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "stdweb" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1md14n9rzxzdskz3hpgln8vxfwqsw2cswc0f5nslh4r82rmlj8nh"))))
    (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))))
    (home-page "https://github.com/koute/stdweb")
    (synopsis
      "A standard library for the client-side Web")
    (description
      "This package provides a standard library for the client-side Web")
    (license #f)))

(define-public rust-wasm-bindgen
  (package
    (name "rust-wasm-bindgen")
    (version "0.2.55")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wasm-bindgen" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1wn5hmiqpw84kc9wd1d1wrjbxwh1ryz1l918k8x6dkds6fpk5bi9"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cfg-if" ,rust-cfg-if)
         ("rust-serde" ,rust-serde)
         ("rust-serde-json" ,rust-serde-json)
         ("rust-wasm-bindgen-macro"
          ,rust-wasm-bindgen-macro))))
    (home-page "https://rustwasm.github.io/")
    (synopsis
      "Easy support for interacting between JS and Rust.
")
    (description
      "Easy support for interacting between JS and Rust.
")
    (license #f)))

(define-public rust-sval
  (package
    (name "rust-sval")
    (version "0.4.7")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "sval" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1aljggx64481q4wp3wx9hxsfh2bs7d64nqsrwbb2zxcpmdnbn6yk"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-serde" ,rust-serde)
         ("rust-smallvec-0.6.13" ,rust-smallvec-0.6.13)
         ("rust-sval-derive" ,rust-sval-derive))))
    (home-page "https://github.com/sval-rs/sval")
    (synopsis
      "A no-std, object-safe serialization framework")
    (description
      "This package provides a no-std, object-safe serialization framework")
    (license (list license:asl2.0 license:expat))))

(define-public rust-backtrace
  (package
    (name "rust-backtrace")
    (version "0.3.40")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "backtrace" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1skpshz0gszhpmj51p35ci9nf4nmd79s899cfrfs570dgxcpck4j"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-addr2line" ,rust-addr2line)
         ("rust-backtrace-sys" ,rust-backtrace-sys)
         ("rust-cfg-if" ,rust-cfg-if)
         ("rust-compiler-builtins"
          ,rust-compiler-builtins)
         ("rust-cpp-demangle" ,rust-cpp-demangle)
         ("rust-findshlibs" ,rust-findshlibs)
         ("rust-goblin-0.0.24" ,rust-goblin-0.0.24)
         ("rust-libc" ,rust-libc)
         ("rust-memmap" ,rust-memmap)
         ("rust-rustc-demangle" ,rust-rustc-demangle)
         ("rust-rustc-serialize" ,rust-rustc-serialize)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core)
         ("rust-serde" ,rust-serde)
         ("rust-winapi" ,rust-winapi))))
    (home-page
      "https://github.com/rust-lang/backtrace-rs")
    (synopsis
      "A library to acquire a stack trace (backtrace) at runtime in a Rust program.
")
    (description
      "This package provides a library to acquire a stack trace (backtrace) at runtime in a Rust program.
")
    (license #f)))

(define-public rust-failure-derive
  (package
    (name "rust-failure-derive")
    (version "0.1.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "failure_derive" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "022xfb9wcs1bdssfm2airsrfxpn2ccpbyh1ld2wf9483isvjbhhb"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2" ,rust-proc-macro2)
         ("rust-quote" ,rust-quote)
         ("rust-syn" ,rust-syn)
         ("rust-synstructure" ,rust-synstructure))))
    (home-page
      "https://rust-lang-nursery.github.io/failure/")
    (synopsis "derives for the failure crate")
    (description "derives for the failure crate")
    (license (list license:expat license:asl2.0))))

(define-public rust-cloudabi
  (package
    (name "rust-cloudabi")
    (version "0.0.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "cloudabi" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0kxcg83jlihy0phnd2g8c2c303px3l2p3pkjz357ll6llnd5pz6x"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-bitflags" ,rust-bitflags))))
    (home-page "https://nuxi.nl/cloudabi/")
    (synopsis
      "Low level interface to CloudABI. Contains all syscalls and related types.")
    (description
      "Low level interface to CloudABI.  Contains all syscalls and related types.")
    (license #f)))

(define-public rust-fuchsia-cprng
  (package
    (name "rust-fuchsia-cprng")
    (version "0.1.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "fuchsia-cprng" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1fnkqrbz7ixxzsb04bsz9p0zzazanma8znfdqjvh39n14vapfvx0"))))
    (build-system cargo-build-system)
    (home-page
      "https://fuchsia.googlesource.com/fuchsia/+/master/garnet/public/rust/fuchsia-cprng")
    (synopsis
      "Rust crate for the Fuchsia cryptographically secure pseudorandom number generator")
    (description
      "Rust crate for the Fuchsia cryptographically secure pseudorandom number generator")
    (license #f)))

(define-public rust-rand-core-0.4.2
  (package
    (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 ".crate"))
        (sha256
          (base32
            "1p09ynysrq1vcdlmcqnapq4qakl2yd1ng3kxh3qscpx09k2a6cww"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("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 #f)))

(define-public rust-rdrand-0.4.0
  (package
    (name "rust-rdrand")
    (version "0.4.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rdrand" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1cjq0kwx1bk7jx3kzyciiish5gqsj7620dm43dc52sr8fzmm9037"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rand-core-0.3.1" ,rust-rand-core-0.3.1))))
    (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-base64-0.10.1
  (package
    (name "rust-base64")
    (version "0.10.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "base64" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "13k6bvd3n6dm7jqn9x918w65dd9xhx454bqphbnv0bkd6n9dj98b"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-byteorder" ,rust-byteorder))))
    (home-page
      "https://github.com/marshallpierce/rust-base64")
    (synopsis
      "encodes and decodes base64 as bytes or utf8")
    (description
      "encodes and decodes base64 as bytes or utf8")
    (license #f)))

(define-public rust-blake2b-simd
  (package
    (name "rust-blake2b-simd")
    (version "0.5.9")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "blake2b_simd" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1h6hhzgvvmp9jb4pvb48h5j0w5vb1n02ahi0g26p2wg6n6m7nfxq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-arrayref" ,rust-arrayref)
         ("rust-arrayvec" ,rust-arrayvec)
         ("rust-constant-time-eq" ,rust-constant-time-eq))))
    (home-page
      "https://github.com/oconnor663/blake2_simd")
    (synopsis
      "a pure Rust BLAKE2b implementation with dynamic SIMD")
    (description
      "a pure Rust BLAKE2b implementation with dynamic SIMD")
    (license license:expat)))

(define-public rust-crossbeam-utils-0.6.6
  (package
    (name "rust-crossbeam-utils")
    (version "0.6.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "crossbeam-utils" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1rk0r9n04bmq4a3g2q5qhvvlmrmx780gc6h9lmc94mwndslkz5q4"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cfg-if" ,rust-cfg-if)
         ("rust-lazy-static" ,rust-lazy-static))))
    (home-page
      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils")
    (synopsis "Utilities for concurrent programming")
    (description
      "Utilities for concurrent programming")
    (license #f)))

(define-public rust-rand-chacha-0.1.1
  (package
    (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 ".crate"))
        (sha256
          (base32
            "1vxwyzs4fy1ffjc8l00fsyygpiss135irjf7nyxgq2v0lqf3lvam"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-rand-core-0.3.1" ,rust-rand-core-0.3.1))))
    (home-page
      "https://crates.io/crates/rand_chacha")
    (synopsis "ChaCha random number generator
")
    (description "ChaCha random number generator
")
    (license #f)))

(define-public rust-rand-hc-0.1.1
  (package
    (name "rust-rand-hc")
    (version "0.1.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rand_hc" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0g33l381hwfvxdcv502d5c88fh7gw78fkfmlp27jp8hhlfxzxam5"))))
    (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 #f)))

(define-public rust-rand-isaac-0.1.2
  (package
    (name "rust-rand-isaac")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rand_isaac" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0zinsqypvm0vwdiwdabvq74d0nnrzshb0kyzsrwi4l5mlp4pkkx9"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rand-core" ,rust-rand-core)
         ("rust-serde" ,rust-serde)
         ("rust-serde-derive" ,rust-serde-derive))))
    (home-page "https://crates.io/crates/rand_isaac")
    (synopsis "ISAAC random number generator
")
    (description "ISAAC random number generator
")
    (license #f)))

(define-public rust-rand-jitter-0.1.4
  (package
    (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 ".crate"))
        (sha256
          (base32
            "16z387y46bfz3csc42zxbjq89vcr1axqacncvv8qhyy93p4xarhi"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-libc" ,rust-libc)
         ("rust-log" ,rust-log)
         ("rust-rand-core-0.4.2" ,rust-rand-core-0.4.2)
         ("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:expat license:asl2.0))))

(define-public rust-rand-pcg-0.1.2
  (package
    (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 ".crate"))
        (sha256
          (base32
            "0i0bdla18a8x4jn1w0fxsbs3jg7ajllz6azmch1zw33r06dv1ydb"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-rand-core-0.4.2" ,rust-rand-core-0.4.2)
         ("rust-serde" ,rust-serde)
         ("rust-serde-derive" ,rust-serde-derive))))
    (home-page "https://crates.io/crates/rand_pcg")
    (synopsis
      "Selected PCG random number generators
")
    (description
      "Selected PCG random number generators
")
    (license #f)))

(define-public rust-rand-xorshift-0.1.2
  (package
    (name "rust-rand-xorshift")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rand_xorshift" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1vwyvly2bgni246j8xls83axvcjz9p563vynx5rqqll8hizsza97"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rand-core" ,rust-rand-core)
         ("rust-serde" ,rust-serde)
         ("rust-serde-derive" ,rust-serde-derive))))
    (home-page
      "https://crates.io/crates/rand_xorshift")
    (synopsis "Xorshift random number generator
")
    (description
      "Xorshift random number generator
")
    (license #f)))

(define-public rust-packed-simd
  (package
    (name "rust-packed-simd")
    (version "0.3.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "packed_simd" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0822wqf6kzw4ig9ykndg348w2bxkhs3x64brzsvdxh2a1pyajpm8"))))
    (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))))
    (home-page
      "https://github.com/rust-lang-nursery/packed_simd")
    (synopsis "Portable Packed SIMD vectors")
    (description "Portable Packed SIMD vectors")
    (license #f)))

(define-public rust-rustc-std-workspace-alloc
  (package
    (name "rust-rustc-std-workspace-alloc")
    (version "1.0.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rustc-std-workspace-alloc" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "11psmqk6glglxl3zwh8slz6iynfxaifh4spd2wcnws552dqdarpz"))))
    (build-system cargo-build-system)
    (home-page "")
    (synopsis "workspace hack")
    (description "workspace hack")
    (license #f)))

(define-public rust-discard
  (package
    (name "rust-discard")
    (version "1.0.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "discard" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1h67ni5bxvg95s91wgicily4ix7lcw7cq0a5gy9njrybaibhyb91"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/Pauan/rust-discard")
    (synopsis
      "Discard trait which allows for intentionally leaking memory")
    (description
      "Discard trait which allows for intentionally leaking memory")
    (license 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 ".crate"))
        (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 #f)))

(define-public rust-stdweb-derive
  (package
    (name "rust-stdweb-derive")
    (version "0.5.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "stdweb-derive" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1vsh7g0gaxn4kxqq3knhymdn02p2pfxmnd2j0vplpj6c1yj60yn8"))))
    (build-system cargo-build-system)
    (arguments
      `(#: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
      "Derive macros for the `stdweb` crate")
    (license #f)))

(define-public rust-stdweb-internal-macros
  (package
    (name "rust-stdweb-internal-macros")
    (version "0.2.9")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "stdweb-internal-macros" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "049fq8fl5ny9l5if2qv7kxwng7g6ns95h4fbm3zx360dmpv5zyjq"))))
    (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")
    (synopsis
      "Internal procedural macros for the `stdweb` crate")
    (description
      "Internal procedural macros for the `stdweb` crate")
    (license #f)))

(define-public rust-stdweb-internal-runtime
  (package
    (name "rust-stdweb-internal-runtime")
    (version "0.1.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "stdweb-internal-runtime" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1h0nkppb4r8dbrbms2hw9n5xdcs392m0r5hj3b6lsx3h6fx02dr1"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/koute/stdweb")
    (synopsis
      "Internal runtime for the `stdweb` crate")
    (description
      "Internal runtime for the `stdweb` crate")
    (license #f)))

(define-public rust-futures-channel-preview
  (package
    (name "rust-futures-channel-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-channel-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0fi6bi4lpyxjigy11y5sjg6wlc8nc71vbpmxz31c3aagjvgz9rfm"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-futures-core-preview"
          ,rust-futures-core-preview)
         ("rust-futures-sink-preview"
          ,rust-futures-sink-preview))))
    (home-page
      "https://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "Channels for asynchronous communication using futures-rs.
")
    (description
      "Channels for asynchronous communication using futures-rs.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures-core-preview
  (package
    (name "rust-futures-core-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-core-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "02n66jkjhpy210dv24pz0j30lvyin5kzlrb50p1j7x8yzdin4nxk"))))
    (build-system cargo-build-system)
    (home-page
      "https://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "The core traits and types in for the `futures` library.
")
    (description
      "The core traits and types in for the `futures` library.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures-executor-preview
  (package
    (name "rust-futures-executor-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-executor-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "161yv7wwha60mdzj1id47kh8ylnhcnv7blgwidg8xs4zpn46w8vm"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-futures-core-preview"
          ,rust-futures-core-preview)
         ("rust-futures-util-preview"
          ,rust-futures-util-preview)
         ("rust-num-cpus" ,rust-num-cpus))))
    (home-page
      "https://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "Executors for asynchronous tasks based on the futures-rs library.
")
    (description
      "Executors for asynchronous tasks based on the futures-rs library.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures-util-preview
  (package
    (name "rust-futures-util-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-util-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "138f8wy0vqy2gsgk28kldbqnrdcgwfv9f9xx6rwzkr8p7iinisaw"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-futures-0.1.29" ,rust-futures-0.1.29)
         ("rust-futures-channel-preview"
          ,rust-futures-channel-preview)
         ("rust-futures-core-preview"
          ,rust-futures-core-preview)
         ("rust-futures-io-preview"
          ,rust-futures-io-preview)
         ("rust-futures-join-macro-preview"
          ,rust-futures-join-macro-preview)
         ("rust-futures-select-macro-preview"
          ,rust-futures-select-macro-preview)
         ("rust-futures-sink-preview"
          ,rust-futures-sink-preview)
         ("rust-memchr" ,rust-memchr)
         ("rust-pin-utils" ,rust-pin-utils)
         ("rust-proc-macro-hack" ,rust-proc-macro-hack)
         ("rust-proc-macro-nested"
          ,rust-proc-macro-nested)
         ("rust-slab" ,rust-slab)
         ("rust-tokio-io-0.1.12" ,rust-tokio-io-0.1.12))))
    (home-page
      "https://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "Common utilities and extension traits for the futures-rs library.
")
    (description
      "Common utilities and extension traits for the futures-rs library.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-serde-json
  (package
    (name "rust-serde-json")
    (version "1.0.42")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "serde_json" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0hq0x0x0lbjcvfnml2s7zk7s9lca50gkqz5bj8n7w1hzpkf52cqs"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-indexmap" ,rust-indexmap)
         ("rust-itoa" ,rust-itoa)
         ("rust-ryu" ,rust-ryu)
         ("rust-serde" ,rust-serde))))
    (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:expat license:asl2.0))))

(define-public rust-wasm-bindgen-macro
  (package
    (name "rust-wasm-bindgen-macro")
    (version "0.2.55")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wasm-bindgen-macro" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1r4zxc52pp44hhind2xxbbncy8jdchs66yll5k996g5pwr3wgz47"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-quote" ,rust-quote)
         ("rust-wasm-bindgen-macro-support"
          ,rust-wasm-bindgen-macro-support))))
    (home-page
      "https://rustwasm.github.io/wasm-bindgen/")
    (synopsis
      "Definition of the `#[wasm_bindgen]` attribute, an internal dependency
")
    (description
      "Definition of the `#[wasm_bindgen]` attribute, an internal dependency
")
    (license #f)))

(define-public rust-smallvec-0.6.13
  (package
    (name "rust-smallvec")
    (version "0.6.13")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "smallvec" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1dl219vnfkmsfx28lm3f83lyw24zap6fdsli6rg8nnp1aa67bc7p"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-maybe-uninit" ,rust-maybe-uninit)
         ("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/servo/rust-smallvec")
    (synopsis
      "'Small vector' optimization: store up to a small number of items on the stack")
    (description
      "'Small vector' optimization: store up to a small number of items on the stack")
    (license #f)))

(define-public rust-sval-derive
  (package
    (name "rust-sval-derive")
    (version "0.4.7")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "sval_derive" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "07s7jqsdczsg0wnydfnxyrsj8zyrjmiwl4is1dfgn8dfvyi8n2bj"))))
    (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/sval-rs/sval")
    (synopsis "Custom derive for sval")
    (description "Custom derive for sval")
    (license (list license:asl2.0 license:expat))))

(define-public rust-rustc-demangle
  (package
    (name "rust-rustc-demangle")
    (version "0.1.16")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rustc-demangle" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "10qp42sl1wrdbgbbh8rnay2grm976z7hqgz32c4y09l1c071qsac"))))
    (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 #f)))

(define-public rust-addr2line
  (package
    (name "rust-addr2line")
    (version "0.10.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "addr2line" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1daaxrzk6fmfzaqi06y704hcw0rjz199l0n9214ybfm3m3jnmc4m"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cpp-demangle" ,rust-cpp-demangle)
         ("rust-fallible-iterator"
          ,rust-fallible-iterator)
         ("rust-gimli" ,rust-gimli)
         ("rust-intervaltree" ,rust-intervaltree)
         ("rust-lazycell" ,rust-lazycell)
         ("rust-object-0.12.0" ,rust-object-0.12.0)
         ("rust-rustc-demangle" ,rust-rustc-demangle)
         ("rust-smallvec-0.6.13" ,rust-smallvec-0.6.13))))
    (home-page
      "https://github.com/gimli-rs/addr2line")
    (synopsis
      "A cross-platform symbolication library written in Rust, using `gimli`")
    (description
      "This package provides a cross-platform symbolication library written in Rust, using `gimli`")
    (license #f)))

(define-public rust-backtrace-sys
  (package
    (name "rust-backtrace-sys")
    (version "0.1.32")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "backtrace-sys" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "14c406z8bdmms8a5l8cv79jfkz1mk10qk5p97izf4vai53qparax"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cc" ,rust-cc)
         ("rust-compiler-builtins"
          ,rust-compiler-builtins)
         ("rust-libc" ,rust-libc)
         ("rust-rustc-std-workspace-core"
          ,rust-rustc-std-workspace-core))))
    (home-page
      "https://github.com/alexcrichton/backtrace-rs")
    (synopsis
      "Bindings to the libbacktrace gcc library
")
    (description
      "Bindings to the libbacktrace gcc library
")
    (license #f)))

(define-public rust-cpp-demangle
  (package
    (name "rust-cpp-demangle")
    (version "0.2.14")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "cpp_demangle" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1mm064x84868q06r4m4b7byf999nrkbhx7iyc4nchyssaxpsy5a1"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-afl" ,rust-afl)
         ("rust-cfg-if" ,rust-cfg-if)
         ("rust-glob" ,rust-glob))))
    (home-page
      "https://github.com/gimli-rs/cpp_demangle")
    (synopsis "A crate for demangling C++ symbols")
    (description
      "This package provides a crate for demangling C++ symbols")
    (license #f)))

(define-public rust-findshlibs
  (package
    (name "rust-findshlibs")
    (version "0.5.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "findshlibs" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1n2vagn0q5yim32hxkwi1cjgp3yn1dm45p7z8nw6lapywihhs9mi"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-lazy-static" ,rust-lazy-static)
         ("rust-libc" ,rust-libc))))
    (home-page
      "https://github.com/gimli-rs/findshlibs")
    (synopsis
      "Find the set of shared libraries loaded in the current process with a cross platform API")
    (description
      "Find the set of shared libraries loaded in the current process with a cross platform API")
    (license #f)))

(define-public rust-goblin-0.0.24
  (package
    (name "rust-goblin")
    (version "0.0.24")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "goblin" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1c31nrraiixy0mnda2227ih3h2g1k4pllg2kwk8yj6lwj4fjdyp3"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-log" ,rust-log)
         ("rust-plain" ,rust-plain)
         ("rust-scroll-0.9.2" ,rust-scroll-0.9.2))))
    (home-page "https://github.com/m4b/goblin")
    (synopsis
      "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
    (description
      "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
    (license license:expat)))

(define-public rust-memmap
  (package
    (name "rust-memmap")
    (version "0.7.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "memmap" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0ns7kkd1h4pijdkwfvw4qlbbmqmlmzwlq3g2676dcl5vwyazv1b5"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-libc" ,rust-libc)
         ("rust-winapi" ,rust-winapi))))
    (home-page
      "https://github.com/danburkert/memmap-rs")
    (synopsis
      "Cross-platform Rust API for memory-mapped file IO")
    (description
      "Cross-platform Rust API for memory-mapped file IO")
    (license #f)))

(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 ".crate"))
        (sha256
          (base32
            "1nkg3vasg7nk80ffkazizgiyv3hb1l9g3d8h17cajbkx538jiwfw"))))
    (build-system cargo-build-system)
    (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 #f)))

(define-public rust-synstructure
  (package
    (name "rust-synstructure")
    (version "0.12.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "synstructure" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0igmc5fzpk6fg7kgff914j05lbpc6ai2wmji312v2h8vvjhnwrb7"))))
    (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))))
    (home-page
      "https://github.com/mystor/synstructure")
    (synopsis
      "Helper methods and macros for custom derives")
    (description
      "Helper methods and macros for custom derives")
    (license license:expat)))

(define-public rust-rand-core-0.3.1
  (package
    (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 ".crate"))
        (sha256
          (base32
            "0jzdgszfa4bliigiy4hi66k7fs3gfwi2qxn8vik84ph77fwdwvvs"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rand-core-0.4.2" ,rust-rand-core-0.4.2))))
    (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 #f)))

(define-public rust-arrayref
  (package
    (name "rust-arrayref")
    (version "0.3.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "arrayref" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1vphy316jbgmgckk4z7m8csvlyc8hih9w95iyq48h8077xc2wf0d"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/droundy/arrayref")
    (synopsis
      "Macros to take array references of slices")
    (description
      "Macros to take array references of slices")
    (license #f)))

(define-public rust-arrayvec
  (package
    (name "rust-arrayvec")
    (version "0.5.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "arrayvec" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1f5mca8kiiwhvhxd1mbnq68j6v6rk139sch567zwwzl6hs37vxyg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
    (home-page "https://github.com/bluss/arrayvec")
    (synopsis
      "A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.")
    (description
      "This package provides a vector with fixed capacity, backed by an array (it can be stored on the stack too).  Implements fixed capacity ArrayVec and ArrayString.")
    (license #f)))

(define-public rust-constant-time-eq
  (package
    (name "rust-constant-time-eq")
    (version "0.1.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "constant_time_eq" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "083icpr9xb72rrdxw3p4068dcspn6ai22jy7rhl2a8grfz448nlr"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/cesarb/constant_time_eq")
    (synopsis
      "Compares two equal-sized byte strings in constant time.")
    (description
      "Compares two equal-sized byte strings in constant time.")
    (license license:cc0)))

(define-public rust-lazy-static
  (package
    (name "rust-lazy-static")
    (version "1.4.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "lazy_static" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0in6ikhw8mgl33wjv6q6xfrb5b9jr16q8ygjy803fay4zcisvaz2"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-spin" ,rust-spin))))
    (home-page
      "https://github.com/rust-lang-nursery/lazy-static.rs")
    (synopsis
      "A macro for declaring lazily evaluated statics in Rust.")
    (description
      "This package provides a macro for declaring lazily evaluated statics in Rust.")
    (license #f)))

(define-public rust-rand-core
  (package
    (name "rust-rand-core")
    (version "0.5.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rand_core" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "06bdvx08v3rkz451cm7z59xwwqn1rkfh6v9ay77b14f8dwlybgch"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-getrandom" ,rust-getrandom)
         ("rust-serde" ,rust-serde))))
    (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:expat license:asl2.0))))

(define-public rust-core-arch
  (package
    (name "rust-core-arch")
    (version "0.1.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "core_arch" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "04vdvr9vj0f1cv2p54nsszmrrk9w1js4c0z4i0bdlajl1lydslim"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/rust-lang-nursery/stdsimd")
    (synopsis
      "`core::arch` - Rust's core library architecture-specific intrinsics.")
    (description
      "`core::arch` - Rust's core library architecture-specific intrinsics.")
    (license #f)))

(define-public rust-sleef-sys
  (package
    (name "rust-sleef-sys")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "sleef-sys" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1881q2yc17j2m1yvh01447c93ws1mspnrj3k2nbvwbvcm8z81kkv"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-bindgen-0.46.0" ,rust-bindgen-0.46.0)
         ("rust-cfg-if" ,rust-cfg-if)
         ("rust-cmake" ,rust-cmake)
         ("rust-env-logger-0.6.2" ,rust-env-logger-0.6.2)
         ("rust-libc" ,rust-libc))))
    (home-page "https://github.com/gnzlbg/sleef-sys")
    (synopsis
      "Rust FFI bindings to the SLEEF Vectorized Math Library
")
    (description
      "Rust FFI bindings to the SLEEF Vectorized Math Library
")
    (license #f)))

(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 ".crate"))
        (sha256
          (base32
            "00q4lkcj0rrgbhviv9sd4p6qmdsipkwkbra7rh11jrhq5kpvjzhx"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-semver-parser-0.7.0"
          ,rust-semver-parser-0.7.0)
         ("rust-serde" ,rust-serde))))
    (home-page "https://docs.rs/crate/semver/")
    (synopsis
      "Semantic version parsing and comparison.
")
    (description
      "Semantic version parsing and comparison.
")
    (license #f)))

(define-public rust-base-x
  (package
    (name "rust-base-x")
    (version "0.2.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "base-x" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1hfy0wv7j5ynd73yk1vyr32pqa77rp15lkrc54f8ky9c6hcbc80v"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/OrKoN/base-x-rs")
    (synopsis "Encode/decode any base")
    (description "Encode/decode any base")
    (license license:expat)))

(define-public rust-sha1
  (package
    (name "rust-sha1")
    (version "0.6.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "sha1" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "03gs2q4m67rn2p8xcdfxhip6mpgahdwm12bnb3vh90ahv9grhy95"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
    (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-futures-sink-preview
  (package
    (name "rust-futures-sink-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-sink-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1v7y5qvgvl0d6hd9s4k7bd5qrj2gdlrs5yfl22v5pxv9dgpliwc6"))))
    (build-system cargo-build-system)
    (home-page
      "https://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "The asynchronous `Sink` trait for the futures-rs library.
")
    (description
      "The asynchronous `Sink` trait for the futures-rs library.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-pin-utils
  (package
    (name "rust-pin-utils")
    (version "0.1.0-alpha.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "pin-utils" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "11xmyx00n4m37d546by2rxb8ryxs12v55cc172i3yak1rqccd52q"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/rust-lang-nursery/pin-utils")
    (synopsis "Utilities for pinning
")
    (description "Utilities for pinning
")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures-0.1.29
  (package
    (name "rust-futures")
    (version "0.1.29")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1vq3cw37knnd0afw3rcjzh71i2l01v5m4ysinrrqdvnn2ql0z60v"))))
    (build-system cargo-build-system)
    (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 #f)))

(define-public rust-futures-io-preview
  (package
    (name "rust-futures-io-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-io-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1npb04xbn2gw5rjllz88cb88fql44xxfkgcidjjj26fva3j4m4gl"))))
    (build-system cargo-build-system)
    (home-page
      "https://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "The `AsyncRead` and `AsyncWrite` traits for the futures-rs library.
")
    (description
      "The `AsyncRead` and `AsyncWrite` traits for the futures-rs library.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures-join-macro-preview
  (package
    (name "rust-futures-join-macro-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "futures-join-macro-preview" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1smwaja466yjh5adlhgggfk9k942sy4702n46scxkrwcnkk61qjr"))))
    (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://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "Definition of the `join!` macro and the `try_join!` macro.
")
    (description
      "Definition of the `join!` macro and the `try_join!` macro.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-futures-select-macro-preview
  (package
    (name "rust-futures-select-macro-preview")
    (version "0.3.0-alpha.19")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri
               "futures-select-macro-preview"
               version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1xsq55cf2rnf7k6r04q8wynmxiy9svm3pi840vjva47bc0sy8anz"))))
    (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://rust-lang-nursery.github.io/futures-rs")
    (synopsis
      "The `select!` macro for waiting on multiple different `Future`s at once and handling the first one to complete.
")
    (description
      "The `select!` macro for waiting on multiple different `Future`s at once and handling the first one to complete.
")
    (license (list license:expat license:asl2.0))))

(define-public rust-memchr
  (package
    (name "rust-memchr")
    (version "2.2.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "memchr" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "13j6ji9x9ydpi9grbss106gqqr3xn3bcfp28aydqfa4751qrfmw8"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-libc" ,rust-libc))))
    (home-page
      "https://github.com/BurntSushi/rust-memchr")
    (synopsis "Safe interface to memchr.")
    (description "Safe interface to memchr.")
    (license #f)))

(define-public rust-proc-macro-hack
  (package
    (name "rust-proc-macro-hack")
    (version "0.5.11")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "proc-macro-hack" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1idz5vmnjjhvr51yvwyjb45mza18wa53fr05m1skqvbdyw15gm7c"))))
    (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/proc-macro-hack")
    (synopsis
      "Procedural macros in expression position")
    (description
      "Procedural macros in expression position")
    (license (list license:expat license:asl2.0))))

(define-public rust-proc-macro-nested
  (package
    (name "rust-proc-macro-nested")
    (version "0.1.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "proc-macro-nested" version))
        (file-name
          (string-append name "-" version ".crate"))
        (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
      "Support for nested proc-macro-hack invocations")
    (license #f)))

(define-public rust-slab
  (package
    (name "rust-slab")
    (version "0.4.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "slab" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1y59xsa27jk84sxzswjk60xcjf8b4fm5960jwpznrrcmasyva4f1"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/carllerche/slab")
    (synopsis
      "Pre-allocated storage for a uniform data type")
    (description
      "Pre-allocated storage for a uniform data type")
    (license license:expat)))

(define-public rust-tokio-io-0.1.12
  (package
    (name "rust-tokio-io")
    (version "0.1.12")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "tokio-io" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "09jrz1hh4h1vj45qy09y7m7m8jsy1hl6g32clnky25mdim3dp42h"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-bytes-0.4.12" ,rust-bytes-0.4.12)
         ("rust-futures-0.1.29" ,rust-futures-0.1.29)
         ("rust-log" ,rust-log))))
    (home-page "https://tokio.rs")
    (synopsis
      "Core I/O primitives for asynchronous I/O in Rust.
")
    (description
      "Core I/O primitives for asynchronous I/O in Rust.
")
    (license license:expat)))

(define-public rust-itoa
  (package
    (name "rust-itoa")
    (version "0.4.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "itoa" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0zvg2d9qv3avhf3d8ggglh6fdyw8kkwqg3r4622ly5yhxnvnc4jh"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/dtolnay/itoa")
    (synopsis
      "Fast functions for printing integer primitives to an io::Write")
    (description
      "Fast functions for printing integer primitives to an io::Write")
    (license #f)))

(define-public rust-ryu
  (package
    (name "rust-ryu")
    (version "1.0.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "ryu" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1j0h74f1xqf9hjkhanp8i20mqc1aw35kr1iq9i79q7713mn51a5z"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-no-panic" ,rust-no-panic))))
    (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-indexmap
  (package
    (name "rust-indexmap")
    (version "1.3.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "indexmap" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1ckd9vg6y71d9syz9j795bdz0dpilm6vy56s9yfwnzw2llz7nbbi"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-rayon" ,rust-rayon)
         ("rust-serde" ,rust-serde))))
    (home-page "https://github.com/bluss/indexmap")
    (synopsis
      "A hash table with consistent order and fast iteration.

The indexmap is a hash table where the iteration order of the key-value
pairs is independent of the hash values of the keys. It has the usual
hash table functionality, it preserves insertion order except after
removals, and it allows lookup of its elements by either hash table key
or numerical index. A corresponding hash set type is also provided.

This crate was initially published under the name ordermap, but it was renamed to
indexmap.
")
    (description
      "This package provides a hash table with consistent order and fast iteration.

The indexmap is a hash table where the iteration order of the key-value
pairs is independent of the hash values of the keys.  It has the usual
hash table functionality, it preserves insertion order except after
removals, and it allows lookup of its elements by either hash table key
or numerical index.  A corresponding hash set type is also provided.

This crate was initially published under the name ordermap, but it was renamed to
indexmap.
")
    (license #f)))

(define-public rust-wasm-bindgen-macro-support
  (package
    (name "rust-wasm-bindgen-macro-support")
    (version "0.2.55")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wasm-bindgen-macro-support" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0w7m0gn783xgbbzwc5mx7j8wa116yvy94frnbx58r307qkrb7i1x"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2" ,rust-proc-macro2)
         ("rust-quote" ,rust-quote)
         ("rust-syn" ,rust-syn)
         ("rust-wasm-bindgen-backend"
          ,rust-wasm-bindgen-backend)
         ("rust-wasm-bindgen-shared"
          ,rust-wasm-bindgen-shared))))
    (home-page
      "https://rustwasm.github.io/wasm-bindgen/")
    (synopsis
      "The part of the implementation of the `#[wasm_bindgen]` attribute that is not in the shared backend crate
")
    (description
      "The part of the implementation of the `#[wasm_bindgen]` attribute that is not in the shared backend crate
")
    (license #f)))

(define-public rust-maybe-uninit
  (package
    (name "rust-maybe-uninit")
    (version "2.0.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "maybe-uninit" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "004y0nzmpfdrhz251278341z6ql34iv1k6dp1h6af7d6nd6jwc30"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/est31/maybe-uninit")
    (synopsis
      "MaybeUninit for friends of backwards compatibility")
    (description
      "MaybeUninit for friends of backwards compatibility")
    (license (list license:asl2.0 license:expat))))

(define-public rust-fallible-iterator
  (package
    (name "rust-fallible-iterator")
    (version "0.2.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "fallible-iterator" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1x31skjsynn2h7sq3qzyv4zlyk2w8jmqcs3phsg4qxhz52yj16qx"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/sfackler/rust-fallible-iterator")
    (synopsis "Fallible iterator traits")
    (description "Fallible iterator traits")
    (license #f)))

(define-public rust-gimli
  (package
    (name "rust-gimli")
    (version "0.19.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "gimli" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "006dpaa63y01wb58nvs2hhj3qqx52yxg20njjflr0frfbyp1hb8n"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-arrayvec-0.4.12" ,rust-arrayvec-0.4.12)
         ("rust-byteorder" ,rust-byteorder)
         ("rust-fallible-iterator"
          ,rust-fallible-iterator)
         ("rust-indexmap" ,rust-indexmap)
         ("rust-stable-deref-trait"
          ,rust-stable-deref-trait))))
    (home-page "https://github.com/gimli-rs/gimli")
    (synopsis
      "A library for reading and writing the DWARF debugging format.")
    (description
      "This package provides a library for reading and writing the DWARF debugging format.")
    (license #f)))

(define-public rust-intervaltree
  (package
    (name "rust-intervaltree")
    (version "0.2.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "intervaltree" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "10k40gsv79kwnsqrzwmnmm6psa5fqws8yggavmbggvymv16hffdg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-smallvec-0.6.13" ,rust-smallvec-0.6.13))))
    (home-page
      "https://github.com/main--/rust-intervaltree")
    (synopsis
      "A simple and generic implementation of an immutable interval tree.")
    (description
      "This package provides a simple and generic implementation of an immutable interval tree.")
    (license license:expat)))

(define-public rust-lazycell
  (package
    (name "rust-lazycell")
    (version "1.2.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "lazycell" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0gvqycmpv7parc98i6y64ai7rvxrn1947z2a6maa02g4kvxdd55j"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-clippy" ,rust-clippy))))
    (home-page "https://github.com/indiv0/lazycell")
    (synopsis
      "A library providing a lazily filled Cell struct")
    (description
      "This package provides a library providing a lazily filled Cell struct")
    (license #f)))

(define-public rust-object-0.12.0
  (package
    (name "rust-object")
    (version "0.12.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "object" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1dch1ajjp05d16lig1dnvisfis0hrlrvw9lcwy1hwgdcym3z6jnz"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-flate2" ,rust-flate2)
         ("rust-goblin-0.0.22" ,rust-goblin-0.0.22)
         ("rust-parity-wasm-0.38.0"
          ,rust-parity-wasm-0.38.0)
         ("rust-scroll-0.9.2" ,rust-scroll-0.9.2)
         ("rust-uuid-0.7.4" ,rust-uuid-0.7.4))))
    (home-page "https://github.com/gimli-rs/object")
    (synopsis
      "A unified interface for parsing object file formats.")
    (description
      "This package provides a unified interface for parsing object file formats.")
    (license #f)))

(define-public rust-glob
  (package
    (name "rust-glob")
    (version "0.3.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "glob" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0x25wfr7vg3mzxc9x05dcphvd3nwlcmbnxrvwcvrrdwplcrrk4cv"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/glob")
    (synopsis
      "Support for matching file paths against Unix shell style patterns.
")
    (description
      "Support for matching file paths against Unix shell style patterns.
")
    (license #f)))

(define-public rust-afl
  (package
    (name "rust-afl")
    (version "0.5.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "afl" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0azpi917l8nhvx25n2v670nvkxkrhcwmddfi85qnr6kchmi6y946"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cc" ,rust-cc)
         ("rust-clap" ,rust-clap)
         ("rust-rustc-version" ,rust-rustc-version)
         ("rust-rustc-version" ,rust-rustc-version)
         ("rust-xdg" ,rust-xdg)
         ("rust-xdg" ,rust-xdg))))
    (home-page "https://github.com/rust-fuzz/afl.rs")
    (synopsis
      "Fuzzing Rust code with american-fuzzy-lop")
    (description
      "Fuzzing Rust code with american-fuzzy-lop")
    (license license:asl2.0)))

(define-public rust-plain
  (package
    (name "rust-plain")
    (version "0.2.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "plain" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "19n1xbxb4wa7w891268bzf6cbwq4qvdb86bik1z129qb0xnnnndl"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/randomites/plain")
    (synopsis
      "A small Rust library that allows users to reinterpret data of certain types safely.")
    (description
      "This package provides a small Rust library that allows users to reinterpret data of certain types safely.")
    (license #f)))

(define-public rust-scroll-0.9.2
  (package
    (name "rust-scroll")
    (version "0.9.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "scroll" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "10q3w86bn22xrjlfg1c90dfi9c26qjkzn26nad0i9z8pxwad311g"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rustc-version" ,rust-rustc-version)
         ("rust-scroll-derive-0.9.5"
          ,rust-scroll-derive-0.9.5))))
    (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-spin
  (package
    (name "rust-spin")
    (version "0.5.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "spin" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0b84m6dbzrwf2kxylnw82d3dr8w06av7rfkr8s85fb5f43rwyqvf"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/mvdnes/spin-rs.git")
    (synopsis
      "Synchronization primitives based on spinning.
They may contain data, are usable without `std`,
and static initializers are available.
")
    (description
      "Synchronization primitives based on spinning.
They may contain data, are usable without `std`,
and static initializers are available.
")
    (license license:expat)))

(define-public rust-bindgen-0.46.0
  (package
    (name "rust-bindgen")
    (version "0.46.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "bindgen" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1qclvj5pydn5camw396b0r3nz4nn3p5wpxg4fgg1favp043pyzwg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-bitflags" ,rust-bitflags)
         ("rust-cexpr" ,rust-cexpr)
         ("rust-cfg-if" ,rust-cfg-if)
         ("rust-clang-sys-0.26.4" ,rust-clang-sys-0.26.4)
         ("rust-clap" ,rust-clap)
         ("rust-env-logger-0.6.2" ,rust-env-logger-0.6.2)
         ("rust-hashbrown-0.1.8" ,rust-hashbrown-0.1.8)
         ("rust-lazy-static" ,rust-lazy-static)
         ("rust-log" ,rust-log)
         ("rust-peeking-take-while"
          ,rust-peeking-take-while)
         ("rust-proc-macro2-0.4.30"
          ,rust-proc-macro2-0.4.30)
         ("rust-quote-0.6.13" ,rust-quote-0.6.13)
         ("rust-regex" ,rust-regex)
         ("rust-which-2.0.1" ,rust-which-2.0.1))))
    (home-page
      "https://rust-lang.github.io/rust-bindgen/")
    (synopsis
      "Automatically generates Rust FFI bindings to C and C++ libraries.")
    (description
      "Automatically generates Rust FFI bindings to C and C++ libraries.")
    (license license:bsd-3)))

(define-public rust-cmake
  (package
    (name "rust-cmake")
    (version "0.1.42")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "cmake" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0qkwibkvx5xjazvv9v8gvdlpky2jhjxvcz014nrixgzqfyv2byw1"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-cc" ,rust-cc))))
    (home-page
      "https://github.com/alexcrichton/cmake-rs")
    (synopsis
      "A build dependency for running `cmake` to build a native library
")
    (description
      "This package provides a build dependency for running `cmake` to build a native library
")
    (license #f)))

(define-public rust-env-logger-0.6.2
  (package
    (name "rust-env-logger")
    (version "0.6.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "env_logger" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1lx2s5nk96xx4i3m4zc4ghqgi8kb07dsnyiv8jk2clhax42dxz5a"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-atty" ,rust-atty)
         ("rust-humantime" ,rust-humantime)
         ("rust-log" ,rust-log)
         ("rust-regex" ,rust-regex)
         ("rust-termcolor" ,rust-termcolor))))
    (home-page
      "https://github.com/sebasmagri/env_logger/")
    (synopsis
      "A logging implementation for `log` which is configured via an environment
variable.
")
    (description
      "This package provides a logging implementation for `log` which is configured via an environment
variable.
")
    (license #f)))

(define-public rust-semver-parser-0.7.0
  (package
    (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 ".crate"))
        (sha256
          (base32
            "18vhypw6zgccnrlm5ps1pwa0khz7ry927iznpr88b87cagr1v2iq"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/steveklabnik/semver-parser")
    (synopsis "Parsing of the semver spec.
")
    (description "Parsing of the semver spec.
")
    (license #f)))

(define-public rust-bytes-0.4.12
  (package
    (name "rust-bytes")
    (version "0.4.12")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "bytes" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0768a55q2fsqdjsvcv98ndg9dq7w2g44dvq1avhwpxrdzbydyvr0"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-byteorder" ,rust-byteorder)
         ("rust-either" ,rust-either)
         ("rust-iovec-0.1.4" ,rust-iovec-0.1.4)
         ("rust-serde" ,rust-serde))))
    (home-page "https://github.com/tokio-rs/bytes")
    (synopsis
      "Types and traits for working with bytes")
    (description
      "Types and traits for working with bytes")
    (license license:expat)))

(define-public rust-no-panic
  (package
    (name "rust-no-panic")
    (version "0.1.12")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "no-panic" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0xan5v9ac1aklinc8aw16raq36pb4idjrl502np8gy32gfs6s751"))))
    (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/no-panic")
    (synopsis
      "Attribute macro to require that the compiler prove a function can't ever panic.")
    (description
      "Attribute macro to require that the compiler prove a function can't ever panic.")
    (license (list license:expat license:asl2.0))))

(define-public rust-rayon
  (package
    (name "rust-rayon")
    (version "1.2.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rayon" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1pgxnyp0iqjjlp2akw5n98wxcjrdcb9j6x33cdijffs96649yws3"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-crossbeam-deque" ,rust-crossbeam-deque)
         ("rust-either" ,rust-either)
         ("rust-rayon-core" ,rust-rayon-core))))
    (home-page "https://github.com/rayon-rs/rayon")
    (synopsis
      "Simple work-stealing parallelism for Rust")
    (description
      "Simple work-stealing parallelism for Rust")
    (license #f)))

(define-public rust-wasm-bindgen-backend
  (package
    (name "rust-wasm-bindgen-backend")
    (version "0.2.55")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wasm-bindgen-backend" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "11cxn5m5srj4bq06zwr2fw2rm9al8kwdkrp61pf44d2rsd5mhi8q"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-bumpalo" ,rust-bumpalo)
         ("rust-lazy-static" ,rust-lazy-static)
         ("rust-log" ,rust-log)
         ("rust-proc-macro2" ,rust-proc-macro2)
         ("rust-quote" ,rust-quote)
         ("rust-syn" ,rust-syn)
         ("rust-wasm-bindgen-shared"
          ,rust-wasm-bindgen-shared))))
    (home-page
      "https://rustwasm.github.io/wasm-bindgen/")
    (synopsis
      "Backend code generation of the wasm-bindgen tool
")
    (description
      "Backend code generation of the wasm-bindgen tool
")
    (license #f)))

(define-public rust-wasm-bindgen-shared
  (package
    (name "rust-wasm-bindgen-shared")
    (version "0.2.55")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wasm-bindgen-shared" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0gdmid85jr3yy34xfdnz99rwla27g70csj8xbnwqk1dysgb7h2ya"))))
    (build-system cargo-build-system)
    (home-page
      "https://rustwasm.github.io/wasm-bindgen/")
    (synopsis
      "Shared support between wasm-bindgen and wasm-bindgen cli, an internal
dependency.
")
    (description
      "Shared support between wasm-bindgen and wasm-bindgen cli, an internal
dependency.
")
    (license #f)))

(define-public rust-arrayvec-0.4.12
  (package
    (name "rust-arrayvec")
    (version "0.4.12")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "arrayvec" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1fdiv5m627gh6flp4mpmi1mh647imm9x423licsr11psz97d97yd"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-nodrop" ,rust-nodrop)
         ("rust-serde" ,rust-serde))))
    (home-page "https://github.com/bluss/arrayvec")
    (synopsis
      "A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.")
    (description
      "This package provides a vector with fixed capacity, backed by an array (it can be stored on the stack too).  Implements fixed capacity ArrayVec and ArrayString.")
    (license #f)))

(define-public rust-stable-deref-trait
  (package
    (name "rust-stable-deref-trait")
    (version "1.1.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "stable_deref_trait" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1j2lkgakksmz4vc5hfawcch2ipiskrhjs1sih0f3br7s7rys58fv"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/storyyeller/stable_deref_trait")
    (synopsis
      "An unsafe marker trait for types like Box and Rc that dereference to a stable address even when moved, and hence can be used with libraries such as owning_ref and rental.
")
    (description
      "An unsafe marker trait for types like Box and Rc that dereference to a stable address even when moved, and hence can be used with libraries such as owning_ref and rental.
")
    (license #f)))

(define-public rust-goblin-0.0.22
  (package
    (name "rust-goblin")
    (version "0.0.22")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "goblin" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1a76i6zz71hjwd11pwmc8iirddj6345mfp02zl5d6bzb04sdambz"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-log" ,rust-log)
         ("rust-plain" ,rust-plain)
         ("rust-scroll-0.9.2" ,rust-scroll-0.9.2))))
    (home-page "https://github.com/m4b/goblin")
    (synopsis
      "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
    (description
      "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
    (license license:expat)))

(define-public rust-uuid-0.7.4
  (package
    (name "rust-uuid")
    (version "0.7.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "uuid" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0ank4xk20x3nrz926w8j9mz53bi3v8bykxmhlq2pffa8xc8wdnwh"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-byteorder" ,rust-byteorder)
         ("rust-md5-0.6.1" ,rust-md5-0.6.1)
         ("rust-rand-0.6.5" ,rust-rand-0.6.5)
         ("rust-serde" ,rust-serde)
         ("rust-sha1" ,rust-sha1)
         ("rust-slog" ,rust-slog)
         ("rust-winapi" ,rust-winapi))))
    (home-page "https://github.com/uuid-rs/uuid")
    (synopsis
      "A library to generate and parse UUIDs.")
    (description
      "This package provides a library to generate and parse UUIDs.")
    (license (list license:asl2.0 license:expat))))

(define-public rust-flate2
  (package
    (name "rust-flate2")
    (version "1.0.13")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "flate2" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "03rwyh691j20ih2vcskwp1sinhf9paggrkv32fvzwli9fpsddmkb"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cfg-if" ,rust-cfg-if)
         ("rust-crc32fast" ,rust-crc32fast)
         ("rust-futures-0.1.29" ,rust-futures-0.1.29)
         ("rust-libc" ,rust-libc)
         ("rust-libz-sys" ,rust-libz-sys)
         ("rust-miniz-oxide" ,rust-miniz-oxide)
         ("rust-miniz-oxide" ,rust-miniz-oxide)
         ("rust-miniz-sys" ,rust-miniz-sys)
         ("rust-tokio-io-0.1.12" ,rust-tokio-io-0.1.12))))
    (home-page
      "https://github.com/alexcrichton/flate2-rs")
    (synopsis
      "Bindings to miniz.c for DEFLATE compression and decompression exposed as
Reader/Writer streams. Contains bindings for zlib, deflate, and gzip-based
streams.
")
    (description
      "Bindings to miniz.c for DEFLATE compression and decompression exposed as
Reader/Writer streams.  Contains bindings for zlib, deflate, and gzip-based
streams.
")
    (license #f)))

(define-public rust-parity-wasm-0.38.0
  (package
    (name "rust-parity-wasm")
    (version "0.38.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "parity-wasm" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0qpfwb9adyi6g98q1w0xiqdzkv4r1p7b2w19wd5cr57rlwifbmr0"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/paritytech/parity-wasm")
    (synopsis "WebAssembly low-level format library")
    (description
      "WebAssembly low-level format library")
    (license #f)))

(define-public rust-xdg
  (package
    (name "rust-xdg")
    (version "2.2.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "xdg" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0mws8a0fr3cqk5nh7aq9lmkmhzghvasqy4mhw6nnza06l4d6i2fh"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/whitequark/rust-xdg")
    (synopsis
      "A library for storing and retrieving files according to XDG Base Directory specification")
    (description
      "This package provides a library for storing and retrieving files according to XDG Base Directory specification")
    (license #f)))

(define-public rust-xdg
  (package
    (name "rust-xdg")
    (version "2.2.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "xdg" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0mws8a0fr3cqk5nh7aq9lmkmhzghvasqy4mhw6nnza06l4d6i2fh"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/whitequark/rust-xdg")
    (synopsis
      "A library for storing and retrieving files according to XDG Base Directory specification")
    (description
      "This package provides a library for storing and retrieving files according to XDG Base Directory specification")
    (license #f)))

(define-public rust-scroll-derive-0.9.5
  (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 ".crate"))
        (sha256
          (base32
            "1jqg5mm8nvii6avl1z1rc89agzh2kwkppgpsnwfakxg78mnaj6lg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2-0.4.30"
          ,rust-proc-macro2-0.4.30)
         ("rust-quote-0.6.13" ,rust-quote-0.6.13)
         ("rust-syn-0.15.44" ,rust-syn-0.15.44))))
    (home-page "https://github.com/m4b/scroll")
    (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-cexpr
  (package
    (name "rust-cexpr")
    (version "0.3.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "cexpr" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "07fdfj4ff2974y33yixrb657riq9zl9b9h9lr0h7ridhhvxvbrgw"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-nom-4.2.3" ,rust-nom-4.2.3))))
    (home-page
      "https://github.com/jethrogb/rust-cexpr")
    (synopsis "A C expression parser and evaluator")
    (description
      "This package provides a C expression parser and evaluator")
    (license #f)))

(define-public rust-clang-sys-0.26.4
  (package
    (name "rust-clang-sys")
    (version "0.26.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "clang-sys" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1r50dwy5hj5gq07dn0qf8222d07qv0970ymx0j8n9779yayc3w3f"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-glob-0.2.11" ,rust-glob-0.2.11)
         ("rust-glob-0.2.11" ,rust-glob-0.2.11)
         ("rust-libc" ,rust-libc)
         ("rust-libloading" ,rust-libloading))))
    (home-page
      "https://github.com/KyleMayes/clang-sys")
    (synopsis "Rust bindings for libclang.")
    (description "Rust bindings for libclang.")
    (license license:asl2.0)))

(define-public rust-hashbrown-0.1.8
  (package
    (name "rust-hashbrown")
    (version "0.1.8")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "hashbrown" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1np350nrzysy021ndn2135q5vpzrp5nli78ywz114d1vcnv2kbiv"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-byteorder" ,rust-byteorder)
         ("rust-rayon" ,rust-rayon)
         ("rust-scopeguard-0.3.3" ,rust-scopeguard-0.3.3)
         ("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/rust-lang/hashbrown")
    (synopsis
      "A Rust port of Google's SwissTable hash map")
    (description
      "This package provides a Rust port of Google's SwissTable hash map")
    (license #f)))

(define-public rust-peeking-take-while
  (package
    (name "rust-peeking-take-while")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "peeking_take_while" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "16bhqr6rdyrp12zv381cxaaqqd0pwysvm1q8h2ygihvypvfprc8r"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/fitzgen/peeking_take_while")
    (synopsis
      "Like `Iterator::take_while`, but calls the predicate on a peeked value. This allows you to use `Iterator::by_ref` and `Iterator::take_while` together, and still get the first value for which the `take_while` predicate returned false after dropping the `by_ref`.")
    (description
      "Like `Iterator::take_while`, but calls the predicate on a peeked value.  This allows you to use `Iterator::by_ref` and `Iterator::take_while` together, and still get the first value for which the `take_while` predicate returned false after dropping the `by_ref`.")
    (license #f)))

(define-public rust-proc-macro2-0.4.30
  (package
    (name "rust-proc-macro2")
    (version "0.4.30")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "proc-macro2" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0nd71fl24sys066jrha6j7i34nfkjv44yzw8yww9742wmc8j0gfg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-unicode-xid-0.1.0"
          ,rust-unicode-xid-0.1.0))))
    (home-page
      "https://github.com/alexcrichton/proc-macro2")
    (synopsis
      "A stable implementation of the upcoming new `proc_macro` API. Comes with an
option, off by default, to also reimplement itself in terms of the upstream
unstable API.
")
    (description
      "This package provides a stable implementation of the upcoming new `proc_macro` API.  Comes with an
option, off by default, to also reimplement itself in terms of the upstream
unstable API.
")
    (license #f)))

(define-public rust-quote-0.6.13
  (package
    (name "rust-quote")
    (version "0.6.13")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "quote" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1qgqq48jymp5h4y082aanf25hrw6bpb678xh3zw993qfhxmkpqkc"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2-0.4.30"
          ,rust-proc-macro2-0.4.30))))
    (home-page "https://github.com/dtolnay/quote")
    (synopsis "Quasi-quoting macro quote!(...)")
    (description "Quasi-quoting macro quote!(...)")
    (license (list license:expat license:asl2.0))))

(define-public rust-regex
  (package
    (name "rust-regex")
    (version "1.3.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "regex" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1g8wp160vzxgralyd4imydd0xsxq6yh25zhs229z1s6w7g9hn8nw"))))
    (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-0.3.6"
          ,rust-thread-local-0.3.6))))
    (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 #f)))

(define-public rust-which-2.0.1
  (package
    (name "rust-which")
    (version "2.0.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "which" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0r7i793sc0xqnd2fxnqbksj7j1kx65bwn81b8z49750v4c8cnymm"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-failure" ,rust-failure)
         ("rust-libc" ,rust-libc))))
    (home-page
      "https://github.com/harryfei/which-rs.git")
    (synopsis
      "A Rust equivalent of Unix command \"which\". Locate installed executable in cross platforms.")
    (description
      "This package provides a Rust equivalent of Unix command \"which\".  Locate installed executable in cross platforms.")
    (license license:expat)))

(define-public rust-humantime
  (package
    (name "rust-humantime")
    (version "1.3.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "humantime" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0krwgbf35pd46xvkqg14j070vircsndabahahlv3rwhflpy4q06z"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-quick-error" ,rust-quick-error))))
    (home-page
      "https://github.com/tailhook/humantime")
    (synopsis
      "    A parser and formatter for std::time::{Duration, SystemTime}
")
    (description
      "    A parser and formatter for std::time::{Duration, SystemTime}
")
    (license #f)))

(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 ".crate"))
        (sha256
          (base32
            "0vjfsn1a8zvqhnrbygrz1id6yckwv1dncw3w4zj65qdx0f00kmln"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-wincolor" ,rust-wincolor))))
    (home-page
      "https://github.com/BurntSushi/termcolor")
    (synopsis
      "A simple cross platform 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-iovec-0.1.4
  (package
    (name "rust-iovec")
    (version "0.1.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "iovec" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0ph73qygwx8i0mblrf110cj59l00gkmsgrpzz1rm85syz5pymcxj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-libc" ,rust-libc))))
    (home-page "https://github.com/carllerche/iovec")
    (synopsis
      "Portable buffer type for scatter/gather I/O operations
")
    (description
      "Portable buffer type for scatter/gather I/O operations
")
    (license #f)))

(define-public rust-either
  (package
    (name "rust-either")
    (version "1.5.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "either" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1qyz1b1acad6w0k5928jw5zaq900zhsk7p8dlcp4hh61w4f6n7xv"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
    (home-page "https://github.com/bluss/either")
    (synopsis
      "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.
")
    (description
      "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.
")
    (license #f)))

(define-public rust-crossbeam-deque
  (package
    (name "rust-crossbeam-deque")
    (version "0.7.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "crossbeam-deque" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1jm3rqb3qfpfywrakyy81f61xnl4jsim7lam9digw6w6cdfr9an3"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-crossbeam-epoch" ,rust-crossbeam-epoch)
         ("rust-crossbeam-utils" ,rust-crossbeam-utils))))
    (home-page
      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-deque")
    (synopsis "Concurrent work-stealing deque")
    (description "Concurrent work-stealing deque")
    (license #f)))

(define-public rust-rayon-core
  (package
    (name "rust-rayon-core")
    (version "1.6.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "rayon-core" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "14a7gdi5lbf99ixy27wny25gq2w5kj5rbsrpqirm9c13dzg1ggzq"))))
    (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-lazy-static" ,rust-lazy-static)
         ("rust-num-cpus" ,rust-num-cpus))))
    (home-page "https://github.com/rayon-rs/rayon")
    (synopsis "Core APIs for Rayon")
    (description "Core APIs for Rayon")
    (license #f)))

(define-public rust-bumpalo
  (package
    (name "rust-bumpalo")
    (version "2.6.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "bumpalo" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "020psxs5dlm0gdbs83rx2rcavibdshdr0fpzk3mmw65zq8ppz05d"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/fitzgen/bumpalo")
    (synopsis
      "A fast bump allocation arena for Rust.")
    (description
      "This package provides a fast bump allocation arena for Rust.")
    (license #f)))

(define-public rust-nodrop
  (package
    (name "rust-nodrop")
    (version "0.1.14")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "nodrop" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1fz1v9r8ijacf0hlq0pdv5l9mz8vgqg1snmhvpjmi9aci1b4mvvj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-nodrop-union" ,rust-nodrop-union))))
    (home-page "https://github.com/bluss/arrayvec")
    (synopsis
      "A wrapper type to inhibit drop (destructor).

***Deprecated: Use ManuallyDrop or MaybeUninit instead!***
")
    (description
      "This package provides a wrapper type to inhibit drop (destructor).

***Deprecated: Use ManuallyDrop or MaybeUninit instead!***
")
    (license #f)))

(define-public rust-md5-0.6.1
  (package
    (name "rust-md5")
    (version "0.6.1")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "md5" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "17b2xm4h4cvxsdjsf3kdrzqv2za60kak961xzi5kmw6g6djcssvy"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/stainless-steel/md5")
    (synopsis
      "The package provides the MD5 hash function.")
    (description
      "The package provides the MD5 hash function.")
    (license #f)))

(define-public rust-slog
  (package
    (name "rust-slog")
    (version "2.5.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "slog" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "16bv6zrdn1sm315vbnia02g31xvsmbjyz5gv3z0vrgxdli0cdj8w"))))
    (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")
    (license (list #f 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 ".crate"))
        (sha256
          (base32
            "1c9dhkvf3brrzzplcijaywxi2w8wv5578i0ryhcm7x8dmzi5s4ms"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-cfg-if" ,rust-cfg-if))))
    (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:expat license:asl2.0))))

(define-public rust-miniz-oxide
  (package
    (name "rust-miniz-oxide")
    (version "0.3.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "miniz_oxide" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "09bnfn4bn3hcp912v5syphm4kjd0fdkwq023a4zmr4xf4vvp8gvg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-adler32" ,rust-adler32))))
    (home-page
      "https://github.com/Frommi/miniz_oxide/tree/master/miniz_oxide")
    (synopsis
      "DEFLATE compression and decompression library rewritten in Rust based on miniz")
    (description
      "DEFLATE compression and decompression library rewritten in Rust based on miniz")
    (license license:expat)))

(define-public rust-libz-sys
  (package
    (name "rust-libz-sys")
    (version "1.0.25")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "libz-sys" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1gjycyl2283525abks98bhxa4r259m617xfm5z52p3p3c8ry9d9f"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cc" ,rust-cc)
         ("rust-libc" ,rust-libc)
         ("rust-pkg-config" ,rust-pkg-config)
         ("rust-vcpkg" ,rust-vcpkg))))
    (home-page
      "https://github.com/alexcrichton/libz-sys")
    (synopsis
      "Bindings to the system libz library (also known as zlib).
")
    (description
      "Bindings to the system libz library (also known as zlib).
")
    (license #f)))

(define-public rust-miniz-oxide
  (package
    (name "rust-miniz-oxide")
    (version "0.3.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "miniz_oxide" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "09bnfn4bn3hcp912v5syphm4kjd0fdkwq023a4zmr4xf4vvp8gvg"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-adler32" ,rust-adler32))))
    (home-page
      "https://github.com/Frommi/miniz_oxide/tree/master/miniz_oxide")
    (synopsis
      "DEFLATE compression and decompression library rewritten in Rust based on miniz")
    (description
      "DEFLATE compression and decompression library rewritten in Rust based on miniz")
    (license license:expat)))

(define-public rust-miniz-sys
  (package
    (name "rust-miniz-sys")
    (version "0.1.12")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "miniz-sys" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "00l2r4anm8g35x0js2zfdnwfbrih9m43vphdpb77c5ga3kjkm7hy"))))
    (build-system cargo-build-system)
    (arguments
      `(#: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
      "Bindings to the miniz.c library.
")
    (license #f)))

(define-public rust-syn-0.15.44
  (package
    (name "rust-syn")
    (version "0.15.44")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "syn" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1id5g6x6zihv3j7hwrw3m1jp636bg8dpi671r7zy3jvpkavb794w"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-proc-macro2-0.4.30"
          ,rust-proc-macro2-0.4.30)
         ("rust-quote-0.6.13" ,rust-quote-0.6.13)
         ("rust-unicode-xid-0.1.0"
          ,rust-unicode-xid-0.1.0))))
    (home-page "https://github.com/dtolnay/syn")
    (synopsis "Parser for Rust source code")
    (description "Parser for Rust source code")
    (license (list license:expat license:asl2.0))))

(define-public rust-nom-4.2.3
  (package
    (name "rust-nom")
    (version "4.2.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "nom" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1mkvby8b4m61p4g1px0pwr58yfkphyp1jcfbp4qfp7l6iqdaklia"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-lazy-static" ,rust-lazy-static)
         ("rust-memchr" ,rust-memchr)
         ("rust-regex" ,rust-regex)
         ("rust-version-check-0.1.5"
          ,rust-version-check-0.1.5))))
    (home-page "https://github.com/Geal/nom")
    (synopsis
      "A byte-oriented, zero-copy, parser combinators library")
    (description
      "This package provides a byte-oriented, zero-copy, parser combinators library")
    (license license:expat)))

(define-public rust-glob-0.2.11
  (package
    (name "rust-glob")
    (version "0.2.11")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "glob" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1ysvi72slkw784fcsymgj4308c3y03gwjjzqxp80xdjnkbh8vqcb"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/glob")
    (synopsis
      "Support for matching file paths against Unix shell style patterns.
")
    (description
      "Support for matching file paths against Unix shell style patterns.
")
    (license #f)))

(define-public rust-glob-0.2.11
  (package
    (name "rust-glob")
    (version "0.2.11")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "glob" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1ysvi72slkw784fcsymgj4308c3y03gwjjzqxp80xdjnkbh8vqcb"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/glob")
    (synopsis
      "Support for matching file paths against Unix shell style patterns.
")
    (description
      "Support for matching file paths against Unix shell style patterns.
")
    (license #f)))

(define-public rust-libloading
  (package
    (name "rust-libloading")
    (version "0.5.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "libloading" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0lyply8rcqc8agajzxs7bq6ivba9dnn1i68kgb9z2flnfjh13cgj"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-cc" ,rust-cc)
         ("rust-winapi" ,rust-winapi))))
    (home-page
      "https://github.com/nagisa/rust_libloading/")
    (synopsis
      "A safer binding to platformâ\x80\x99s dynamic library loading utilities")
    (description
      "This package provides a safer binding to platformâ\x80\x99s dynamic library loading utilities")
    (license license:isc)))

(define-public rust-scopeguard-0.3.3
  (package
    (name "rust-scopeguard")
    (version "0.3.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "scopeguard" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "09sy9wbqp409pkwmqni40qmwa99ldqpl48pp95m1xw8sc19qy9cl"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/bluss/scopeguard")
    (synopsis
      "A RAII scope guard that will run a given closure when it goes out of scope,
even if the code between panics (assuming unwinding panic).

Defines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as
shorthands for guards with one of the implemented strategies.
")
    (description
      "This package provides a RAII scope guard that will run a given closure when it goes out of scope,
even if the code between panics (assuming unwinding panic).

Defines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as
shorthands for guards with one of the implemented strategies.
")
    (license #f)))

(define-public rust-unicode-xid-0.1.0
  (package
    (name "rust-unicode-xid")
    (version "0.1.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "unicode-xid" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1z57lqh4s18rr4x0j4fw4fmp9hf9346h0kmdgqsqx0fhjr3k0wpw"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/unicode-rs/unicode-xid")
    (synopsis
      "Determine whether characters have the XID_Start
or XID_Continue properties according to
Unicode Standard Annex #31.
")
    (description
      "Determine whether characters have the XID_Start
or XID_Continue properties according to
Unicode Standard Annex #31.
")
    (license #f)))

(define-public rust-regex-syntax
  (package
    (name "rust-regex-syntax")
    (version "0.6.12")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "regex-syntax" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "05pplicvzvgkb2wb4i98p2mrpgc8gws6vdl8xlpyyr6f3h6y59qi"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/rust-lang/regex")
    (synopsis "A regular expression parser.")
    (description
      "This package provides a regular expression parser.")
    (license #f)))

(define-public rust-aho-corasick
  (package
    (name "rust-aho-corasick")
    (version "0.7.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "aho-corasick" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0b8dh20fhdc59dhhnfi89n2bi80a8zbagzd5c122hf1vv2amxysq"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-memchr" ,rust-memchr))))
    (home-page
      "https://github.com/BurntSushi/aho-corasick")
    (synopsis "Fast multiple substring searching.")
    (description
      "Fast multiple substring searching.")
    (license #f)))

(define-public rust-thread-local-0.3.6
  (package
    (name "rust-thread-local")
    (version "0.3.6")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "thread_local" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "06rzik99p8c5js8238yhc8rk6np543ylb1dy9nrw5v80j0r3xdf6"))))
    (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 #f)))

(define-public rust-quick-error
  (package
    (name "rust-quick-error")
    (version "1.2.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "quick-error" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1w6kgwwv7p7zr0yyg5rb315lkk24bimywklwx7fsvsbwi10bjx4j"))))
    (build-system cargo-build-system)
    (home-page
      "http://github.com/tailhook/quick-error")
    (synopsis
      "    A macro which makes error types pleasant to write.
")
    (description
      "    A macro which makes error types pleasant to write.
")
    (license #f)))

(define-public rust-wincolor
  (package
    (name "rust-wincolor")
    (version "1.0.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "wincolor" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1agaf3hcav113i86912ajnw6jxcy4rvkrgyf8gdj8kc031mh3xcn"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-winapi" ,rust-winapi)
         ("rust-winapi-util" ,rust-winapi-util))))
    (home-page
      "https://github.com/BurntSushi/termcolor/tree/master/wincolor")
    (synopsis
      "A simple Windows specific API for controlling text color in a Windows console.
")
    (description
      "This package provides a simple Windows specific API for controlling text color in a Windows console.
")
    (license (list license:unlicense license:expat))))

(define-public rust-crossbeam-epoch
  (package
    (name "rust-crossbeam-epoch")
    (version "0.8.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "crossbeam-epoch" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1b2mgc2gxxvyzyxgd5wvn9k42gr6f9phi2swwjawpqswy3dynr2h"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-cfg-if" ,rust-cfg-if)
         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
         ("rust-lazy-static" ,rust-lazy-static)
         ("rust-memoffset" ,rust-memoffset)
         ("rust-scopeguard" ,rust-scopeguard))))
    (home-page
      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-epoch")
    (synopsis "Epoch-based garbage collection")
    (description "Epoch-based garbage collection")
    (license #f)))

(define-public rust-crossbeam-utils
  (package
    (name "rust-crossbeam-utils")
    (version "0.7.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "crossbeam-utils" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1x1rn35q2v05qif14ijfg7800d3rf3ji2cg79awnacfw5jq6si6f"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-autocfg" ,rust-autocfg)
         ("rust-cfg-if" ,rust-cfg-if)
         ("rust-lazy-static" ,rust-lazy-static))))
    (home-page
      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils")
    (synopsis "Utilities for concurrent programming")
    (description
      "Utilities for concurrent programming")
    (license #f)))

(define-public rust-crossbeam-queue
  (package
    (name "rust-crossbeam-queue")
    (version "0.2.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "crossbeam-queue" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "00177hj1anmb3fijm6lc95cncb19ad2kv0a2gf3jybd8cic53mnz"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-crossbeam-utils" ,rust-crossbeam-utils))))
    (home-page
      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils")
    (synopsis "Concurrent queues")
    (description "Concurrent queues")
    (license #f)))

(define-public rust-nodrop-union
  (package
    (name "rust-nodrop-union")
    (version "0.1.11")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "nodrop-union" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1h59pph19rxanyqcaid8pg73s7wmzdx3zhjv5snlim5qx606zxkc"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/bluss/arrayvec")
    (synopsis
      "A wrapper type to inhibit drop (destructor). Implementation crate for nodrop, the untagged unions implementation (which is unstable / requires nightly) as of this writing.

***Deprecated: Use ManuallyDrop or MaybeUninit instead!***
")
    (description
      "This package provides a wrapper type to inhibit drop (destructor).  Implementation crate for nodrop, the untagged unions implementation (which is unstable / requires nightly) as of this writing.

***Deprecated: Use ManuallyDrop or MaybeUninit instead!***
")
    (license #f)))

(define-public rust-erased-serde
  (package
    (name "rust-erased-serde")
    (version "0.3.9")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "erased-serde" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0q7bnxs5zskfq5iillig55g7891dllcxh2p8y8k1p2j72syf9viv"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
    (home-page
      "https://github.com/dtolnay/erased-serde")
    (synopsis
      "Type-erased Serialize and Serializer traits")
    (description
      "Type-erased Serialize and Serializer traits")
    (license #f)))

(define-public rust-adler32
  (package
    (name "rust-adler32")
    (version "1.0.4")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "adler32" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1hnan4fgmnidgn2k84hh2i67c3wp2c5iwd5hs61yi7gwwx1p6bjx"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/remram44/adler32-rs")
    (synopsis
      "Minimal Adler32 implementation for Rust.")
    (description
      "Minimal Adler32 implementation for Rust.")
    (license license:zlib)))

(define-public rust-pkg-config
  (package
    (name "rust-pkg-config")
    (version "0.3.17")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "pkg-config" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "0xynnaxdv0gzadlw4h79j855k0q7rj4zb9xb1vk00nc6ss559nh5"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/rust-lang/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
      "This package provides a library to run the pkg-config system tool at build time in order to be used in
Cargo build scripts.
")
    (license #f)))

(define-public rust-vcpkg
  (package
    (name "rust-vcpkg")
    (version "0.2.7")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "vcpkg" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "15dzk1b96q946v9aisbd1bbhi33n93wvgziwh1shmscn1xflbp9k"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/mcgoo/vcpkg-rs")
    (synopsis
      "A library to find native dependencies in a vcpkg tree at build
time in order to be used in Cargo build scripts.
")
    (description
      "This package provides a library to find native dependencies in a vcpkg tree at build
time in order to be used in Cargo build scripts.
")
    (license #f)))

(define-public rust-version-check-0.1.5
  (package
    (name "rust-version-check")
    (version "0.1.5")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "version_check" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1pf91pvj8n6akh7w6j5ypka6aqz08b3qpzgs0ak2kjf4frkiljwi"))))
    (build-system cargo-build-system)
    (home-page
      "https://github.com/SergioBenitez/version_check")
    (synopsis
      "Tiny crate to check the version of the installed/running rustc.")
    (description
      "Tiny crate to check the version of the installed/running rustc.")
    (license #f)))

(define-public rust-winapi-util
  (package
    (name "rust-winapi-util")
    (version "0.1.2")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "winapi-util" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1j839dc6y8vszvrsb7yk0qvs0w6asnahxzbyans37vnsw6vbls3i"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs (("rust-winapi" ,rust-winapi))))
    (home-page
      "https://github.com/BurntSushi/winapi-util")
    (synopsis
      "A dumping ground for high level safe wrappers over winapi.")
    (description
      "This package provides a dumping ground for high level safe wrappers over winapi.")
    (license #f)))

(define-public rust-memoffset
  (package
    (name "rust-memoffset")
    (version "0.5.3")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "memoffset" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "1fblqzc25hfaym8m0pj112s66pqq87avvaqm5hp5rskib2w9w63m"))))
    (build-system cargo-build-system)
    (arguments
      `(#:cargo-inputs
        (("rust-rustc-version" ,rust-rustc-version))))
    (home-page "https://github.com/Gilnaa/memoffset")
    (synopsis
      "offset_of functionality for Rust structs.")
    (description
      "offset_of functionality for Rust structs.")
    (license license:expat)))

(define-public rust-scopeguard
  (package
    (name "rust-scopeguard")
    (version "1.0.0")
    (source
      (origin
        (method url-fetch)
        (uri (crate-uri "scopeguard" version))
        (file-name
          (string-append name "-" version ".crate"))
        (sha256
          (base32
            "03aay84r1f6w87ckbpj6cc4rnsxkxcfs13n5ynxjia0qkgjiabml"))))
    (build-system cargo-build-system)
    (home-page "https://github.com/bluss/scopeguard")
    (synopsis
      "A RAII scope guard that will run a given closure when it goes out of scope,
even if the code between panics (assuming unwinding panic).

Defines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as
shorthands for guards with one of the implemented strategies.
")
    (description
      "This package provides a RAII scope guard that will run a given closure when it goes out of scope,
even if the code between panics (assuming unwinding panic).

Defines the macros `defer!`, `defer_on_unwind!`, `defer_on_success!` as
shorthands for guards with one of the implemented strategies.
")
    (license #f)))

rust-hello-cli