MPpiR8dB

1
2
3(use-modules (guix packages)
4	     (guix download)
5	     ;; (gnu packages ruby)
6	     (guix licenses)
7             (guix build-system crate))
8(define-public rust-serde-derive
9  (package
10    (name "rust-serde-derive")
11    (version "1.0.101")
12    (source
13      (origin
14        (method url-fetch)
15        (uri (crate-uri "serde_derive" version))
16        (file-name
17          (string-append name "-" version ".tar.gz"))
18        (sha256
19          (base32
20            "0bn0wz3j48248187mfmypyqnh73mq734snxxhr05vmgcl51kl4sb"))))
21    (build-system cargo-build-system)
22    (arguments
23      `(#:cargo-inputs
24        (("rust-proc-macro2" ,rust-proc-macro2)
25         ("rust-quote" ,rust-quote)
26         ("rust-syn" ,rust-syn))
27        #:cargo-development-inputs
28        (("rust-serde" ,rust-serde))))
29    (home-page "https://serde.rs")
30    (synopsis
31      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
32    (description
33      "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]")
34    (license (list license:expat license:asl2.0))))
35
36(define-public rust-serde
37  (package
38    (name "rust-serde")
39    (version "1.0.101")
40    (source
41      (origin
42        (method url-fetch)
43        (uri (crate-uri "serde" version))
44        (file-name
45          (string-append name "-" version ".tar.gz"))
46        (sha256
47          (base32
48            "1p8r24hagcsrl92w5z32nfrg9040qkgqf8iwwnf7mzigpavwk5lp"))))
49    (build-system cargo-build-system)
50    (arguments
51      `(#:cargo-inputs
52        (("rust-serde-derive" ,rust-serde-derive))
53        #:cargo-development-inputs
54        (("rust-serde-derive" ,rust-serde-derive))))
55    (home-page "https://serde.rs")
56    (synopsis
57      "A generic serialization/deserialization framework")
58    (description
59      "This package provides a generic serialization/deserialization framework")
60    (license (list license:expat license:asl2.0))))
61
62(define-public rust-clap
63  (package
64    (name "rust-clap")
65    (version "2.33.0")
66    (source
67      (origin
68        (method url-fetch)
69        (uri (crate-uri "clap" version))
70        (file-name
71          (string-append name "-" version ".tar.gz"))
72        (sha256
73          (base32
74            "1nf6ld3bims1n5vfzhkvcb55pdzh04bbhzf8nil5vvw05nxzarsh"))))
75    (build-system cargo-build-system)
76    (arguments
77      `(#:cargo-inputs
78        (("rust-ansi-term" ,rust-ansi-term)
79         ("rust-atty" ,rust-atty)
80         ("rust-bitflags" ,rust-bitflags)
81         ("rust-clippy" ,rust-clippy)
82         ("rust-strsim" ,rust-strsim)
83         ("rust-term-size" ,rust-term-size)
84         ("rust-textwrap" ,rust-textwrap)
85         ("rust-unicode-width" ,rust-unicode-width)
86         ("rust-vec-map" ,rust-vec-map)
87         ("rust-yaml-rust" ,rust-yaml-rust))
88        #:cargo-development-inputs
89        (("rust-lazy-static" ,rust-lazy-static)
90         ("rust-regex" ,rust-regex)
91         ("rust-version-sync" ,rust-version-sync))))
92    (home-page "https://clap.rs/")
93    (synopsis
94      "A simple to use, efficient, and full-featured Command Line Argument Parser
95")
96    (description
97      "This package provides a simple to use, efficient, and full-featured Command Line Argument Parser
98")
99    (license license:expat)))
100
101(define-public rust-automod
102  (package
103    (name "rust-automod")
104    (version "0.1.2")
105    (source
106      (origin
107        (method url-fetch)
108        (uri (crate-uri "automod" version))
109        (file-name
110          (string-append name "-" version ".tar.gz"))
111        (sha256
112          (base32
113            "17am5i7z7jpsrq9bm0wyhf4q9850g2kqvzl3ik900x5gc7brwv2a"))))
114    (build-system cargo-build-system)
115    (arguments
116      `(#:cargo-inputs
117        (("rust-proc-macro2" ,rust-proc-macro2)
118         ("rust-quote" ,rust-quote)
119         ("rust-syn" ,rust-syn))))
120    (home-page "https://github.com/dtolnay/automod")
121    (synopsis
122      "Pull in every source file in a directory as a module.")
123    (description
124      "Pull in every source file in a directory as a module.")
125    (license (list license:expat license:asl2.0))))
126
127(define-public rust-select-rustc
128  (package
129    (name "rust-select-rustc")
130    (version "0.1.2")
131    (source
132      (origin
133        (method url-fetch)
134        (uri (crate-uri "select-rustc" version))
135        (file-name
136          (string-append name "-" version ".tar.gz"))
137        (sha256
138          (base32
139            "0daqd56smi93g59nz43n4mh3d8whr6j5pa8dmwlf8bd76mdy3cpx"))))
140    (build-system cargo-build-system)
141    (arguments
142      `(#:cargo-inputs
143        (("rust-proc-macro2" ,rust-proc-macro2)
144         ("rust-quote" ,rust-quote)
145         ("rust-syn" ,rust-syn))))
146    (home-page
147      "https://github.com/dtolnay/select-rustc")
148    (synopsis
149      "Conditional compilation according to rustc compiler version")
150    (description
151      "Conditional compilation according to rustc compiler version")
152    (license (list license:expat license:asl2.0))))
153
154(define-public rust-serde-stacker
155  (package
156    (name "rust-serde-stacker")
157    (version "0.1.0")
158    (source
159      (origin
160        (method url-fetch)
161        (uri (crate-uri "serde_stacker" version))
162        (file-name
163          (string-append name "-" version ".tar.gz"))
164        (sha256
165          (base32
166            "1jn54i5m1mlc6nm47f96k85fgjs9mhpbbqa4dvd5xjbivkdw55ic"))))
167    (build-system cargo-build-system)
168    (arguments
169      `(#:cargo-inputs
170        (("rust-serde" ,rust-serde)
171         ("rust-stacker" ,rust-stacker))
172        #:cargo-development-inputs
173        (("rust-serde-json" ,rust-serde-json))))
174    (home-page
175      "https://github.com/dtolnay/serde-stacker")
176    (synopsis
177      "Serde adapter that avoids stack overflow by dynamically growing the stack")
178    (description
179      "Serde adapter that avoids stack overflow by dynamically growing the stack")
180    (license (list license:expat license:asl2.0))))
181
182(define-public rust-serde-json
183  (package
184    (name "rust-serde-json")
185    (version "1.0.40")
186    (source
187      (origin
188        (method url-fetch)
189        (uri (crate-uri "serde_json" version))
190        (file-name
191          (string-append name "-" version ".tar.gz"))
192        (sha256
193          (base32
194            "010pa89zx07aqx1cwgw2a603wcp3q5n2iy0k71ppqbr8kwi4j705"))))
195    (build-system cargo-build-system)
196    (arguments
197      `(#:cargo-inputs
198        (("rust-indexmap" ,rust-indexmap)
199         ("rust-itoa" ,rust-itoa)
200         ("rust-ryu" ,rust-ryu)
201         ("rust-serde" ,rust-serde))
202        #:cargo-development-inputs
203        (("rust-automod" ,rust-automod)
204         ("rust-select-rustc" ,rust-select-rustc)
205         ("rust-serde-bytes" ,rust-serde-bytes)
206         ("rust-serde-derive" ,rust-serde-derive)
207         ("rust-serde-stacker" ,rust-serde-stacker)
208         ("rust-trybuild" ,rust-trybuild))))
209    (home-page "https://github.com/serde-rs/json")
210    (synopsis "A JSON serialization file format")
211    (description
212      "This package provides a JSON serialization file format")
213    (license (list license:expat license:asl2.0))))
214
215(define-public rust-regex
216  (package
217    (name "rust-regex")
218    (version "1.3.1")
219    (source
220      (origin
221        (method url-fetch)
222        (uri (crate-uri "regex" version))
223        (file-name
224          (string-append name "-" version ".tar.gz"))
225        (sha256
226          (base32
227            "1g8wp160vzxgralyd4imydd0xsxq6yh25zhs229z1s6w7g9hn8nw"))))
228    (build-system cargo-build-system)
229    (arguments
230      `(#:cargo-inputs
231        (("rust-aho-corasick" ,rust-aho-corasick)
232         ("rust-memchr" ,rust-memchr)
233         ("rust-regex-syntax" ,rust-regex-syntax)
234         ("rust-thread-local" ,rust-thread-local))
235        #:cargo-development-inputs
236        (("rust-doc-comment" ,rust-doc-comment)
237         ("rust-lazy-static" ,rust-lazy-static)
238         ("rust-quickcheck" ,rust-quickcheck)
239         ("rust-rand" ,rust-rand))))
240    (home-page "https://github.com/rust-lang/regex")
241    (synopsis
242      "An implementation of regular expressions for Rust. This implementation uses
243finite automata and guarantees linear time matching on all inputs.
244")
245    (description
246      "An implementation of regular expressions for Rust.  This implementation uses
247finite automata and guarantees linear time matching on all inputs.
248")
249    (license #f)))
250
251(define-public rust-jemallocator
252  (package
253    (name "rust-jemallocator")
254    (version "0.3.2")
255    (source
256      (origin
257        (method url-fetch)
258        (uri (crate-uri "jemallocator" version))
259        (file-name
260          (string-append name "-" version ".tar.gz"))
261        (sha256
262          (base32
263            "0sabfa5118b7l4ars5n36s2fjyfn59w4d6mjs6rrmsa5zky67bj3"))))
264    (build-system cargo-build-system)
265    (arguments
266      `(#:cargo-inputs
267        (("rust-jemalloc-sys" ,rust-jemalloc-sys)
268         ("rust-libc" ,rust-libc))
269        #:cargo-development-inputs
270        (("rust-paste" ,rust-paste))))
271    (home-page
272      "https://github.com/gnzlbg/jemallocator")
273    (synopsis
274      "A Rust allocator backed by jemalloc
275")
276    (description
277      "This package provides a Rust allocator backed by jemalloc
278")
279    (license #f)))
280
281(define-public rust-ignore
282  (package
283    (name "rust-ignore")
284    (version "0.4.10")
285    (source
286      (origin
287        (method url-fetch)
288        (uri (crate-uri "ignore" version))
289        (file-name
290          (string-append name "-" version ".tar.gz"))
291        (sha256
292          (base32
293            "19w4iwq1f01v1wd9s5afg06hcnycqgrp70pgm9qxa2c44lr6ih8f"))))
294    (build-system cargo-build-system)
295    (arguments
296      `(#:cargo-inputs
297        (("rust-crossbeam-channel"
298          ,rust-crossbeam-channel)
299         ("rust-globset" ,rust-globset)
300         ("rust-lazy-static" ,rust-lazy-static)
301         ("rust-log" ,rust-log)
302         ("rust-memchr" ,rust-memchr)
303         ("rust-regex" ,rust-regex)
304         ("rust-same-file" ,rust-same-file)
305         ("rust-thread-local" ,rust-thread-local)
306         ("rust-walkdir" ,rust-walkdir)
307         ("rust-winapi-util" ,rust-winapi-util))))
308    (home-page
309      "https://github.com/BurntSushi/ripgrep/tree/master/ignore")
310    (synopsis
311      "A fast library for efficiently matching ignore files such as `.gitignore`
312against file paths.
313")
314    (description
315      "This package provides a fast library for efficiently matching ignore files such as `.gitignore`
316against file paths.
317")
318    (license #f)))
319
320(define-public rust-globset
321  (package
322    (name "rust-globset")
323    (version "0.4.4")
324    (source
325      (origin
326        (method url-fetch)
327        (uri (crate-uri "globset" version))
328        (file-name
329          (string-append name "-" version ".tar.gz"))
330        (sha256
331          (base32
332            "1wnqxq91liknmr2w93wjq2spyxbrd1pmnhd4nbi3921dr35a4nlj"))))
333    (build-system cargo-build-system)
334    (arguments
335      `(#:cargo-inputs
336        (("rust-aho-corasick" ,rust-aho-corasick)
337         ("rust-bstr" ,rust-bstr)
338         ("rust-fnv" ,rust-fnv)
339         ("rust-log" ,rust-log)
340         ("rust-regex" ,rust-regex))
341        #:cargo-development-inputs
342        (("rust-glob" ,rust-glob))))
343    (home-page
344      "https://github.com/BurntSushi/ripgrep/tree/master/globset")
345    (synopsis
346      "Cross platform single glob and glob set matching. Glob set matching is the
347process of matching one or more glob patterns against a single candidate path
348simultaneously, and returning all of the globs that matched.
349")
350    (description
351      "Cross platform single glob and glob set matching.  Glob set matching is the
352process of matching one or more glob patterns against a single candidate path
353simultaneously, and returning all of the globs that matched.
354")
355    (license #f)))
356
357(define-public rust-grep-cli
358  (package
359    (name "rust-grep-cli")
360    (version "0.1.3")
361    (source
362      (origin
363        (method url-fetch)
364        (uri (crate-uri "grep-cli" version))
365        (file-name
366          (string-append name "-" version ".tar.gz"))
367        (sha256
368          (base32
369            "05a502x5m4fijwx7zj9icxna2dx86scm76ap80zr89pnvpbfk1hp"))))
370    (build-system cargo-build-system)
371    (arguments
372      `(#:cargo-inputs
373        (("rust-atty" ,rust-atty)
374         ("rust-bstr" ,rust-bstr)
375         ("rust-globset" ,rust-globset)
376         ("rust-lazy-static" ,rust-lazy-static)
377         ("rust-log" ,rust-log)
378         ("rust-regex" ,rust-regex)
379         ("rust-same-file" ,rust-same-file)
380         ("rust-termcolor" ,rust-termcolor)
381         ("rust-winapi-util" ,rust-winapi-util))))
382    (home-page
383      "https://github.com/BurntSushi/ripgrep")
384    (synopsis
385      "Utilities for search oriented command line applications.
386")
387    (description
388      "Utilities for search oriented command line applications.
389")
390    (license #f)))
391
392(define-public rust-grep-matcher
393  (package
394    (name "rust-grep-matcher")
395    (version "0.1.3")
396    (source
397      (origin
398        (method url-fetch)
399        (uri (crate-uri "grep-matcher" version))
400        (file-name
401          (string-append name "-" version ".tar.gz"))
402        (sha256
403          (base32
404            "113lafx3abrr96ahpz6yn905ian1w3qsr5hijbb909p2j0xgmhkm"))))
405    (build-system cargo-build-system)
406    (arguments
407      `(#:cargo-inputs
408        (("rust-memchr" ,rust-memchr))
409        #:cargo-development-inputs
410        (("rust-regex" ,rust-regex))))
411    (home-page
412      "https://github.com/BurntSushi/ripgrep")
413    (synopsis
414      "A trait for regular expressions, with a focus on line oriented search.
415")
416    (description
417      "This package provides a trait for regular expressions, with a focus on line oriented search.
418")
419    (license #f)))
420
421(define-public rust-pcre2-sys
422  (package
423    (name "rust-pcre2-sys")
424    (version "0.2.2")
425    (source
426      (origin
427        (method url-fetch)
428        (uri (crate-uri "pcre2-sys" version))
429        (file-name
430          (string-append name "-" version ".tar.gz"))
431        (sha256
432          (base32
433            "0nwdvc43dkb89qmm5q8gw1zyll0wsfqw7kczpn23mljra3874v47"))))
434    (build-system cargo-build-system)
435    (arguments
436      `(#:cargo-inputs
437        (("rust-libc" ,rust-libc))
438        #:cargo-development-inputs
439        (("rust-cc" ,rust-cc)
440         ("rust-pkg-config" ,rust-pkg-config))))
441    (home-page
442      "https://github.com/BurntSushi/rust-pcre2")
443    (synopsis "Low level bindings to PCRE2.")
444    (description "Low level bindings to PCRE2.")
445    (license #f)))
446
447(define-public rust-pcre2
448  (package
449    (name "rust-pcre2")
450    (version "0.2.2")
451    (source
452      (origin
453        (method url-fetch)
454        (uri (crate-uri "pcre2" version))
455        (file-name
456          (string-append name "-" version ".tar.gz"))
457        (sha256
458          (base32
459            "0hk4q7s71w1iiijq5c69z44n8anhk0bpi14wrm7v4h7ch9rc8xq8"))))
460    (build-system cargo-build-system)
461    (arguments
462      `(#:cargo-inputs
463        (("rust-libc" ,rust-libc)
464         ("rust-log" ,rust-log)
465         ("rust-pcre2-sys" ,rust-pcre2-sys)
466         ("rust-thread-local" ,rust-thread-local))))
467    (home-page
468      "https://github.com/BurntSushi/rust-pcre2")
469    (synopsis
470      "High level wrapper library for PCRE2.")
471    (description
472      "High level wrapper library for PCRE2.")
473    (license #f)))
474
475(define-public rust-grep-pcre2
476  (package
477    (name "rust-grep-pcre2")
478    (version "0.1.3")
479    (source
480      (origin
481        (method url-fetch)
482        (uri (crate-uri "grep-pcre2" version))
483        (file-name
484          (string-append name "-" version ".tar.gz"))
485        (sha256
486          (base32
487            "1wjc3gsan20gapga8nji6jcrmwn9n85q5zf2yfq6g50c7abkc2ql"))))
488    (build-system cargo-build-system)
489    (arguments
490      `(#:cargo-inputs
491        (("rust-grep-matcher" ,rust-grep-matcher)
492         ("rust-pcre2" ,rust-pcre2))))
493    (home-page
494      "https://github.com/BurntSushi/ripgrep")
495    (synopsis "Use PCRE2 with the 'grep' crate.
496")
497    (description
498      "Use PCRE2 with the 'grep' crate.
499")
500    (license #f)))
501
502(define-public rust-grep-printer
503  (package
504    (name "rust-grep-printer")
505    (version "0.1.3")
506    (source
507      (origin
508        (method url-fetch)
509        (uri (crate-uri "grep-printer" version))
510        (file-name
511          (string-append name "-" version ".tar.gz"))
512        (sha256
513          (base32
514            "0mxc1yx5sx89f00imlm5d3hxwdgglv9rzwdki8ba50gvq8a2nr8m"))))
515    (build-system cargo-build-system)
516    (arguments
517      `(#:cargo-inputs
518        (("rust-base64" ,rust-base64)
519         ("rust-bstr" ,rust-bstr)
520         ("rust-grep-matcher" ,rust-grep-matcher)
521         ("rust-grep-searcher" ,rust-grep-searcher)
522         ("rust-serde" ,rust-serde)
523         ("rust-serde-derive" ,rust-serde-derive)
524         ("rust-serde-json" ,rust-serde-json)
525         ("rust-termcolor" ,rust-termcolor))
526        #:cargo-development-inputs
527        (("rust-grep-regex" ,rust-grep-regex))))
528    (home-page
529      "https://github.com/BurntSushi/ripgrep")
530    (synopsis
531      "An implementation of the grep crate's Sink trait that provides standard
532printing of search results, similar to grep itself.
533")
534    (description
535      "An implementation of the grep crate's Sink trait that provides standard
536printing of search results, similar to grep itself.
537")
538    (license #f)))
539
540(define-public rust-aho-corasick
541  (package
542    (name "rust-aho-corasick")
543    (version "0.7.6")
544    (source
545      (origin
546        (method url-fetch)
547        (uri (crate-uri "aho-corasick" version))
548        (file-name
549          (string-append name "-" version ".tar.gz"))
550        (sha256
551          (base32
552            "0b8dh20fhdc59dhhnfi89n2bi80a8zbagzd5c122hf1vv2amxysq"))))
553    (build-system cargo-build-system)
554    (arguments
555      `(#:cargo-inputs
556        (("rust-memchr" ,rust-memchr))
557        #:cargo-development-inputs
558        (("rust-doc-comment" ,rust-doc-comment))))
559    (home-page
560      "https://github.com/BurntSushi/aho-corasick")
561    (synopsis "Fast multiple substring searching.")
562    (description
563      "Fast multiple substring searching.")
564    (license #f)))
565
566(define-public rust-grep-regex
567  (package
568    (name "rust-grep-regex")
569    (version "0.1.5")
570    (source
571      (origin
572        (method url-fetch)
573        (uri (crate-uri "grep-regex" version))
574        (file-name
575          (string-append name "-" version ".tar.gz"))
576        (sha256
577          (base32
578            "0afl67ikb42phn6fryxv2mmj97zb75llynr92fgzhin879c4vmm0"))))
579    (build-system cargo-build-system)
580    (arguments
581      `(#:cargo-inputs
582        (("rust-aho-corasick" ,rust-aho-corasick)
583         ("rust-grep-matcher" ,rust-grep-matcher)
584         ("rust-log" ,rust-log)
585         ("rust-regex" ,rust-regex)
586         ("rust-regex-syntax" ,rust-regex-syntax)
587         ("rust-thread-local" ,rust-thread-local))))
588    (home-page
589      "https://github.com/BurntSushi/ripgrep")
590    (synopsis
591      "Use Rust's regex library with the 'grep' crate.
592")
593    (description
594      "Use Rust's regex library with the 'grep' crate.
595")
596    (license #f)))
597
598(define-public rust-bytecount
599  (package
600    (name "rust-bytecount")
601    (version "0.6.0")
602    (source
603      (origin
604        (method url-fetch)
605        (uri (crate-uri "bytecount" version))
606        (file-name
607          (string-append name "-" version ".tar.gz"))
608        (sha256
609          (base32
610            "0vplsx73zncb7mz8x0fs3k0p0rz5bmavj09vjk5nqn4z6fa7h0dh"))))
611    (build-system cargo-build-system)
612    (arguments
613      `(#:cargo-inputs
614        (("rust-packed-simd" ,rust-packed-simd))
615        #:cargo-development-inputs
616        (("rust-criterion" ,rust-criterion)
617         ("rust-quickcheck" ,rust-quickcheck)
618         ("rust-rand" ,rust-rand))))
619    (home-page "https://github.com/llogiq/bytecount")
620    (synopsis
621      "count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast")
622    (description
623      "count occurrences of a given byte, or the number of UTF-8 code points, in a byte slice, fast")
624    (license #f)))
625
626(define-public rust-encoding-rs-io
627  (package
628    (name "rust-encoding-rs-io")
629    (version "0.1.6")
630    (source
631      (origin
632        (method url-fetch)
633        (uri (crate-uri "encoding_rs_io" version))
634        (file-name
635          (string-append name "-" version ".tar.gz"))
636        (sha256
637          (base32
638            "0b7k9p7inkrcanh7h6q4m278y05gmcwi8p5r43h7grzl5dxfw6cn"))))
639    (build-system cargo-build-system)
640    (arguments
641      `(#:cargo-inputs
642        (("rust-encoding-rs" ,rust-encoding-rs))))
643    (home-page
644      "https://github.com/BurntSushi/encoding_rs_io")
645    (synopsis
646      "Streaming transcoding for encoding_rs")
647    (description
648      "Streaming transcoding for encoding_rs")
649    (license (list license:expat license:asl2.0))))
650
651(define-public rust-grep-searcher
652  (package
653    (name "rust-grep-searcher")
654    (version "0.1.6")
655    (source
656      (origin
657        (method url-fetch)
658        (uri (crate-uri "grep-searcher" version))
659        (file-name
660          (string-append name "-" version ".tar.gz"))
661        (sha256
662          (base32
663            "09ag16im12v6k0lzkyvbvamn1iw15kfx1jbfldb7z5xa7208l04a"))))
664    (build-system cargo-build-system)
665    (arguments
666      `(#:cargo-inputs
667        (("rust-bstr" ,rust-bstr)
668         ("rust-bytecount" ,rust-bytecount)
669         ("rust-encoding-rs" ,rust-encoding-rs)
670         ("rust-encoding-rs-io" ,rust-encoding-rs-io)
671         ("rust-grep-matcher" ,rust-grep-matcher)
672         ("rust-log" ,rust-log)
673         ("rust-memmap" ,rust-memmap))
674        #:cargo-development-inputs
675        (("rust-grep-regex" ,rust-grep-regex)
676         ("rust-regex" ,rust-regex))))
677    (home-page
678      "https://github.com/BurntSushi/ripgrep")
679    (synopsis
680      "Fast line oriented regex searching as a library.
681")
682    (description
683      "Fast line oriented regex searching as a library.
684")
685    (license #f)))
686
687(define-public rust-grep
688  (package
689    (name "rust-grep")
690    (version "0.2.4")
691    (source
692      (origin
693        (method url-fetch)
694        (uri (crate-uri "grep" version))
695        (file-name
696          (string-append name "-" version ".tar.gz"))
697        (sha256
698          (base32
699            "1pkhjladybzzciwg0mjk3vjz5fyi76hk0d3hgyzv2jxlyp8v4fyc"))))
700    (build-system cargo-build-system)
701    (arguments
702      `(#:cargo-inputs
703        (("rust-grep-cli" ,rust-grep-cli)
704         ("rust-grep-matcher" ,rust-grep-matcher)
705         ("rust-grep-pcre2" ,rust-grep-pcre2)
706         ("rust-grep-printer" ,rust-grep-printer)
707         ("rust-grep-regex" ,rust-grep-regex)
708         ("rust-grep-searcher" ,rust-grep-searcher))
709        #:cargo-development-inputs
710        (("rust-termcolor" ,rust-termcolor)
711         ("rust-walkdir" ,rust-walkdir))))
712    (home-page
713      "https://github.com/BurntSushi/ripgrep")
714    (synopsis
715      "Fast line oriented regex searching as a library.
716")
717    (description
718      "Fast line oriented regex searching as a library.
719")
720    (license #f)))
721
722(define-public rust-term-size
723  (package
724    (name "rust-term-size")
725    (version "1.0.0-beta1")
726    (source
727      (origin
728        (method url-fetch)
729        (uri (crate-uri "term_size" version))
730        (file-name
731          (string-append name "-" version ".tar.gz"))
732        (sha256
733          (base32
734            "13w9cqjhzh3mmx6zami8lxyf42xx53yy866zxhxqcm71k637v8d8"))))
735    (build-system cargo-build-system)
736    (arguments
737      `(#:cargo-inputs
738        (("rust-clippy" ,rust-clippy)
739         ("rust-kernel32-sys" ,rust-kernel32-sys)
740         ("rust-libc" ,rust-libc)
741         ("rust-winapi" ,rust-winapi))))
742    (home-page
743      "https://github.com/kbknapp/term_size-rs.git")
744    (synopsis
745      "functions for determining terminal sizes and dimensions")
746    (description
747      "functions for determining terminal sizes and dimensions")
748    (license #f)))
749
750(define-public rust-fst-levenshtein
751  (package
752    (name "rust-fst-levenshtein")
753    (version "0.2.1")
754    (source
755      (origin
756        (method url-fetch)
757        (uri (crate-uri "fst-levenshtein" version))
758        (file-name
759          (string-append name "-" version ".tar.gz"))
760        (sha256
761          (base32
762            "1s5ml10442bbnpmilmwjh4pfixsj6837rg68vjzg63i3djd4524y"))))
763    (build-system cargo-build-system)
764    (arguments
765      `(#:cargo-inputs
766        (("rust-fst" ,rust-fst)
767         ("rust-utf8-ranges" ,rust-utf8-ranges))))
768    (home-page "https://github.com/BurntSushi/fst")
769    (synopsis
770      "Search finite state transducers with fuzzy queries using Levenshtein automata.
771")
772    (description
773      "Search finite state transducers with fuzzy queries using Levenshtein automata.
774")
775    (license #f)))
776
777(define-public rust-fst-regex
778  (package
779    (name "rust-fst-regex")
780    (version "0.2.2")
781    (source
782      (origin
783        (method url-fetch)
784        (uri (crate-uri "fst-regex" version))
785        (file-name
786          (string-append name "-" version ".tar.gz"))
787        (sha256
788          (base32
789            "126xrv3s8mrq8nqsahmpy0nlks6l3wlivqyf6a0i4g7d3vcs3b47"))))
790    (build-system cargo-build-system)
791    (arguments
792      `(#:cargo-inputs
793        (("rust-fst" ,rust-fst)
794         ("rust-regex-syntax" ,rust-regex-syntax)
795         ("rust-utf8-ranges" ,rust-utf8-ranges))))
796    (home-page "https://github.com/BurntSushi/fst")
797    (synopsis
798      "Search finite state transducers with regular expression.
799")
800    (description
801      "Search finite state transducers with regular expression.
802")
803    (license #f)))
804
805(define-public rust-fst
806  (package
807    (name "rust-fst")
808    (version "0.3.5")
809    (source
810      (origin
811        (method url-fetch)
812        (uri (crate-uri "fst" version))
813        (file-name
814          (string-append name "-" version ".tar.gz"))
815        (sha256
816          (base32
817            "1mpby7wa5mkpgjiilam94a2l9mxx9wpgs3nw2nr1a0czzwsb8zwj"))))
818    (build-system cargo-build-system)
819    (arguments
820      `(#:cargo-inputs
821        (("rust-byteorder" ,rust-byteorder)
822         ("rust-memmap" ,rust-memmap))
823        #:cargo-development-inputs
824        (("rust-fnv" ,rust-fnv)
825         ("rust-fst-levenshtein" ,rust-fst-levenshtein)
826         ("rust-fst-regex" ,rust-fst-regex)
827         ("rust-lazy-static" ,rust-lazy-static)
828         ("rust-quickcheck" ,rust-quickcheck)
829         ("rust-rand" ,rust-rand))))
830    (home-page "https://github.com/BurntSushi/fst")
831    (synopsis
832      "Use finite state transducers to compactly represents sets or maps of many
833strings (> 1 billion is possible).
834")
835    (description
836      "Use finite state transducers to compactly represents sets or maps of many
837strings (> 1 billion is possible).
838")
839    (license #f)))
840
841(define-public rust-atlatl
842  (package
843    (name "rust-atlatl")
844    (version "0.1.2")
845    (source
846      (origin
847        (method url-fetch)
848        (uri (crate-uri "atlatl" version))
849        (file-name
850          (string-append name "-" version ".tar.gz"))
851        (sha256
852          (base32
853            "18kyvdm56fdb52b1sryi80xgs3nkjdylynsv324aiqnj85l1bfrj"))))
854    (build-system cargo-build-system)
855    (arguments
856      `(#:cargo-inputs
857        (("rust-fnv" ,rust-fnv)
858         ("rust-num-traits" ,rust-num-traits)
859         ("rust-serde" ,rust-serde))
860        #:cargo-development-inputs
861        (("rust-fst" ,rust-fst)
862         ("rust-lazy-static" ,rust-lazy-static)
863         ("rust-quickcheck" ,rust-quickcheck)
864         ("rust-rand" ,rust-rand))))
865    (home-page
866      "https://github.com/tapeinosyne/atlatl")
867    (synopsis "Double-array tries.")
868    (description "Double-array tries.")
869    (license #f)))
870
871(define-public rust-hyphenation-commons
872  (package
873    (name "rust-hyphenation-commons")
874    (version "0.7.1")
875    (source
876      (origin
877        (method url-fetch)
878        (uri (crate-uri "hyphenation_commons" version))
879        (file-name
880          (string-append name "-" version ".tar.gz"))
881        (sha256
882          (base32
883            "1pasnbk3rbdgf30jjjh1h24a9pxpdrnn0ihcivmpnzqha6mn2d4y"))))
884    (build-system cargo-build-system)
885    (arguments
886      `(#:cargo-inputs
887        (("rust-atlatl" ,rust-atlatl)
888         ("rust-serde" ,rust-serde))))
889    (home-page
890      "https://github.com/tapeinosyne/hyphenation")
891    (synopsis
892      "Proemial code for the `hyphenation` library")
893    (description
894      "Proemial code for the `hyphenation` library")
895    (license #f)))
896
897(define-public rust-hyphenation
898  (package
899    (name "rust-hyphenation")
900    (version "0.7.1")
901    (source
902      (origin
903        (method url-fetch)
904        (uri (crate-uri "hyphenation" version))
905        (file-name
906          (string-append name "-" version ".tar.gz"))
907        (sha256
908          (base32
909            "0k5msv8calmnfd5kw1rmq4bg5hn1vcd39kbsxl57sdld63xwd4q4"))))
910    (build-system cargo-build-system)
911    (arguments
912      `(#:cargo-inputs
913        (("rust-atlatl" ,rust-atlatl)
914         ("rust-bincode" ,rust-bincode)
915         ("rust-hyphenation-commons"
916          ,rust-hyphenation-commons)
917         ("rust-serde" ,rust-serde))
918        #:cargo-development-inputs
919        (("rust-atlatl" ,rust-atlatl)
920         ("rust-bincode" ,rust-bincode)
921         ("rust-hyphenation-commons"
922          ,rust-hyphenation-commons)
923         ("rust-lazy-static" ,rust-lazy-static)
924         ("rust-pocket-resources" ,rust-pocket-resources)
925         ("rust-quickcheck" ,rust-quickcheck)
926         ("rust-serde" ,rust-serde)
927         ("rust-unicode-normalization"
928          ,rust-unicode-normalization)
929         ("rust-unicode-segmentation"
930          ,rust-unicode-segmentation))))
931    (home-page
932      "https://github.com/tapeinosyne/hyphenation")
933    (synopsis
934      "Knuth-Liang hyphenation for a variety of languages")
935    (description
936      "Knuth-Liang hyphenation for a variety of languages")
937    (license #f)))
938
939(define-public rust-lipsum
940  (package
941    (name "rust-lipsum")
942    (version "0.6.0")
943    (source
944      (origin
945        (method url-fetch)
946        (uri (crate-uri "lipsum" version))
947        (file-name
948          (string-append name "-" version ".tar.gz"))
949        (sha256
950          (base32
951            "0nlxkz8zjxqmbrxqasr36a5fqn2n33cxy11w0x0a0b6mcx04dr2q"))))
952    (build-system cargo-build-system)
953    (arguments
954      `(#:cargo-inputs
955        (("rust-rand" ,rust-rand))
956        #:cargo-development-inputs
957        (("rust-rand-xorshift" ,rust-rand-xorshift)
958         ("rust-version-sync" ,rust-version-sync))))
959    (home-page "https://github.com/mgeisler/lipsum/")
960    (synopsis
961      "Lipsum is a lorem ipsum text generation library. Use this if you need
962some filler text for your application.
963
964The text is generated using a simple Markov chain, which you can also
965instantiate to generate your own pieces of pseudo-random text.
966")
967    (description
968      "Lipsum is a lorem ipsum text generation library.  Use this if you need
969some filler text for your application.
970
971The text is generated using a simple Markov chain, which you can also
972instantiate to generate your own pieces of pseudo-random text.
973")
974    (license license:expat)))
975
976(define-public rust-textwrap
977  (package
978    (name "rust-textwrap")
979    (version "0.11.0")
980    (source
981      (origin
982        (method url-fetch)
983        (uri (crate-uri "textwrap" version))
984        (file-name
985          (string-append name "-" version ".tar.gz"))
986        (sha256
987          (base32
988            "0q5hky03ik3y50s9sz25r438bc4nwhqc6dqwynv4wylc807n29nk"))))
989    (build-system cargo-build-system)
990    (arguments
991      `(#:cargo-inputs
992        (("rust-hyphenation" ,rust-hyphenation)
993         ("rust-term-size" ,rust-term-size)
994         ("rust-unicode-width" ,rust-unicode-width))
995        #:cargo-development-inputs
996        (("rust-lipsum" ,rust-lipsum)
997         ("rust-rand" ,rust-rand)
998         ("rust-rand-xorshift" ,rust-rand-xorshift)
999         ("rust-version-sync" ,rust-version-sync))))
1000    (home-page
1001      "https://github.com/mgeisler/textwrap")
1002    (synopsis
1003      "Textwrap is a small library for word wrapping, indenting, and
1004dedenting strings.
1005
1006You can use it to format strings (such as help and error messages) for
1007display in commandline applications. It is designed to be efficient
1008and handle Unicode characters correctly.
1009")
1010    (description
1011      "Textwrap is a small library for word wrapping, indenting, and
1012dedenting strings.
1013
1014You can use it to format strings (such as help and error messages) for
1015display in commandline applications.  It is designed to be efficient
1016and handle Unicode characters correctly.
1017")
1018    (license license:expat)))
1019
1020(define-public rust-vec-map
1021  (package
1022    (name "rust-vec-map")
1023    (version "0.8.1")
1024    (source
1025      (origin
1026        (method url-fetch)
1027        (uri (crate-uri "vec_map" version))
1028        (file-name
1029          (string-append name "-" version ".tar.gz"))
1030        (sha256
1031          (base32
1032            "06n8hw4hlbcz328a3gbpvmy0ma46vg1lc0r5wf55900szf3qdiq5"))))
1033    (build-system cargo-build-system)
1034    (arguments
1035      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
1036    (home-page
1037      "https://github.com/contain-rs/vec-map")
1038    (synopsis
1039      "A simple map based on a vector for small integer keys")
1040    (description
1041      "This package provides a simple map based on a vector for small integer keys")
1042    (license #f)))
1043
1044(define-public rust-clap
1045  (package
1046    (name "rust-clap")
1047    (version "2.33.0")
1048    (source
1049      (origin
1050        (method url-fetch)
1051        (uri (crate-uri "clap" version))
1052        (file-name
1053          (string-append name "-" version ".tar.gz"))
1054        (sha256
1055          (base32
1056            "1nf6ld3bims1n5vfzhkvcb55pdzh04bbhzf8nil5vvw05nxzarsh"))))
1057    (build-system cargo-build-system)
1058    (arguments
1059      `(#:cargo-inputs
1060        (("rust-ansi-term" ,rust-ansi-term)
1061         ("rust-atty" ,rust-atty)
1062         ("rust-bitflags" ,rust-bitflags)
1063         ("rust-clippy" ,rust-clippy)
1064         ("rust-strsim" ,rust-strsim)
1065         ("rust-term-size" ,rust-term-size)
1066         ("rust-textwrap" ,rust-textwrap)
1067         ("rust-unicode-width" ,rust-unicode-width)
1068         ("rust-vec-map" ,rust-vec-map)
1069         ("rust-yaml-rust" ,rust-yaml-rust))
1070        #:cargo-development-inputs
1071        (("rust-lazy-static" ,rust-lazy-static)
1072         ("rust-regex" ,rust-regex)
1073         ("rust-version-sync" ,rust-version-sync))))
1074    (home-page "https://clap.rs/")
1075    (synopsis
1076      "A simple to use, efficient, and full-featured Command Line Argument Parser
1077")
1078    (description
1079      "This package provides a simple to use, efficient, and full-featured Command Line Argument Parser
1080")
1081    (license license:expat)))
1082
1083(define-public rust-memchr
1084  (package
1085    (name "rust-memchr")
1086    (version "2.2.1")
1087    (source
1088      (origin
1089        (method url-fetch)
1090        (uri (crate-uri "memchr" version))
1091        (file-name
1092          (string-append name "-" version ".tar.gz"))
1093        (sha256
1094          (base32
1095            "13j6ji9x9ydpi9grbss106gqqr3xn3bcfp28aydqfa4751qrfmw8"))))
1096    (build-system cargo-build-system)
1097    (arguments
1098      `(#:cargo-inputs
1099        (("rust-libc" ,rust-libc))
1100        #:cargo-development-inputs
1101        (("rust-quickcheck" ,rust-quickcheck))))
1102    (home-page
1103      "https://github.com/BurntSushi/rust-memchr")
1104    (synopsis "Safe interface to memchr.")
1105    (description "Safe interface to memchr.")
1106    (license #f)))
1107
1108(define-public rust-utf8-ranges
1109  (package
1110    (name "rust-utf8-ranges")
1111    (version "1.0.4")
1112    (source
1113      (origin
1114        (method url-fetch)
1115        (uri (crate-uri "utf8-ranges" version))
1116        (file-name
1117          (string-append name "-" version ".tar.gz"))
1118        (sha256
1119          (base32
1120            "1fpc32znar5v02nwsw7icl41jzzzzhy0si6ngqjylzrbxxpi3bml"))))
1121    (build-system cargo-build-system)
1122    (arguments
1123      `(#:cargo-development-inputs
1124        (("rust-doc-comment" ,rust-doc-comment)
1125         ("rust-quickcheck" ,rust-quickcheck))))
1126    (home-page
1127      "https://github.com/BurntSushi/utf8-ranges")
1128    (synopsis
1129      "DEPRECATED. Use regex-syntax::utf8 submodule instead.")
1130    (description
1131      "DEPRECATED.  Use regex-syntax::utf8 submodule instead.")
1132    (license #f)))
1133
1134(define-public rust-regex-automata
1135  (package
1136    (name "rust-regex-automata")
1137    (version "0.1.8")
1138    (source
1139      (origin
1140        (method url-fetch)
1141        (uri (crate-uri "regex-automata" version))
1142        (file-name
1143          (string-append name "-" version ".tar.gz"))
1144        (sha256
1145          (base32
1146            "1y89vkwd9z7797lsdsizvhw4lw7i1mhfx97a8315bhkh2wm3rdwj"))))
1147    (build-system cargo-build-system)
1148    (arguments
1149      `(#:cargo-inputs
1150        (("rust-byteorder" ,rust-byteorder)
1151         ("rust-regex-syntax" ,rust-regex-syntax)
1152         ("rust-utf8-ranges" ,rust-utf8-ranges))
1153        #:cargo-development-inputs
1154        (("rust-lazy-static" ,rust-lazy-static)
1155         ("rust-regex" ,rust-regex)
1156         ("rust-serde" ,rust-serde)
1157         ("rust-serde-bytes" ,rust-serde-bytes)
1158         ("rust-serde-derive" ,rust-serde-derive)
1159         ("rust-toml" ,rust-toml))))
1160    (home-page
1161      "https://github.com/BurntSushi/regex-automata")
1162    (synopsis
1163      "Automata construction and matching using regular expressions.")
1164    (description
1165      "Automata construction and matching using regular expressions.")
1166    (license #f)))
1167
1168(define-public rust-chrono
1169  (package
1170    (name "rust-chrono")
1171    (version "0.4.9")
1172    (source
1173      (origin
1174        (method url-fetch)
1175        (uri (crate-uri "chrono" version))
1176        (file-name
1177          (string-append name "-" version ".tar.gz"))
1178        (sha256
1179          (base32
1180            "0s5xbn4im53169bnqbcr4qvnyn44frplvc0v7hcv10w5jrb30jg8"))))
1181    (build-system cargo-build-system)
1182    (arguments
1183      `(#:cargo-inputs
1184        (("rust-js-sys" ,rust-js-sys)
1185         ("rust-libc" ,rust-libc)
1186         ("rust-num-integer" ,rust-num-integer)
1187         ("rust-num-traits" ,rust-num-traits)
1188         ("rust-rustc-serialize" ,rust-rustc-serialize)
1189         ("rust-serde" ,rust-serde)
1190         ("rust-time" ,rust-time)
1191         ("rust-wasm-bindgen" ,rust-wasm-bindgen))
1192        #:cargo-development-inputs
1193        (("rust-bincode" ,rust-bincode)
1194         ("rust-doc-comment" ,rust-doc-comment)
1195         ("rust-num-iter" ,rust-num-iter)
1196         ("rust-serde-derive" ,rust-serde-derive)
1197         ("rust-serde-json" ,rust-serde-json)
1198         ("rust-wasm-bindgen-test"
1199          ,rust-wasm-bindgen-test))))
1200    (home-page
1201      "https://github.com/chronotope/chrono")
1202    (synopsis "Date and time library for Rust")
1203    (description "Date and time library for Rust")
1204    (license #f)))
1205
1206(define-public rust-humantime
1207  (package
1208    (name "rust-humantime")
1209    (version "1.3.0")
1210    (source
1211      (origin
1212        (method url-fetch)
1213        (uri (crate-uri "humantime" version))
1214        (file-name
1215          (string-append name "-" version ".tar.gz"))
1216        (sha256
1217          (base32
1218            "0krwgbf35pd46xvkqg14j070vircsndabahahlv3rwhflpy4q06z"))))
1219    (build-system cargo-build-system)
1220    (arguments
1221      `(#:cargo-inputs
1222        (("rust-quick-error" ,rust-quick-error))
1223        #:cargo-development-inputs
1224        (("rust-chrono" ,rust-chrono)
1225         ("rust-rand" ,rust-rand)
1226         ("rust-time" ,rust-time))))
1227    (home-page
1228      "https://github.com/tailhook/humantime")
1229    (synopsis
1230      "    A parser and formatter for std::time::{Duration, SystemTime}
1231")
1232    (description
1233      "    A parser and formatter for std::time::{Duration, SystemTime}
1234")
1235    (license #f)))
1236
1237(define-public rust-env-logger
1238  (package
1239    (name "rust-env-logger")
1240    (version "0.7.0")
1241    (source
1242      (origin
1243        (method url-fetch)
1244        (uri (crate-uri "env_logger" version))
1245        (file-name
1246          (string-append name "-" version ".tar.gz"))
1247        (sha256
1248          (base32
1249            "1ynqjpx717mdwjv31835hqhklpyxnbindmjn19pm4ra4smyxpv1r"))))
1250    (build-system cargo-build-system)
1251    (arguments
1252      `(#:cargo-inputs
1253        (("rust-atty" ,rust-atty)
1254         ("rust-humantime" ,rust-humantime)
1255         ("rust-log" ,rust-log)
1256         ("rust-regex" ,rust-regex)
1257         ("rust-termcolor" ,rust-termcolor))))
1258    (home-page
1259      "https://github.com/sebasmagri/env_logger/")
1260    (synopsis
1261      "A logging implementation for `log` which is configured via an environment
1262variable.
1263")
1264    (description
1265      "This package provides a logging implementation for `log` which is configured via an environment
1266variable.
1267")
1268    (license #f)))
1269
1270(define-public rust-compiler-builtins
1271  (package
1272    (name "rust-compiler-builtins")
1273    (version "0.1.19")
1274    (source
1275      (origin
1276        (method url-fetch)
1277        (uri (crate-uri "compiler_builtins" version))
1278        (file-name
1279          (string-append name "-" version ".tar.gz"))
1280        (sha256
1281          (base32
1282            "1fpabpmg8paj4r5a37vmidh1jx1b7a6ilxm4s3xsxczx27ybjcjf"))))
1283    (build-system cargo-build-system)
1284    (arguments
1285      `(#:cargo-inputs
1286        (("rust-rustc-std-workspace-core"
1287          ,rust-rustc-std-workspace-core))
1288        #:cargo-development-inputs
1289        (("rust-cc" ,rust-cc))))
1290    (home-page
1291      "https://github.com/rust-lang-nursery/compiler-builtins")
1292    (synopsis
1293      "Compiler intrinsics used by the Rust compiler. Also available for other targets
1294if necessary!
1295")
1296    (description
1297      "Compiler intrinsics used by the Rust compiler.  Also available for other targets
1298if necessary!
1299")
1300    (license #f)))
1301
1302(define-public rust-stdweb-derive
1303  (package
1304    (name "rust-stdweb-derive")
1305    (version "0.5.2")
1306    (source
1307      (origin
1308        (method url-fetch)
1309        (uri (crate-uri "stdweb-derive" version))
1310        (file-name
1311          (string-append name "-" version ".tar.gz"))
1312        (sha256
1313          (base32
1314            "06qv17pp8myab8lqna2v082mrx5m900h79543kmn197fvwj67snv"))))
1315    (build-system cargo-build-system)
1316    (arguments
1317      `(#:cargo-inputs
1318        (("rust-proc-macro2" ,rust-proc-macro2)
1319         ("rust-quote" ,rust-quote)
1320         ("rust-serde" ,rust-serde)
1321         ("rust-serde-derive" ,rust-serde-derive)
1322         ("rust-syn" ,rust-syn))))
1323    (home-page "https://github.com/koute/stdweb")
1324    (synopsis "Derive macros for the `stdweb` crate")
1325    (description
1326      "Derive macros for the `stdweb` crate")
1327    (license #f)))
1328
1329(define-public rust-stdweb-internal-macros
1330  (package
1331    (name "rust-stdweb-internal-macros")
1332    (version "0.2.8")
1333    (source
1334      (origin
1335        (method url-fetch)
1336        (uri (crate-uri "stdweb-internal-macros" version))
1337        (file-name
1338          (string-append name "-" version ".tar.gz"))
1339        (sha256
1340          (base32
1341            "1s9ywlqbw70q868qn86sx7dfn82kmhbkr6b1kcxc9jlngrzarf32"))))
1342    (build-system cargo-build-system)
1343    (arguments
1344      `(#:cargo-inputs
1345        (("rust-base-x" ,rust-base-x)
1346         ("rust-proc-macro2" ,rust-proc-macro2)
1347         ("rust-quote" ,rust-quote)
1348         ("rust-serde" ,rust-serde)
1349         ("rust-serde-derive" ,rust-serde-derive)
1350         ("rust-serde-json" ,rust-serde-json)
1351         ("rust-sha1" ,rust-sha1)
1352         ("rust-syn" ,rust-syn))))
1353    (home-page "https://github.com/koute/stdweb")
1354    (synopsis
1355      "Internal procedural macros for the `stdweb` crate")
1356    (description
1357      "Internal procedural macros for the `stdweb` crate")
1358    (license #f)))
1359
1360(define-public rust-stdweb
1361  (package
1362    (name "rust-stdweb")
1363    (version "0.4.19")
1364    (source
1365      (origin
1366        (method url-fetch)
1367        (uri (crate-uri "stdweb" version))
1368        (file-name
1369          (string-append name "-" version ".tar.gz"))
1370        (sha256
1371          (base32
1372            "00pgs78pyp9qlv14axjd8cnbbs5y7dkaxfwmiwl6pxdhkrcm3w3y"))))
1373    (build-system cargo-build-system)
1374    (arguments
1375      `(#:cargo-inputs
1376        (("rust-discard" ,rust-discard)
1377         ("rust-futures-channel-preview"
1378          ,rust-futures-channel-preview)
1379         ("rust-futures-core-preview"
1380          ,rust-futures-core-preview)
1381         ("rust-futures-executor-preview"
1382          ,rust-futures-executor-preview)
1383         ("rust-futures-util-preview"
1384          ,rust-futures-util-preview)
1385         ("rust-serde" ,rust-serde)
1386         ("rust-serde-json" ,rust-serde-json)
1387         ("rust-stdweb-derive" ,rust-stdweb-derive)
1388         ("rust-stdweb-internal-macros"
1389          ,rust-stdweb-internal-macros)
1390         ("rust-stdweb-internal-runtime"
1391          ,rust-stdweb-internal-runtime)
1392         ("rust-wasm-bindgen" ,rust-wasm-bindgen))
1393        #:cargo-development-inputs
1394        (("rust-rustc-version" ,rust-rustc-version)
1395         ("rust-serde-derive" ,rust-serde-derive)
1396         ("rust-serde-json" ,rust-serde-json)
1397         ("rust-stdweb-internal-test-macro"
1398          ,rust-stdweb-internal-test-macro)
1399         ("rust-wasm-bindgen-test"
1400          ,rust-wasm-bindgen-test))))
1401    (home-page "https://github.com/koute/stdweb")
1402    (synopsis
1403      "A standard library for the client-side Web")
1404    (description
1405      "This package provides a standard library for the client-side Web")
1406    (license #f)))
1407
1408(define-public rust-wasm-bindgen-macro-support
1409  (package
1410    (name "rust-wasm-bindgen-macro-support")
1411    (version "0.2.51")
1412    (source
1413      (origin
1414        (method url-fetch)
1415        (uri (crate-uri "wasm-bindgen-macro-support" version))
1416        (file-name
1417          (string-append name "-" version ".tar.gz"))
1418        (sha256
1419          (base32
1420            "1ibgni8qgwh3ks2jnhkx8y64zrhk6n665zkp1z56h74rnwkms1ww"))))
1421    (build-system cargo-build-system)
1422    (arguments
1423      `(#:cargo-inputs
1424        (("rust-proc-macro2" ,rust-proc-macro2)
1425         ("rust-quote" ,rust-quote)
1426         ("rust-syn" ,rust-syn)
1427         ("rust-wasm-bindgen-backend"
1428          ,rust-wasm-bindgen-backend)
1429         ("rust-wasm-bindgen-shared"
1430          ,rust-wasm-bindgen-shared))))
1431    (home-page
1432      "https://rustwasm.github.io/wasm-bindgen/")
1433    (synopsis
1434      "The part of the implementation of the `#[wasm_bindgen]` attribute that is not in the shared backend crate
1435")
1436    (description
1437      "The part of the implementation of the `#[wasm_bindgen]` attribute that is not in the shared backend crate
1438")
1439    (license #f)))
1440
1441(define-public rust-trybuild
1442  (package
1443    (name "rust-trybuild")
1444    (version "1.0.16")
1445    (source
1446      (origin
1447        (method url-fetch)
1448        (uri (crate-uri "trybuild" version))
1449        (file-name
1450          (string-append name "-" version ".tar.gz"))
1451        (sha256
1452          (base32
1453            "0s5f3fan58341caajd4xjicfgp3g31g01aiglvw5ynhw49kg7n0h"))))
1454    (build-system cargo-build-system)
1455    (arguments
1456      `(#:cargo-inputs
1457        (("rust-glob" ,rust-glob)
1458         ("rust-lazy-static" ,rust-lazy-static)
1459         ("rust-serde" ,rust-serde)
1460         ("rust-serde-json" ,rust-serde-json)
1461         ("rust-termcolor" ,rust-termcolor)
1462         ("rust-toml" ,rust-toml))))
1463    (home-page "https://github.com/dtolnay/trybuild")
1464    (synopsis
1465      "Test harness for ui tests of compiler diagnostics")
1466    (description
1467      "Test harness for ui tests of compiler diagnostics")
1468    (license (list license:expat license:asl2.0))))
1469
1470(define-public rust-js-sys
1471  (package
1472    (name "rust-js-sys")
1473    (version "0.3.28")
1474    (source
1475      (origin
1476        (method url-fetch)
1477        (uri (crate-uri "js-sys" version))
1478        (file-name
1479          (string-append name "-" version ".tar.gz"))
1480        (sha256
1481          (base32
1482            "0y9wnjk30hg2anvy4hdlp7703h7iklgpr2mjv27i4c7cgiyskj9c"))))
1483    (build-system cargo-build-system)
1484    (arguments
1485      `(#:cargo-inputs
1486        (("rust-wasm-bindgen" ,rust-wasm-bindgen))
1487        #:cargo-development-inputs
1488        (("rust-wasm-bindgen-futures"
1489          ,rust-wasm-bindgen-futures)
1490         ("rust-wasm-bindgen-test"
1491          ,rust-wasm-bindgen-test))))
1492    (home-page
1493      "https://rustwasm.github.io/wasm-bindgen/")
1494    (synopsis
1495      "Bindings for all JS global objects and functions in all JS environments like
1496Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.
1497")
1498    (description
1499      "Bindings for all JS global objects and functions in all JS environments like
1500Node.js and browsers, built on `#[wasm_bindgen]` using the `wasm-bindgen` crate.
1501")
1502    (license #f)))
1503
1504(define-public rust-failure
1505  (package
1506    (name "rust-failure")
1507    (version "0.1.5")
1508    (source
1509      (origin
1510        (method url-fetch)
1511        (uri (crate-uri "failure" version))
1512        (file-name
1513          (string-append name "-" version ".tar.gz"))
1514        (sha256
1515          (base32
1516            "1qppmgv4i5jj6vrss91qackqnl0a12h7lnby4l7j5fdy78yxhnvr"))))
1517    (build-system cargo-build-system)
1518    (arguments
1519      `(#:cargo-inputs
1520        (("rust-backtrace" ,rust-backtrace)
1521         ("rust-failure-derive" ,rust-failure-derive))))
1522    (home-page
1523      "https://rust-lang-nursery.github.io/failure/")
1524    (synopsis
1525      "Experimental error handling abstraction.")
1526    (description
1527      "Experimental error handling abstraction.")
1528    (license (list license:expat license:asl2.0))))
1529
1530(define-public rust-heck
1531  (package
1532    (name "rust-heck")
1533    (version "0.3.1")
1534    (source
1535      (origin
1536        (method url-fetch)
1537        (uri (crate-uri "heck" version))
1538        (file-name
1539          (string-append name "-" version ".tar.gz"))
1540        (sha256
1541          (base32
1542            "01a2v7yvkiqxakdqz4hw3w3g4sm52ivz9cs3qcsv2arxsmw4wmi0"))))
1543    (build-system cargo-build-system)
1544    (arguments
1545      `(#:cargo-inputs
1546        (("rust-unicode-segmentation"
1547          ,rust-unicode-segmentation))))
1548    (home-page
1549      "https://github.com/withoutboats/heck")
1550    (synopsis "heck is a case conversion library.")
1551    (description
1552      "heck is a case conversion library.")
1553    (license (list license:expat license:asl2.0))))
1554
1555(define-public rust-ascii
1556  (package
1557    (name "rust-ascii")
1558    (version "1.0.0")
1559    (source
1560      (origin
1561        (method url-fetch)
1562        (uri (crate-uri "ascii" version))
1563        (file-name
1564          (string-append name "-" version ".tar.gz"))
1565        (sha256
1566          (base32
1567            "0281gc828q4j692gb66jfdr5k16gyszgqflylh0pp30rllv63xdv"))))
1568    (build-system cargo-build-system)
1569    (arguments
1570      `(#:cargo-inputs
1571        (("rust-serde" ,rust-serde)
1572         ("rust-serde-test" ,rust-serde-test))))
1573    (home-page
1574      "https://github.com/tomprogrammer/rust-ascii")
1575    (synopsis
1576      "ASCII-only equivalents to `char`, `str` and `String`.")
1577    (description
1578      "ASCII-only equivalents to `char`, `str` and `String`.")
1579    (license #f)))
1580
1581(define-public rust-encode-unicode
1582  (package
1583    (name "rust-encode-unicode")
1584    (version "0.3.6")
1585    (source
1586      (origin
1587        (method url-fetch)
1588        (uri (crate-uri "encode_unicode" version))
1589        (file-name
1590          (string-append name "-" version ".tar.gz"))
1591        (sha256
1592          (base32
1593            "07w3vzrhxh9lpjgsg2y5bwzfar2aq35mdznvcp3zjl0ssj7d4mx3"))))
1594    (build-system cargo-build-system)
1595    (arguments
1596      `(#:cargo-inputs
1597        (("rust-ascii" ,rust-ascii)
1598         ("rust-clippy" ,rust-clippy))
1599        #:cargo-development-inputs
1600        (("rust-lazy-static" ,rust-lazy-static))))
1601    (home-page
1602      "https://github.com/tormol/encode_unicode")
1603    (synopsis
1604      "UTF-8 and UTF-16 character types, iterators and related methods for char, u8 and u16.
1605")
1606    (description
1607      "UTF-8 and UTF-16 character types, iterators and related methods for char, u8 and u16.
1608")
1609    (license #f)))
1610
1611(define-public rust-console
1612  (package
1613    (name "rust-console")
1614    (version "0.9.0")
1615    (source
1616      (origin
1617        (method url-fetch)
1618        (uri (crate-uri "console" version))
1619        (file-name
1620          (string-append name "-" version ".tar.gz"))
1621        (sha256
1622          (base32
1623            "04jnkydhhf7zlyxrzfjcfmzziwvarv346nnmscqqr3x1rx8qz0k2"))))
1624    (build-system cargo-build-system)
1625    (arguments
1626      `(#:cargo-inputs
1627        (("rust-clicolors-control"
1628          ,rust-clicolors-control)
1629         ("rust-encode-unicode" ,rust-encode-unicode)
1630         ("rust-lazy-static" ,rust-lazy-static)
1631         ("rust-libc" ,rust-libc)
1632         ("rust-regex" ,rust-regex)
1633         ("rust-termios" ,rust-termios)
1634         ("rust-unicode-width" ,rust-unicode-width)
1635         ("rust-winapi" ,rust-winapi))))
1636    (home-page
1637      "https://github.com/mitsuhiko/console")
1638    (synopsis
1639      "A terminal and console abstraction for Rust")
1640    (description
1641      "This package provides a terminal and console abstraction for Rust")
1642    (license license:expat)))
1643
1644(define-public rust-pest
1645  (package
1646    (name "rust-pest")
1647    (version "2.1.2")
1648    (source
1649      (origin
1650        (method url-fetch)
1651        (uri (crate-uri "pest" version))
1652        (file-name
1653          (string-append name "-" version ".tar.gz"))
1654        (sha256
1655          (base32
1656            "0jl9nv6jx1jy3fz2j49nw7jkh9z5igvrbvsgnbc5aan2ql0v4kvy"))))
1657    (build-system cargo-build-system)
1658    (arguments
1659      `(#:cargo-inputs
1660        (("rust-serde" ,rust-serde)
1661         ("rust-serde-json" ,rust-serde-json)
1662         ("rust-ucd-trie" ,rust-ucd-trie))))
1663    (home-page "https://pest-parser.github.io/")
1664    (synopsis "The Elegant Parser")
1665    (description "The Elegant Parser")
1666    (license #f)))
1667
1668(define-public rust-block-padding
1669  (package
1670    (name "rust-block-padding")
1671    (version "0.1.4")
1672    (source
1673      (origin
1674        (method url-fetch)
1675        (uri (crate-uri "block-padding" version))
1676        (file-name
1677          (string-append name "-" version ".tar.gz"))
1678        (sha256
1679          (base32
1680            "02fz9wx5dmgpc79ndrb9xfxqlrkk7lg5wki2blz2zqg27spw6kbd"))))
1681    (build-system cargo-build-system)
1682    (arguments
1683      `(#:cargo-inputs
1684        (("rust-byte-tools" ,rust-byte-tools))))
1685    (home-page "https://github.com/RustCrypto/utils")
1686    (synopsis
1687      "Padding and unpadding of messages divided into blocks.")
1688    (description
1689      "Padding and unpadding of messages divided into blocks.")
1690    (license (list license:expat license:asl2.0))))
1691
1692(define-public rust-byte-tools
1693  (package
1694    (name "rust-byte-tools")
1695    (version "0.3.1")
1696    (source
1697      (origin
1698        (method url-fetch)
1699        (uri (crate-uri "byte-tools" version))
1700        (file-name
1701          (string-append name "-" version ".tar.gz"))
1702        (sha256
1703          (base32
1704            "1mqi29wsm8njpl51pfwr31wmpzs5ahlcb40wsjyd92l90ixcmdg3"))))
1705    (build-system cargo-build-system)
1706    (home-page "https://github.com/RustCrypto/utils")
1707    (synopsis "Bytes related utility functions")
1708    (description "Bytes related utility functions")
1709    (license (list license:expat license:asl2.0))))
1710
1711(define-public rust-block-buffer
1712  (package
1713    (name "rust-block-buffer")
1714    (version "0.7.3")
1715    (source
1716      (origin
1717        (method url-fetch)
1718        (uri (crate-uri "block-buffer" version))
1719        (file-name
1720          (string-append name "-" version ".tar.gz"))
1721        (sha256
1722          (base32
1723            "12v8wizynqin0hqf140kmp9s38q223mp1b0hkqk8j5pk8720v560"))))
1724    (build-system cargo-build-system)
1725    (arguments
1726      `(#:cargo-inputs
1727        (("rust-block-padding" ,rust-block-padding)
1728         ("rust-byte-tools" ,rust-byte-tools)
1729         ("rust-byteorder" ,rust-byteorder)
1730         ("rust-generic-array" ,rust-generic-array))))
1731    (home-page "https://github.com/RustCrypto/utils")
1732    (synopsis
1733      "Fixed size buffer for block processing of data")
1734    (description
1735      "Fixed size buffer for block processing of data")
1736    (license (list license:expat license:asl2.0))))
1737
1738(define-public rust-digest
1739  (package
1740    (name "rust-digest")
1741    (version "0.8.1")
1742    (source
1743      (origin
1744        (method url-fetch)
1745        (uri (crate-uri "digest" version))
1746        (file-name
1747          (string-append name "-" version ".tar.gz"))
1748        (sha256
1749          (base32
1750            "1madjl27f3kj5ql7kwgvb9c8b7yb7bv7yfgx7rqzj4i3fp4cil7k"))))
1751    (build-system cargo-build-system)
1752    (arguments
1753      `(#:cargo-inputs
1754        (("rust-blobby" ,rust-blobby)
1755         ("rust-generic-array" ,rust-generic-array))))
1756    (home-page
1757      "https://github.com/RustCrypto/traits")
1758    (synopsis
1759      "Traits for cryptographic hash functions")
1760    (description
1761      "Traits for cryptographic hash functions")
1762    (license (list license:expat license:asl2.0))))
1763
1764(define-public rust-fake-simd
1765  (package
1766    (name "rust-fake-simd")
1767    (version "0.1.2")
1768    (source
1769      (origin
1770        (method url-fetch)
1771        (uri (crate-uri "fake-simd" version))
1772        (file-name
1773          (string-append name "-" version ".tar.gz"))
1774        (sha256
1775          (base32
1776            "1vfylvk4va2ivqx85603lyqqp0zk52cgbs4n5nfbbbqx577qm2p8"))))
1777    (build-system cargo-build-system)
1778    (home-page "https://github.com/RustCrypto/utils")
1779    (synopsis
1780      "Crate for mimicking simd crate on stable Rust")
1781    (description
1782      "Crate for mimicking simd crate on stable Rust")
1783    (license #f)))
1784
1785(define-public rust-opaque-debug
1786  (package
1787    (name "rust-opaque-debug")
1788    (version "0.2.3")
1789    (source
1790      (origin
1791        (method url-fetch)
1792        (uri (crate-uri "opaque-debug" version))
1793        (file-name
1794          (string-append name "-" version ".tar.gz"))
1795        (sha256
1796          (base32
1797            "172j6bs8ndclqxa2m64qc0y1772rr73g4l9fg2svscgicnbfff98"))))
1798    (build-system cargo-build-system)
1799    (home-page "https://github.com/RustCrypto/utils")
1800    (synopsis
1801      "Macro for opaque Debug trait implementation")
1802    (description
1803      "Macro for opaque Debug trait implementation")
1804    (license (list license:expat license:asl2.0))))
1805
1806(define-public rust-sha1-asm
1807  (package
1808    (name "rust-sha1-asm")
1809    (version "0.4.3")
1810    (source
1811      (origin
1812        (method url-fetch)
1813        (uri (crate-uri "sha1-asm" version))
1814        (file-name
1815          (string-append name "-" version ".tar.gz"))
1816        (sha256
1817          (base32
1818            "1i1i8viy6y30mv9v5hwhg9w6b722qkyh9c6n8bn4d27jpv14pg0s"))))
1819    (build-system cargo-build-system)
1820    (arguments
1821      `(#:cargo-development-inputs
1822        (("rust-cc" ,rust-cc))))
1823    (home-page
1824      "https://github.com/RustCrypto/asm-hashes")
1825    (synopsis
1826      "Assembly implementation of SHA-1 compression function")
1827    (description
1828      "Assembly implementation of SHA-1 compression function")
1829    (license license:expat)))
1830
1831(define-public rust-sha-1
1832  (package
1833    (name "rust-sha-1")
1834    (version "0.8.1")
1835    (source
1836      (origin
1837        (method url-fetch)
1838        (uri (crate-uri "sha-1" version))
1839        (file-name
1840          (string-append name "-" version ".tar.gz"))
1841        (sha256
1842          (base32
1843            "0s6fdy5wp3x4h2z4fcl2d9vjvrpzr87v4h49r51xcq8nm4qj35i3"))))
1844    (build-system cargo-build-system)
1845    (arguments
1846      `(#:cargo-inputs
1847        (("rust-block-buffer" ,rust-block-buffer)
1848         ("rust-digest" ,rust-digest)
1849         ("rust-fake-simd" ,rust-fake-simd)
1850         ("rust-opaque-debug" ,rust-opaque-debug)
1851         ("rust-sha1-asm" ,rust-sha1-asm))
1852        #:cargo-development-inputs
1853        (("rust-digest" ,rust-digest)
1854         ("rust-hex-literal" ,rust-hex-literal))))
1855    (home-page
1856      "https://github.com/RustCrypto/hashes")
1857    (synopsis "SHA-1 hash function")
1858    (description "SHA-1 hash function")
1859    (license (list license:expat license:asl2.0))))
1860
1861(define-public rust-pest-meta
1862  (package
1863    (name "rust-pest-meta")
1864    (version "2.1.2")
1865    (source
1866      (origin
1867        (method url-fetch)
1868        (uri (crate-uri "pest_meta" version))
1869        (file-name
1870          (string-append name "-" version ".tar.gz"))
1871        (sha256
1872          (base32
1873            "0iymvrh7lcfi8iarkgq0hwgarr00np3l4xg4bx42rmvgi6czshyz"))))
1874    (build-system cargo-build-system)
1875    (arguments
1876      `(#:cargo-inputs
1877        (("rust-maplit" ,rust-maplit)
1878         ("rust-pest" ,rust-pest))
1879        #:cargo-development-inputs
1880        (("rust-sha-1" ,rust-sha-1))))
1881    (home-page "https://pest-parser.github.io/")
1882    (synopsis
1883      "pest meta language parser and validator")
1884    (description
1885      "pest meta language parser and validator")
1886    (license #f)))
1887
1888(define-public rust-pest-generator
1889  (package
1890    (name "rust-pest-generator")
1891    (version "2.1.1")
1892    (source
1893      (origin
1894        (method url-fetch)
1895        (uri (crate-uri "pest_generator" version))
1896        (file-name
1897          (string-append name "-" version ".tar.gz"))
1898        (sha256
1899          (base32
1900            "1h3z8jccki87mn7gppy4292s1ah98z4md998w5pd04jpkclwz7vv"))))
1901    (build-system cargo-build-system)
1902    (arguments
1903      `(#:cargo-inputs
1904        (("rust-pest" ,rust-pest)
1905         ("rust-pest-meta" ,rust-pest-meta)
1906         ("rust-proc-macro2" ,rust-proc-macro2)
1907         ("rust-quote" ,rust-quote)
1908         ("rust-syn" ,rust-syn))))
1909    (home-page "https://pest-parser.github.io/")
1910    (synopsis "pest code generator")
1911    (description "pest code generator")
1912    (license #f)))
1913
1914(define-public rust-pest-derive
1915  (package
1916    (name "rust-pest-derive")
1917    (version "2.1.0")
1918    (source
1919      (origin
1920        (method url-fetch)
1921        (uri (crate-uri "pest_derive" version))
1922        (file-name
1923          (string-append name "-" version ".tar.gz"))
1924        (sha256
1925          (base32
1926            "1l5jfa6ril71cw5nsiw0r45br54dd8cj2r1nc2d1wq6wb3jilgc3"))))
1927    (build-system cargo-build-system)
1928    (arguments
1929      `(#:cargo-inputs
1930        (("rust-pest" ,rust-pest)
1931         ("rust-pest-generator" ,rust-pest-generator))))
1932    (home-page "https://pest-parser.github.io/")
1933    (synopsis "pest's derive macro")
1934    (description "pest's derive macro")
1935    (license #f)))
1936
1937(define-public rust-base64
1938  (package
1939    (name "rust-base64")
1940    (version "0.10.1")
1941    (source
1942      (origin
1943        (method url-fetch)
1944        (uri (crate-uri "base64" version))
1945        (file-name
1946          (string-append name "-" version ".tar.gz"))
1947        (sha256
1948          (base32
1949            "13k6bvd3n6dm7jqn9x918w65dd9xhx454bqphbnv0bkd6n9dj98b"))))
1950    (build-system cargo-build-system)
1951    (arguments
1952      `(#:cargo-inputs
1953        (("rust-byteorder" ,rust-byteorder))
1954        #:cargo-development-inputs
1955        (("rust-criterion" ,rust-criterion)
1956         ("rust-rand" ,rust-rand))))
1957    (home-page
1958      "https://github.com/alicemaz/rust-base64")
1959    (synopsis
1960      "encodes and decodes base64 as bytes or utf8")
1961    (description
1962      "encodes and decodes base64 as bytes or utf8")
1963    (license #f)))
1964
1965(define-public rust-ron
1966  (package
1967    (name "rust-ron")
1968    (version "0.5.1")
1969    (source
1970      (origin
1971        (method url-fetch)
1972        (uri (crate-uri "ron" version))
1973        (file-name
1974          (string-append name "-" version ".tar.gz"))
1975        (sha256
1976          (base32
1977            "1mb2bavvp8jg5wx0kx9n45anrsbjwhjzddim987bjaa11hg45kif"))))
1978    (build-system cargo-build-system)
1979    (arguments
1980      `(#:cargo-inputs
1981        (("rust-base64" ,rust-base64)
1982         ("rust-bitflags" ,rust-bitflags)
1983         ("rust-serde" ,rust-serde))
1984        #:cargo-development-inputs
1985        (("rust-serde-bytes" ,rust-serde-bytes)
1986         ("rust-serde-json" ,rust-serde-json))))
1987    (home-page "https://github.com/ron-rs/ron")
1988    (synopsis "Rusty Object Notation")
1989    (description "Rusty Object Notation")
1990    (license #f)))
1991
1992(define-public rust-yaml-rust
1993  (package
1994    (name "rust-yaml-rust")
1995    (version "0.4.3")
1996    (source
1997      (origin
1998        (method url-fetch)
1999        (uri (crate-uri "yaml-rust" version))
2000        (file-name
2001          (string-append name "-" version ".tar.gz"))
2002        (sha256
2003          (base32
2004            "0ka3qhqc5lvk3hz14wmsj32jhmh44blcbfrx5hfxli2gg38kv4k5"))))
2005    (build-system cargo-build-system)
2006    (arguments
2007      `(#:cargo-inputs
2008        (("rust-linked-hash-map" ,rust-linked-hash-map))
2009        #:cargo-development-inputs
2010        (("rust-quickcheck" ,rust-quickcheck))))
2011    (home-page
2012      "http://chyh1990.github.io/yaml-rust/")
2013    (synopsis "The missing YAML 1.2 parser for rust")
2014    (description
2015      "The missing YAML 1.2 parser for rust")
2016    (license #f)))
2017
2018(define-public rust-serde-yaml
2019  (package
2020    (name "rust-serde-yaml")
2021    (version "0.8.9")
2022    (source
2023      (origin
2024        (method url-fetch)
2025        (uri (crate-uri "serde_yaml" version))
2026        (file-name
2027          (string-append name "-" version ".tar.gz"))
2028        (sha256
2029          (base32
2030            "10mmjpnshgrwij01a13679nxy1hnh5yfr0343kh0y9p5j2d8mc1q"))))
2031    (build-system cargo-build-system)
2032    (arguments
2033      `(#:cargo-inputs
2034        (("rust-dtoa" ,rust-dtoa)
2035         ("rust-linked-hash-map" ,rust-linked-hash-map)
2036         ("rust-serde" ,rust-serde)
2037         ("rust-yaml-rust" ,rust-yaml-rust))
2038        #:cargo-development-inputs
2039        (("rust-serde-derive" ,rust-serde-derive)
2040         ("rust-unindent" ,rust-unindent)
2041         ("rust-version-sync" ,rust-version-sync))))
2042    (home-page
2043      "https://github.com/dtolnay/serde-yaml")
2044    (synopsis "YAML support for Serde")
2045    (description "YAML support for Serde")
2046    (license #f)))
2047
2048(define-public rust-insta
2049  (package
2050    (name "rust-insta")
2051    (version "0.11.0")
2052    (source
2053      (origin
2054        (method url-fetch)
2055        (uri (crate-uri "insta" version))
2056        (file-name
2057          (string-append name "-" version ".tar.gz"))
2058        (sha256
2059          (base32
2060            "0xlv6wsby9567x7av84ym95hls8jsizw48045wlqpww6xss3my13"))))
2061    (build-system cargo-build-system)
2062    (arguments
2063      `(#:cargo-inputs
2064        (("rust-console" ,rust-console)
2065         ("rust-difference" ,rust-difference)
2066         ("rust-lazy-static" ,rust-lazy-static)
2067         ("rust-pest" ,rust-pest)
2068         ("rust-pest-derive" ,rust-pest-derive)
2069         ("rust-ron" ,rust-ron)
2070         ("rust-serde" ,rust-serde)
2071         ("rust-serde-json" ,rust-serde-json)
2072         ("rust-serde-yaml" ,rust-serde-yaml)
2073         ("rust-uuid" ,rust-uuid))))
2074    (home-page "https://github.com/mitsuhiko/insta")
2075    (synopsis "A snapshot testing library for Rust")
2076    (description
2077      "This package provides a snapshot testing library for Rust")
2078    (license license:asl2.0)))
2079
2080(define-public rust-ref-cast-impl
2081  (package
2082    (name "rust-ref-cast-impl")
2083    (version "0.2.7")
2084    (source
2085      (origin
2086        (method url-fetch)
2087        (uri (crate-uri "ref-cast-impl" version))
2088        (file-name
2089          (string-append name "-" version ".tar.gz"))
2090        (sha256
2091          (base32
2092            "0av43xxjlinfqklb67rpj217cmaxfjsf8151gs0hbs4hnr5664ck"))))
2093    (build-system cargo-build-system)
2094    (arguments
2095      `(#:cargo-inputs
2096        (("rust-proc-macro2" ,rust-proc-macro2)
2097         ("rust-quote" ,rust-quote)
2098         ("rust-syn" ,rust-syn))))
2099    (home-page "https://github.com/dtolnay/ref-cast")
2100    (synopsis
2101      "Derive implementation for ref_cast::RefCast.")
2102    (description
2103      "Derive implementation for ref_cast::RefCast.")
2104    (license (list license:expat license:asl2.0))))
2105
2106(define-public rust-rustversion
2107  (package
2108    (name "rust-rustversion")
2109    (version "0.1.4")
2110    (source
2111      (origin
2112        (method url-fetch)
2113        (uri (crate-uri "rustversion" version))
2114        (file-name
2115          (string-append name "-" version ".tar.gz"))
2116        (sha256
2117          (base32
2118            "1s3ib2paa5gq17x4qsmjmnsw68z7b5d5av1wsiqcrihmqb7kk0dl"))))
2119    (build-system cargo-build-system)
2120    (arguments
2121      `(#:cargo-inputs
2122        (("rust-proc-macro2" ,rust-proc-macro2)
2123         ("rust-quote" ,rust-quote)
2124         ("rust-syn" ,rust-syn))))
2125    (home-page
2126      "https://github.com/dtolnay/rustversion")
2127    (synopsis
2128      "Conditional compilation according to rustc compiler version")
2129    (description
2130      "Conditional compilation according to rustc compiler version")
2131    (license (list license:expat license:asl2.0))))
2132
2133(define-public rust-ref-cast
2134  (package
2135    (name "rust-ref-cast")
2136    (version "0.2.7")
2137    (source
2138      (origin
2139        (method url-fetch)
2140        (uri (crate-uri "ref-cast" version))
2141        (file-name
2142          (string-append name "-" version ".tar.gz"))
2143        (sha256
2144          (base32
2145            "1fcbpfb7xhr992qvyfg9hr5p63xqykjp48pm3f7a1q21vmhzksvv"))))
2146    (build-system cargo-build-system)
2147    (arguments
2148      `(#:cargo-inputs
2149        (("rust-ref-cast-impl" ,rust-ref-cast-impl))
2150        #:cargo-development-inputs
2151        (("rust-rustversion" ,rust-rustversion)
2152         ("rust-trybuild" ,rust-trybuild))))
2153    (home-page "https://github.com/dtolnay/ref-cast")
2154    (synopsis
2155      "Safely cast &T to &U where the struct U contains a single field of type T.")
2156    (description
2157      "Safely cast &T to &U where the struct U contains a single field of type T.")
2158    (license (list license:expat license:asl2.0))))
2159
2160(define-public rust-syn
2161  (package
2162    (name "rust-syn")
2163    (version "1.0.5")
2164    (source
2165      (origin
2166        (method url-fetch)
2167        (uri (crate-uri "syn" version))
2168        (file-name
2169          (string-append name "-" version ".tar.gz"))
2170        (sha256
2171          (base32
2172            "1gw03w7lzrlqmp2vislcybikgl5wkhrqi6sy70w93xss2abhx1b6"))))
2173    (build-system cargo-build-system)
2174    (arguments
2175      `(#:cargo-inputs
2176        (("rust-proc-macro2" ,rust-proc-macro2)
2177         ("rust-quote" ,rust-quote)
2178         ("rust-unicode-xid" ,rust-unicode-xid))
2179        #:cargo-development-inputs
2180        (("rust-insta" ,rust-insta)
2181         ("rust-rayon" ,rust-rayon)
2182         ("rust-ref-cast" ,rust-ref-cast)
2183         ("rust-regex" ,rust-regex)
2184         ("rust-termcolor" ,rust-termcolor)
2185         ("rust-walkdir" ,rust-walkdir))))
2186    (home-page "https://github.com/dtolnay/syn")
2187    (synopsis "Parser for Rust source code")
2188    (description "Parser for Rust source code")
2189    (license (list license:expat license:asl2.0))))
2190
2191(define-public rust-bumpalo
2192  (package
2193    (name "rust-bumpalo")
2194    (version "2.6.0")
2195    (source
2196      (origin
2197        (method url-fetch)
2198        (uri (crate-uri "bumpalo" version))
2199        (file-name
2200          (string-append name "-" version ".tar.gz"))
2201        (sha256
2202          (base32
2203            "020psxs5dlm0gdbs83rx2rcavibdshdr0fpzk3mmw65zq8ppz05d"))))
2204    (build-system cargo-build-system)
2205    (arguments
2206      `(#:cargo-development-inputs
2207        (("rust-criterion" ,rust-criterion)
2208         ("rust-quickcheck" ,rust-quickcheck))))
2209    (home-page "https://github.com/fitzgen/bumpalo")
2210    (synopsis
2211      "A fast bump allocation arena for Rust.")
2212    (description
2213      "This package provides a fast bump allocation arena for Rust.")
2214    (license #f)))
2215
2216(define-public rust-wasm-bindgen-backend
2217  (package
2218    (name "rust-wasm-bindgen-backend")
2219    (version "0.2.51")
2220    (source
2221      (origin
2222        (method url-fetch)
2223        (uri (crate-uri "wasm-bindgen-backend" version))
2224        (file-name
2225          (string-append name "-" version ".tar.gz"))
2226        (sha256
2227          (base32
2228            "0nxij37k3khnmp2vvnchkl3iljn5lisscas490kysgn22nrrcwcj"))))
2229    (build-system cargo-build-system)
2230    (arguments
2231      `(#:cargo-inputs
2232        (("rust-bumpalo" ,rust-bumpalo)
2233         ("rust-lazy-static" ,rust-lazy-static)
2234         ("rust-log" ,rust-log)
2235         ("rust-proc-macro2" ,rust-proc-macro2)
2236         ("rust-quote" ,rust-quote)
2237         ("rust-syn" ,rust-syn)
2238         ("rust-wasm-bindgen-shared"
2239          ,rust-wasm-bindgen-shared))))
2240    (home-page
2241      "https://rustwasm.github.io/wasm-bindgen/")
2242    (synopsis
2243      "Backend code generation of the wasm-bindgen tool
2244")
2245    (description
2246      "Backend code generation of the wasm-bindgen tool
2247")
2248    (license #f)))
2249
2250(define-public rust-lexical-core
2251  (package
2252    (name "rust-lexical-core")
2253    (version "0.6.2")
2254    (source
2255      (origin
2256        (method url-fetch)
2257        (uri (crate-uri "lexical-core" version))
2258        (file-name
2259          (string-append name "-" version ".tar.gz"))
2260        (sha256
2261          (base32
2262            "146qxf9i5wfj5rla6pjlwj6l5b4ff31vib277fvlzlsxq2jkl16p"))))
2263    (build-system cargo-build-system)
2264    (arguments
2265      `(#:cargo-inputs
2266        (("rust-arrayvec" ,rust-arrayvec)
2267         ("rust-cfg-if" ,rust-cfg-if)
2268         ("rust-dtoa" ,rust-dtoa)
2269         ("rust-ryu" ,rust-ryu)
2270         ("rust-static-assertions"
2271          ,rust-static-assertions))
2272        #:cargo-development-inputs
2273        (("rust-approx" ,rust-approx)
2274         ("rust-proptest" ,rust-proptest)
2275         ("rust-quickcheck" ,rust-quickcheck)
2276         ("rust-rustc-version" ,rust-rustc-version))))
2277    (home-page
2278      "https://github.com/Alexhuszagh/rust-lexical/tree/master/lexical-core")
2279    (synopsis
2280      "Lexical, to- and from-string conversion routines.")
2281    (description
2282      "Lexical, to- and from-string conversion routines.")
2283    (license #f)))
2284
2285(define-public rust-cast
2286  (package
2287    (name "rust-cast")
2288    (version "0.2.2")
2289    (source
2290      (origin
2291        (method url-fetch)
2292        (uri (crate-uri "cast" version))
2293        (file-name
2294          (string-append name "-" version ".tar.gz"))
2295        (sha256
2296          (base32
2297            "09yl2700crxa4n860b080msij25klvs1kfzazhp2aihchvr16q4j"))))
2298    (build-system cargo-build-system)
2299    (arguments
2300      `(#:cargo-development-inputs
2301        (("rust-quickcheck" ,rust-quickcheck))))
2302    (home-page "https://github.com/japaric/cast.rs")
2303    (synopsis
2304      "Ergonomic, checked cast functions for primitive types")
2305    (description
2306      "Ergonomic, checked cast functions for primitive types")
2307    (license (list license:expat license:asl2.0))))
2308
2309(define-public rust-itertools-num
2310  (package
2311    (name "rust-itertools-num")
2312    (version "0.1.3")
2313    (source
2314      (origin
2315        (method url-fetch)
2316        (uri (crate-uri "itertools-num" version))
2317        (file-name
2318          (string-append name "-" version ".tar.gz"))
2319        (sha256
2320          (base32
2321            "1rr7ig9nkpampcas23s91x7yac6qdnwssq3nap522xbgkqps4wm8"))))
2322    (build-system cargo-build-system)
2323    (arguments
2324      `(#:cargo-inputs
2325        (("rust-num-traits" ,rust-num-traits))
2326        #:cargo-development-inputs
2327        (("rust-itertools" ,rust-itertools)
2328         ("rust-quickcheck" ,rust-quickcheck))))
2329    (home-page
2330      "https://github.com/bluss/itertools-num")
2331    (synopsis
2332      "Numerical iterator tools. Extra iterators and iterator methods and functions.
2333")
2334    (description
2335      "Numerical iterator tools.  Extra iterators and iterator methods and functions.
2336")
2337    (license #f)))
2338
2339(define-public rust-criterion-plot
2340  (package
2341    (name "rust-criterion-plot")
2342    (version "0.4.0")
2343    (source
2344      (origin
2345        (method url-fetch)
2346        (uri (crate-uri "criterion-plot" version))
2347        (file-name
2348          (string-append name "-" version ".tar.gz"))
2349        (sha256
2350          (base32
2351            "18kjl0fh2n5ws6ssiqskikmz893dm9rfdgi5j2l2qddyig7cdkgc"))))
2352    (build-system cargo-build-system)
2353    (arguments
2354      `(#:cargo-inputs
2355        (("rust-cast" ,rust-cast)
2356         ("rust-itertools" ,rust-itertools))
2357        #:cargo-development-inputs
2358        (("rust-itertools-num" ,rust-itertools-num)
2359         ("rust-num-complex" ,rust-num-complex)
2360         ("rust-rand" ,rust-rand))))
2361    (home-page
2362      "https://github.com/bheisler/criterion.rs")
2363    (synopsis "Criterion's plotting library")
2364    (description "Criterion's plotting library")
2365    (license #f)))
2366
2367(define-public rust-csv-core
2368  (package
2369    (name "rust-csv-core")
2370    (version "0.1.6")
2371    (source
2372      (origin
2373        (method url-fetch)
2374        (uri (crate-uri "csv-core" version))
2375        (file-name
2376          (string-append name "-" version ".tar.gz"))
2377        (sha256
2378          (base32
2379            "0k5zs0x0qmmn27pa5kcg86lg84s29491fw5sh3zswxswnavasp4v"))))
2380    (build-system cargo-build-system)
2381    (arguments
2382      `(#:cargo-inputs
2383        (("rust-memchr" ,rust-memchr))
2384        #:cargo-development-inputs
2385        (("rust-arrayvec" ,rust-arrayvec))))
2386    (home-page
2387      "https://github.com/BurntSushi/rust-csv")
2388    (synopsis
2389      "Bare bones CSV parsing with no_std support.")
2390    (description
2391      "Bare bones CSV parsing with no_std support.")
2392    (license #f)))
2393
2394(define-public rust-no-panic
2395  (package
2396    (name "rust-no-panic")
2397    (version "0.1.11")
2398    (source
2399      (origin
2400        (method url-fetch)
2401        (uri (crate-uri "no-panic" version))
2402        (file-name
2403          (string-append name "-" version ".tar.gz"))
2404        (sha256
2405          (base32
2406            "0r3r67w0blgfh9l75jjd2isldy73x5siclsf33wd4p83cgwrdpwq"))))
2407    (build-system cargo-build-system)
2408    (arguments
2409      `(#:cargo-inputs
2410        (("rust-proc-macro2" ,rust-proc-macro2)
2411         ("rust-quote" ,rust-quote)
2412         ("rust-syn" ,rust-syn))
2413        #:cargo-development-inputs
2414        (("rust-tempfile" ,rust-tempfile))))
2415    (home-page "https://github.com/dtolnay/no-panic")
2416    (synopsis
2417      "Attribute macro to require that the compiler prove a function can't ever panic.")
2418    (description
2419      "Attribute macro to require that the compiler prove a function can't ever panic.")
2420    (license (list license:expat license:asl2.0))))
2421
2422(define-public rust-ryu
2423  (package
2424    (name "rust-ryu")
2425    (version "1.0.0")
2426    (source
2427      (origin
2428        (method url-fetch)
2429        (uri (crate-uri "ryu" version))
2430        (file-name
2431          (string-append name "-" version ".tar.gz"))
2432        (sha256
2433          (base32
2434            "15r9z2wzgbj04pks4jz7y6wif5xqhf1wqkl2nd7qrvn08ys68969"))))
2435    (build-system cargo-build-system)
2436    (arguments
2437      `(#:cargo-inputs
2438        (("rust-no-panic" ,rust-no-panic))
2439        #:cargo-development-inputs
2440        (("rust-num-cpus" ,rust-num-cpus)
2441         ("rust-rand" ,rust-rand))))
2442    (home-page "https://github.com/dtolnay/ryu")
2443    (synopsis
2444      "Fast floating point to string conversion")
2445    (description
2446      "Fast floating point to string conversion")
2447    (license (list license:asl2.0 license:boost1.0))))
2448
2449(define-public rust-csv
2450  (package
2451    (name "rust-csv")
2452    (version "1.1.1")
2453    (source
2454      (origin
2455        (method url-fetch)
2456        (uri (crate-uri "csv" version))
2457        (file-name
2458          (string-append name "-" version ".tar.gz"))
2459        (sha256
2460          (base32
2461            "0zgq18xam24rbggm3ybmrygipa0mrr7rscf9r8hmi9vkzp6rql9p"))))
2462    (build-system cargo-build-system)
2463    (arguments
2464      `(#:cargo-inputs
2465        (("rust-bstr" ,rust-bstr)
2466         ("rust-csv-core" ,rust-csv-core)
2467         ("rust-itoa" ,rust-itoa)
2468         ("rust-ryu" ,rust-ryu)
2469         ("rust-serde" ,rust-serde))
2470        #:cargo-development-inputs
2471        (("rust-serde" ,rust-serde))))
2472    (home-page
2473      "https://github.com/BurntSushi/rust-csv")
2474    (synopsis
2475      "Fast CSV parsing with support for serde.")
2476    (description
2477      "Fast CSV parsing with support for serde.")
2478    (license #f)))
2479
2480(define-public rust-itertools
2481  (package
2482    (name "rust-itertools")
2483    (version "0.8.0")
2484    (source
2485      (origin
2486        (method url-fetch)
2487        (uri (crate-uri "itertools" version))
2488        (file-name
2489          (string-append name "-" version ".tar.gz"))
2490        (sha256
2491          (base32
2492            "0n2k13b6w4x2x6np2lykh9bj3b3z4hwh2r4cn3z2dgnfq7cng12v"))))
2493    (build-system cargo-build-system)
2494    (arguments
2495      `(#:cargo-inputs
2496        (("rust-either" ,rust-either))
2497        #:cargo-development-inputs
2498        (("rust-permutohedron" ,rust-permutohedron)
2499         ("rust-quickcheck" ,rust-quickcheck)
2500         ("rust-rand" ,rust-rand))))
2501    (home-page
2502      "https://github.com/bluss/rust-itertools")
2503    (synopsis
2504      "Extra iterator adaptors, iterator methods, free functions, and macros.")
2505    (description
2506      "Extra iterator adaptors, iterator methods, free functions, and macros.")
2507    (license #f)))
2508
2509(define-public rust-rand-os
2510  (package
2511    (name "rust-rand-os")
2512    (version "0.2.2")
2513    (source
2514      (origin
2515        (method url-fetch)
2516        (uri (crate-uri "rand_os" version))
2517        (file-name
2518          (string-append name "-" version ".tar.gz"))
2519        (sha256
2520          (base32
2521            "12m59l42aa07khcjnhq8lkw2332brj4d7gqr3jxgqv39vczax257"))))
2522    (build-system cargo-build-system)
2523    (arguments
2524      `(#:cargo-inputs
2525        (("rust-getrandom" ,rust-getrandom)
2526         ("rust-rand-core" ,rust-rand-core))))
2527    (home-page "https://crates.io/crates/rand_os")
2528    (synopsis "OS backed Random Number Generator")
2529    (description "OS backed Random Number Generator")
2530    (license (list license:expat license:asl2.0))))
2531
2532(define-public rust-rand-xoshiro
2533  (package
2534    (name "rust-rand-xoshiro")
2535    (version "0.4.0")
2536    (source
2537      (origin
2538        (method url-fetch)
2539        (uri (crate-uri "rand_xoshiro" version))
2540        (file-name
2541          (string-append name "-" version ".tar.gz"))
2542        (sha256
2543          (base32
2544            "013h45rikipv5bda2ixmwx5rwsk9wpc7mr0a77cz20hxi0pdvz59"))))
2545    (build-system cargo-build-system)
2546    (arguments
2547      `(#:cargo-inputs
2548        (("rust-rand-core" ,rust-rand-core)
2549         ("rust-serde" ,rust-serde))
2550        #:cargo-development-inputs
2551        (("rust-bincode" ,rust-bincode))))
2552    (home-page
2553      "https://crates.io/crates/rand_xoshiro")
2554    (synopsis
2555      "Xoshiro, xoroshiro and splitmix64 random number generators")
2556    (description
2557      "Xoshiro, xoroshiro and splitmix64 random number generators")
2558    (license (list license:expat license:asl2.0))))
2559
2560(define-public rust-arrayvec
2561  (package
2562    (name "rust-arrayvec")
2563    (version "0.5.0")
2564    (source
2565      (origin
2566        (method url-fetch)
2567        (uri (crate-uri "arrayvec" version))
2568        (file-name
2569          (string-append name "-" version ".tar.gz"))
2570        (sha256
2571          (base32
2572            "05ia5hrr78x2fi7dwf0pkd8wwfbgg1dzja50l0gcjfw4p2y03n7a"))))
2573    (build-system cargo-build-system)
2574    (arguments
2575      `(#:cargo-inputs
2576        (("rust-serde" ,rust-serde))
2577        #:cargo-development-inputs
2578        (("rust-bencher" ,rust-bencher)
2579         ("rust-matches" ,rust-matches)
2580         ("rust-serde-test" ,rust-serde-test))))
2581    (home-page "https://github.com/bluss/arrayvec")
2582    (synopsis
2583      "A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.")
2584    (description
2585      "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.")
2586    (license #f)))
2587
2588(define-public rust-crossbeam
2589  (package
2590    (name "rust-crossbeam")
2591    (version "0.7.2")
2592    (source
2593      (origin
2594        (method url-fetch)
2595        (uri (crate-uri "crossbeam" version))
2596        (file-name
2597          (string-append name "-" version ".tar.gz"))
2598        (sha256
2599          (base32
2600            "0g5jysq5x4gndc1v5sq9n3f1m97k7qihwdpigw6ar6knj14qm09d"))))
2601    (build-system cargo-build-system)
2602    (arguments
2603      `(#:cargo-inputs
2604        (("rust-cfg-if" ,rust-cfg-if)
2605         ("rust-crossbeam-channel"
2606          ,rust-crossbeam-channel)
2607         ("rust-crossbeam-deque" ,rust-crossbeam-deque)
2608         ("rust-crossbeam-epoch" ,rust-crossbeam-epoch)
2609         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
2610         ("rust-crossbeam-utils" ,rust-crossbeam-utils))
2611        #:cargo-development-inputs
2612        (("rust-rand" ,rust-rand))))
2613    (home-page
2614      "https://github.com/crossbeam-rs/crossbeam")
2615    (synopsis "Tools for concurrent programming")
2616    (description "Tools for concurrent programming")
2617    (license #f)))
2618
2619(define-public rust-test-assembler
2620  (package
2621    (name "rust-test-assembler")
2622    (version "0.1.5")
2623    (source
2624      (origin
2625        (method url-fetch)
2626        (uri (crate-uri "test-assembler" version))
2627        (file-name
2628          (string-append name "-" version ".tar.gz"))
2629        (sha256
2630          (base32
2631            "1sdx9hk0dk3z9crm8834ysyxsi92chls8arpd0gs796kis6lik2w"))))
2632    (build-system cargo-build-system)
2633    (arguments
2634      `(#:cargo-inputs
2635        (("rust-byteorder" ,rust-byteorder))))
2636    (home-page
2637      "https://github.com/luser/rust-test-assembler")
2638    (synopsis
2639      "A set of types for building complex binary streams.")
2640    (description
2641      "This package provides a set of types for building complex binary streams.")
2642    (license license:expat)))
2643
2644(define-public rust-gimli
2645  (package
2646    (name "rust-gimli")
2647    (version "0.19.0")
2648    (source
2649      (origin
2650        (method url-fetch)
2651        (uri (crate-uri "gimli" version))
2652        (file-name
2653          (string-append name "-" version ".tar.gz"))
2654        (sha256
2655          (base32
2656            "006dpaa63y01wb58nvs2hhj3qqx52yxg20njjflr0frfbyp1hb8n"))))
2657    (build-system cargo-build-system)
2658    (arguments
2659      `(#:cargo-inputs
2660        (("rust-arrayvec" ,rust-arrayvec)
2661         ("rust-byteorder" ,rust-byteorder)
2662         ("rust-fallible-iterator"
2663          ,rust-fallible-iterator)
2664         ("rust-indexmap" ,rust-indexmap)
2665         ("rust-stable-deref-trait"
2666          ,rust-stable-deref-trait))
2667        #:cargo-development-inputs
2668        (("rust-crossbeam" ,rust-crossbeam)
2669         ("rust-getopts" ,rust-getopts)
2670         ("rust-memmap" ,rust-memmap)
2671         ("rust-num-cpus" ,rust-num-cpus)
2672         ("rust-object" ,rust-object)
2673         ("rust-rayon" ,rust-rayon)
2674         ("rust-regex" ,rust-regex)
2675         ("rust-test-assembler" ,rust-test-assembler)
2676         ("rust-typed-arena" ,rust-typed-arena))))
2677    (home-page "https://github.com/gimli-rs/gimli")
2678    (synopsis
2679      "A library for reading and writing the DWARF debugging format.")
2680    (description
2681      "This package provides a library for reading and writing the DWARF debugging format.")
2682    (license #f)))
2683
2684(define-public rust-intervaltree
2685  (package
2686    (name "rust-intervaltree")
2687    (version "0.2.4")
2688    (source
2689      (origin
2690        (method url-fetch)
2691        (uri (crate-uri "intervaltree" version))
2692        (file-name
2693          (string-append name "-" version ".tar.gz"))
2694        (sha256
2695          (base32
2696            "10k40gsv79kwnsqrzwmnmm6psa5fqws8yggavmbggvymv16hffdg"))))
2697    (build-system cargo-build-system)
2698    (arguments
2699      `(#:cargo-inputs
2700        (("rust-smallvec" ,rust-smallvec))))
2701    (home-page
2702      "https://github.com/main--/rust-intervaltree")
2703    (synopsis
2704      "A simple and generic implementation of an immutable interval tree.")
2705    (description
2706      "This package provides a simple and generic implementation of an immutable interval tree.")
2707    (license license:expat)))
2708
2709(define-public rust-lazycell
2710  (package
2711    (name "rust-lazycell")
2712    (version "1.2.1")
2713    (source
2714      (origin
2715        (method url-fetch)
2716        (uri (crate-uri "lazycell" version))
2717        (file-name
2718          (string-append name "-" version ".tar.gz"))
2719        (sha256
2720          (base32
2721            "0gvqycmpv7parc98i6y64ai7rvxrn1947z2a6maa02g4kvxdd55j"))))
2722    (build-system cargo-build-system)
2723    (arguments
2724      `(#:cargo-inputs (("rust-clippy" ,rust-clippy))))
2725    (home-page "https://github.com/indiv0/lazycell")
2726    (synopsis
2727      "A library providing a lazily filled Cell struct")
2728    (description
2729      "This package provides a library providing a lazily filled Cell struct")
2730    (license #f)))
2731
2732(define-public rust-crc32fast
2733  (package
2734    (name "rust-crc32fast")
2735    (version "1.2.0")
2736    (source
2737      (origin
2738        (method url-fetch)
2739        (uri (crate-uri "crc32fast" version))
2740        (file-name
2741          (string-append name "-" version ".tar.gz"))
2742        (sha256
2743          (base32
2744            "1c9dhkvf3brrzzplcijaywxi2w8wv5578i0ryhcm7x8dmzi5s4ms"))))
2745    (build-system cargo-build-system)
2746    (arguments
2747      `(#:cargo-inputs
2748        (("rust-cfg-if" ,rust-cfg-if))
2749        #:cargo-development-inputs
2750        (("rust-bencher" ,rust-bencher)
2751         ("rust-quickcheck" ,rust-quickcheck)
2752         ("rust-rand" ,rust-rand))))
2753    (home-page
2754      "https://github.com/srijs/rust-crc32fast")
2755    (synopsis
2756      "Fast, SIMD-accelerated CRC32 (IEEE) checksum computation")
2757    (description
2758      "Fast, SIMD-accelerated CRC32 (IEEE) checksum computation")
2759    (license (list license:expat license:asl2.0))))
2760
2761(define-public rust-pin-project-internal
2762  (package
2763    (name "rust-pin-project-internal")
2764    (version "0.4.2")
2765    (source
2766      (origin
2767        (method url-fetch)
2768        (uri (crate-uri "pin-project-internal" version))
2769        (file-name
2770          (string-append name "-" version ".tar.gz"))
2771        (sha256
2772          (base32
2773            "1npkq8kyby96dxwspp3yslmsk8g0ygic35gv0a1kvxbvrpzmydqs"))))
2774    (build-system cargo-build-system)
2775    (arguments
2776      `(#:cargo-inputs
2777        (("rust-proc-macro2" ,rust-proc-macro2)
2778         ("rust-quote" ,rust-quote)
2779         ("rust-syn" ,rust-syn))))
2780    (home-page
2781      "https://github.com/taiki-e/pin-project")
2782    (synopsis
2783      "An internal crate to support pin_project - do not use directly
2784")
2785    (description
2786      "An internal crate to support pin_project - do not use directly
2787")
2788    (license #f)))
2789
2790(define-public rust-pin-project
2791  (package
2792    (name "rust-pin-project")
2793    (version "0.4.2")
2794    (source
2795      (origin
2796        (method url-fetch)
2797        (uri (crate-uri "pin-project" version))
2798        (file-name
2799          (string-append name "-" version ".tar.gz"))
2800        (sha256
2801          (base32
2802            "1sva1qgvlsf3w10imccyp37j9bwdfd4dh326q3n31bkrb7m5d49x"))))
2803    (build-system cargo-build-system)
2804    (arguments
2805      `(#:cargo-inputs
2806        (("rust-pin-project-internal"
2807          ,rust-pin-project-internal))
2808        #:cargo-development-inputs
2809        (("rust-compiletest-rs" ,rust-compiletest-rs))))
2810    (home-page
2811      "https://github.com/taiki-e/pin-project")
2812    (synopsis
2813      "A crate for safe and ergonomic pin-projection.
2814")
2815    (description
2816      "This package provides a crate for safe and ergonomic pin-projection.
2817")
2818    (license #f)))
2819
2820(define-public rust-tokio-io
2821  (package
2822    (name "rust-tokio-io")
2823    (version "0.2.0-alpha.6")
2824    (source
2825      (origin
2826        (method url-fetch)
2827        (uri (crate-uri "tokio-io" version))
2828        (file-name
2829          (string-append name "-" version ".tar.gz"))
2830        (sha256
2831          (base32
2832            "1i92ichh2m7i23vdr51gnf5hxngv7d1clwjan1h0dwrxakaq89qi"))))
2833    (build-system cargo-build-system)
2834    (arguments
2835      `(#:cargo-inputs
2836        (("rust-bytes" ,rust-bytes)
2837         ("rust-futures-core-preview"
2838          ,rust-futures-core-preview)
2839         ("rust-log" ,rust-log)
2840         ("rust-memchr" ,rust-memchr)
2841         ("rust-pin-project" ,rust-pin-project))))
2842    (home-page "https://tokio.rs")
2843    (synopsis
2844      "Core I/O primitives for asynchronous I/O in Rust.
2845")
2846    (description
2847      "Core I/O primitives for asynchronous I/O in Rust.
2848")
2849    (license license:expat)))
2850
2851(define-public rust-tokio-tcp
2852  (package
2853    (name "rust-tokio-tcp")
2854    (version "0.2.0-alpha.1")
2855    (source
2856      (origin
2857        (method url-fetch)
2858        (uri (crate-uri "tokio-tcp" version))
2859        (file-name
2860          (string-append name "-" version ".tar.gz"))
2861        (sha256
2862          (base32
2863            "19h6wxz4bn1rkixa72x5d6pccyq8mz7vskfb57fljf7kbgc9qc3y"))))
2864    (build-system cargo-build-system)
2865    (arguments
2866      `(#:cargo-inputs
2867        (("rust-bytes" ,rust-bytes)
2868         ("rust-futures-core-preview"
2869          ,rust-futures-core-preview)
2870         ("rust-futures-util-preview"
2871          ,rust-futures-util-preview)
2872         ("rust-iovec" ,rust-iovec)
2873         ("rust-mio" ,rust-mio)
2874         ("rust-tokio-io" ,rust-tokio-io)
2875         ("rust-tokio-reactor" ,rust-tokio-reactor))
2876        #:cargo-development-inputs
2877        (("rust-tokio" ,rust-tokio)
2878         ("rust-tokio-test" ,rust-tokio-test))))
2879    (home-page "https://tokio.rs")
2880    (synopsis "TCP bindings for tokio.
2881")
2882    (description "TCP bindings for tokio.
2883")
2884    (license license:expat)))
2885
2886(define-public rust-futures-join-macro-preview
2887  (package
2888    (name "rust-futures-join-macro-preview")
2889    (version "0.3.0-alpha.19")
2890    (source
2891      (origin
2892        (method url-fetch)
2893        (uri (crate-uri "futures-join-macro-preview" version))
2894        (file-name
2895          (string-append name "-" version ".tar.gz"))
2896        (sha256
2897          (base32
2898            "1smwaja466yjh5adlhgggfk9k942sy4702n46scxkrwcnkk61qjr"))))
2899    (build-system cargo-build-system)
2900    (arguments
2901      `(#:cargo-inputs
2902        (("rust-proc-macro-hack" ,rust-proc-macro-hack)
2903         ("rust-proc-macro2" ,rust-proc-macro2)
2904         ("rust-quote" ,rust-quote)
2905         ("rust-syn" ,rust-syn))))
2906    (home-page
2907      "https://rust-lang-nursery.github.io/futures-rs")
2908    (synopsis
2909      "Definition of the `join!` macro and the `try_join!` macro.
2910")
2911    (description
2912      "Definition of the `join!` macro and the `try_join!` macro.
2913")
2914    (license (list license:expat license:asl2.0))))
2915
2916(define-public rust-futures-select-macro-preview
2917  (package
2918    (name "rust-futures-select-macro-preview")
2919    (version "0.3.0-alpha.19")
2920    (source
2921      (origin
2922        (method url-fetch)
2923        (uri (crate-uri
2924               "futures-select-macro-preview"
2925               version))
2926        (file-name
2927          (string-append name "-" version ".tar.gz"))
2928        (sha256
2929          (base32
2930            "1xsq55cf2rnf7k6r04q8wynmxiy9svm3pi840vjva47bc0sy8anz"))))
2931    (build-system cargo-build-system)
2932    (arguments
2933      `(#:cargo-inputs
2934        (("rust-proc-macro-hack" ,rust-proc-macro-hack)
2935         ("rust-proc-macro2" ,rust-proc-macro2)
2936         ("rust-quote" ,rust-quote)
2937         ("rust-syn" ,rust-syn))))
2938    (home-page
2939      "https://rust-lang-nursery.github.io/futures-rs")
2940    (synopsis
2941      "The `select!` macro for waiting on multiple different `Future`s at once and handling the first one to complete.
2942")
2943    (description
2944      "The `select!` macro for waiting on multiple different `Future`s at once and handling the first one to complete.
2945")
2946    (license (list license:expat license:asl2.0))))
2947
2948(define-public rust-proc-macro-nested
2949  (package
2950    (name "rust-proc-macro-nested")
2951    (version "0.1.3")
2952    (source
2953      (origin
2954        (method url-fetch)
2955        (uri (crate-uri "proc-macro-nested" version))
2956        (file-name
2957          (string-append name "-" version ".tar.gz"))
2958        (sha256
2959          (base32
2960            "0bmlksm8vl44wkwihmwr7jsjznhbg0n7aibcw1cs2jgjcp86x6in"))))
2961    (build-system cargo-build-system)
2962    (home-page
2963      "https://github.com/dtolnay/proc-macro-hack")
2964    (synopsis
2965      "Support for nested proc-macro-hack invocations")
2966    (description
2967      "Support for nested proc-macro-hack invocations")
2968    (license #f)))
2969
2970(define-public rust-futures-util-preview
2971  (package
2972    (name "rust-futures-util-preview")
2973    (version "0.3.0-alpha.19")
2974    (source
2975      (origin
2976        (method url-fetch)
2977        (uri (crate-uri "futures-util-preview" version))
2978        (file-name
2979          (string-append name "-" version ".tar.gz"))
2980        (sha256
2981          (base32
2982            "138f8wy0vqy2gsgk28kldbqnrdcgwfv9f9xx6rwzkr8p7iinisaw"))))
2983    (build-system cargo-build-system)
2984    (arguments
2985      `(#:cargo-inputs
2986        (("rust-futures" ,rust-futures)
2987         ("rust-futures-channel-preview"
2988          ,rust-futures-channel-preview)
2989         ("rust-futures-core-preview"
2990          ,rust-futures-core-preview)
2991         ("rust-futures-io-preview"
2992          ,rust-futures-io-preview)
2993         ("rust-futures-join-macro-preview"
2994          ,rust-futures-join-macro-preview)
2995         ("rust-futures-select-macro-preview"
2996          ,rust-futures-select-macro-preview)
2997         ("rust-futures-sink-preview"
2998          ,rust-futures-sink-preview)
2999         ("rust-memchr" ,rust-memchr)
3000         ("rust-pin-utils" ,rust-pin-utils)
3001         ("rust-proc-macro-hack" ,rust-proc-macro-hack)
3002         ("rust-proc-macro-nested"
3003          ,rust-proc-macro-nested)
3004         ("rust-slab" ,rust-slab)
3005         ("rust-tokio-io" ,rust-tokio-io))))
3006    (home-page
3007      "https://rust-lang-nursery.github.io/futures-rs")
3008    (synopsis
3009      "Common utilities and extension traits for the futures-rs library.
3010")
3011    (description
3012      "Common utilities and extension traits for the futures-rs library.
3013")
3014    (license (list license:expat license:asl2.0))))
3015
3016(define-public rust-crossbeam-channel
3017  (package
3018    (name "rust-crossbeam-channel")
3019    (version "0.3.9")
3020    (source
3021      (origin
3022        (method url-fetch)
3023        (uri (crate-uri "crossbeam-channel" version))
3024        (file-name
3025          (string-append name "-" version ".tar.gz"))
3026        (sha256
3027          (base32
3028            "1ylyzb1m9qbvd1nd3vy38x9073wdmcy295ncjs7wf7ap476pzv68"))))
3029    (build-system cargo-build-system)
3030    (arguments
3031      `(#:cargo-inputs
3032        (("rust-crossbeam-utils" ,rust-crossbeam-utils))
3033        #:cargo-development-inputs
3034        (("rust-num-cpus" ,rust-num-cpus)
3035         ("rust-rand" ,rust-rand)
3036         ("rust-signal-hook" ,rust-signal-hook))))
3037    (home-page
3038      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-channel")
3039    (synopsis
3040      "Multi-producer multi-consumer channels for message passing")
3041    (description
3042      "Multi-producer multi-consumer channels for message passing")
3043    (license #f)))
3044
3045(define-public rust-tokio-executor
3046  (package
3047    (name "rust-tokio-executor")
3048    (version "0.2.0-alpha.6")
3049    (source
3050      (origin
3051        (method url-fetch)
3052        (uri (crate-uri "tokio-executor" version))
3053        (file-name
3054          (string-append name "-" version ".tar.gz"))
3055        (sha256
3056          (base32
3057            "1j67p4g9y20bvlbphjmpfzc0yy8clhmz6wza6hw94iciyvncxscy"))))
3058    (build-system cargo-build-system)
3059    (arguments
3060      `(#:cargo-inputs
3061        (("rust-crossbeam-channel"
3062          ,rust-crossbeam-channel)
3063         ("rust-crossbeam-deque" ,rust-crossbeam-deque)
3064         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
3065         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
3066         ("rust-futures-core-preview"
3067          ,rust-futures-core-preview)
3068         ("rust-futures-util-preview"
3069          ,rust-futures-util-preview)
3070         ("rust-lazy-static" ,rust-lazy-static)
3071         ("rust-num-cpus" ,rust-num-cpus)
3072         ("rust-slab" ,rust-slab)
3073         ("rust-tokio-sync" ,rust-tokio-sync)
3074         ("rust-tracing" ,rust-tracing))))
3075    (home-page "https://github.com/tokio-rs/tokio")
3076    (synopsis "Future execution primitives
3077")
3078    (description "Future execution primitives
3079")
3080    (license license:expat)))
3081
3082(define-public rust-tokio-sync
3083  (package
3084    (name "rust-tokio-sync")
3085    (version "0.2.0-alpha.6")
3086    (source
3087      (origin
3088        (method url-fetch)
3089        (uri (crate-uri "tokio-sync" version))
3090        (file-name
3091          (string-append name "-" version ".tar.gz"))
3092        (sha256
3093          (base32
3094            "1lirf9s9pibgv8cypqzlddy8q9bxfp4z29qfx83p83slhnvaw6jg"))))
3095    (build-system cargo-build-system)
3096    (arguments
3097      `(#:cargo-inputs
3098        (("rust-fnv" ,rust-fnv)
3099         ("rust-futures-core-preview"
3100          ,rust-futures-core-preview)
3101         ("rust-futures-sink-preview"
3102          ,rust-futures-sink-preview)
3103         ("rust-futures-util-preview"
3104          ,rust-futures-util-preview))))
3105    (home-page "https://tokio.rs")
3106    (synopsis "Synchronization utilities.
3107")
3108    (description "Synchronization utilities.
3109")
3110    (license license:expat)))
3111
3112(define-public rust-bytes
3113  (package
3114    (name "rust-bytes")
3115    (version "0.4.12")
3116    (source
3117      (origin
3118        (method url-fetch)
3119        (uri (crate-uri "bytes" version))
3120        (file-name
3121          (string-append name "-" version ".tar.gz"))
3122        (sha256
3123          (base32
3124            "0768a55q2fsqdjsvcv98ndg9dq7w2g44dvq1avhwpxrdzbydyvr0"))))
3125    (build-system cargo-build-system)
3126    (arguments
3127      `(#:cargo-inputs
3128        (("rust-byteorder" ,rust-byteorder)
3129         ("rust-either" ,rust-either)
3130         ("rust-iovec" ,rust-iovec)
3131         ("rust-serde" ,rust-serde))
3132        #:cargo-development-inputs
3133        (("rust-serde-test" ,rust-serde-test))))
3134    (home-page "https://github.com/carllerche/bytes")
3135    (synopsis
3136      "Types and traits for working with bytes")
3137    (description
3138      "Types and traits for working with bytes")
3139    (license license:expat)))
3140
3141(define-public rust-tokio-codec
3142  (package
3143    (name "rust-tokio-codec")
3144    (version "0.2.0-alpha.6")
3145    (source
3146      (origin
3147        (method url-fetch)
3148        (uri (crate-uri "tokio-codec" version))
3149        (file-name
3150          (string-append name "-" version ".tar.gz"))
3151        (sha256
3152          (base32
3153            "0ykqx22rmw0k49y5302wshsaxjnpnwf4j4w8s92l1gc43vyj4pcz"))))
3154    (build-system cargo-build-system)
3155    (arguments
3156      `(#:cargo-inputs
3157        (("rust-bytes" ,rust-bytes)
3158         ("rust-futures-core-preview"
3159          ,rust-futures-core-preview)
3160         ("rust-futures-sink-preview"
3161          ,rust-futures-sink-preview)
3162         ("rust-log" ,rust-log)
3163         ("rust-tokio-io" ,rust-tokio-io))))
3164    (home-page "https://tokio.rs")
3165    (synopsis
3166      "Utilities for encoding and decoding frames.
3167")
3168    (description
3169      "Utilities for encoding and decoding frames.
3170")
3171    (license license:expat)))
3172
3173(define-public rust-tokio-fs
3174  (package
3175    (name "rust-tokio-fs")
3176    (version "0.2.0-alpha.6")
3177    (source
3178      (origin
3179        (method url-fetch)
3180        (uri (crate-uri "tokio-fs" version))
3181        (file-name
3182          (string-append name "-" version ".tar.gz"))
3183        (sha256
3184          (base32
3185            "1niwp3xjnfm8skbdqpaw4y3b155yansc3q12qs0fc1hyjwb5xy0b"))))
3186    (build-system cargo-build-system)
3187    (arguments
3188      `(#:cargo-inputs
3189        (("rust-futures-core-preview"
3190          ,rust-futures-core-preview)
3191         ("rust-futures-util-preview"
3192          ,rust-futures-util-preview)
3193         ("rust-lazy-static" ,rust-lazy-static)
3194         ("rust-tokio-executor" ,rust-tokio-executor)
3195         ("rust-tokio-io" ,rust-tokio-io)
3196         ("rust-tokio-sync" ,rust-tokio-sync))))
3197    (home-page "https://tokio.rs")
3198    (synopsis "Filesystem API for Tokio.
3199")
3200    (description "Filesystem API for Tokio.
3201")
3202    (license license:expat)))
3203
3204(define-public rust-tokio-macros
3205  (package
3206    (name "rust-tokio-macros")
3207    (version "0.2.0-alpha.6")
3208    (source
3209      (origin
3210        (method url-fetch)
3211        (uri (crate-uri "tokio-macros" version))
3212        (file-name
3213          (string-append name "-" version ".tar.gz"))
3214        (sha256
3215          (base32
3216            "0kln2i8s7b34sv040f65cc8kz4fw0z5dzw71ficxkbfd9cviddl6"))))
3217    (build-system cargo-build-system)
3218    (arguments
3219      `(#:cargo-inputs
3220        (("rust-quote" ,rust-quote)
3221         ("rust-syn" ,rust-syn))))
3222    (home-page "https://tokio.rs")
3223    (synopsis "Tokio's proc macros.
3224")
3225    (description "Tokio's proc macros.
3226")
3227    (license license:expat)))
3228
3229(define-public rust-mio
3230  (package
3231    (name "rust-mio")
3232    (version "0.6.19")
3233    (source
3234      (origin
3235        (method url-fetch)
3236        (uri (crate-uri "mio" version))
3237        (file-name
3238          (string-append name "-" version ".tar.gz"))
3239        (sha256
3240          (base32
3241            "08zzs227vrnyz5kvws6awzlgzb8zqpnihs71hkqlw07dlfb1kxc3"))))
3242    (build-system cargo-build-system)
3243    (arguments
3244      `(#:cargo-inputs
3245        (("rust-fuchsia-zircon" ,rust-fuchsia-zircon)
3246         ("rust-fuchsia-zircon-sys"
3247          ,rust-fuchsia-zircon-sys)
3248         ("rust-iovec" ,rust-iovec)
3249         ("rust-kernel32-sys" ,rust-kernel32-sys)
3250         ("rust-libc" ,rust-libc)
3251         ("rust-log" ,rust-log)
3252         ("rust-miow" ,rust-miow)
3253         ("rust-net2" ,rust-net2)
3254         ("rust-slab" ,rust-slab)
3255         ("rust-winapi" ,rust-winapi))
3256        #:cargo-development-inputs
3257        (("rust-bytes" ,rust-bytes)
3258         ("rust-env-logger" ,rust-env-logger)
3259         ("rust-tempdir" ,rust-tempdir))))
3260    (home-page "https://github.com/carllerche/mio")
3261    (synopsis "Lightweight non-blocking IO")
3262    (description "Lightweight non-blocking IO")
3263    (license license:expat)))
3264
3265(define-public rust-mio-named-pipes
3266  (package
3267    (name "rust-mio-named-pipes")
3268    (version "0.1.6")
3269    (source
3270      (origin
3271        (method url-fetch)
3272        (uri (crate-uri "mio-named-pipes" version))
3273        (file-name
3274          (string-append name "-" version ".tar.gz"))
3275        (sha256
3276          (base32
3277            "1cwwfx1yr9vws8x971x34ijnirs377vcxi47frdirki5yppp9qzm"))))
3278    (build-system cargo-build-system)
3279    (arguments
3280      `(#:cargo-inputs
3281        (("rust-log" ,rust-log)
3282         ("rust-mio" ,rust-mio)
3283         ("rust-miow" ,rust-miow)
3284         ("rust-winapi" ,rust-winapi))
3285        #:cargo-development-inputs
3286        (("rust-env-logger" ,rust-env-logger)
3287         ("rust-rand" ,rust-rand))))
3288    (home-page
3289      "https://github.com/alexcrichton/mio-named-pipes")
3290    (synopsis
3291      "Windows named pipe bindings for mio.
3292")
3293    (description
3294      "Windows named pipe bindings for mio.
3295")
3296    (license #f)))
3297
3298(define-public rust-mio-uds
3299  (package
3300    (name "rust-mio-uds")
3301    (version "0.6.7")
3302    (source
3303      (origin
3304        (method url-fetch)
3305        (uri (crate-uri "mio-uds" version))
3306        (file-name
3307          (string-append name "-" version ".tar.gz"))
3308        (sha256
3309          (base32
3310            "09gimdbnj7b9yca99pk8lxh9jhl79msj795c8fxi2sqr9slmfqln"))))
3311    (build-system cargo-build-system)
3312    (arguments
3313      `(#:cargo-inputs
3314        (("rust-iovec" ,rust-iovec)
3315         ("rust-libc" ,rust-libc)
3316         ("rust-mio" ,rust-mio))
3317        #:cargo-development-inputs
3318        (("rust-tempdir" ,rust-tempdir))))
3319    (home-page
3320      "https://github.com/alexcrichton/mio-uds")
3321    (synopsis
3322      "Unix domain socket bindings for mio
3323")
3324    (description
3325      "Unix domain socket bindings for mio
3326")
3327    (license #f)))
3328
3329(define-public rust-ordermap
3330  (package
3331    (name "rust-ordermap")
3332    (version "0.4.2")
3333    (source
3334      (origin
3335        (method url-fetch)
3336        (uri (crate-uri "ordermap" version))
3337        (file-name
3338          (string-append name "-" version ".tar.gz"))
3339        (sha256
3340          (base32
3341            "1m0vxmlm1x92m1ydgpddzg5mrfk3ddy8gk3r9dmpml18qrs9ch4i"))))
3342    (build-system cargo-build-system)
3343    (arguments
3344      `(#:cargo-inputs
3345        (("rust-serde" ,rust-serde))
3346        #:cargo-development-inputs
3347        (("rust-fnv" ,rust-fnv)
3348         ("rust-itertools" ,rust-itertools)
3349         ("rust-lazy-static" ,rust-lazy-static)
3350         ("rust-quickcheck" ,rust-quickcheck)
3351         ("rust-rand" ,rust-rand)
3352         ("rust-serde-test" ,rust-serde-test))))
3353    (home-page "https://github.com/bluss/ordermap")
3354    (synopsis
3355      "A hash table with consistent order and fast iteration. NOTE: This crate was renamed to indexmap. Please use it under its new name.")
3356    (description
3357      "This package provides a hash table with consistent order and fast iteration.  NOTE: This crate was renamed to indexmap.  Please use it under its new name.")
3358    (license #f)))
3359
3360(define-public rust-rawslice
3361  (package
3362    (name "rust-rawslice")
3363    (version "0.1.0")
3364    (source
3365      (origin
3366        (method url-fetch)
3367        (uri (crate-uri "rawslice" version))
3368        (file-name
3369          (string-append name "-" version ".tar.gz"))
3370        (sha256
3371          (base32
3372            "09bympww1rpsd422da3w444q5w1znjbjh7mjninhq9gaaygkpci2"))))
3373    (build-system cargo-build-system)
3374    (arguments
3375      `(#:cargo-inputs
3376        (("rust-rawpointer" ,rust-rawpointer))
3377        #:cargo-development-inputs
3378        (("rust-quickcheck" ,rust-quickcheck))))
3379    (home-page "https://github.com/bluss/rawslice/")
3380    (synopsis
3381      "Reimplementation of the slice iterators, with extra features. For example
3382creation from raw pointers and start, end pointer accessors.
3383")
3384    (description
3385      "Reimplementation of the slice iterators, with extra features.  For example
3386creation from raw pointers and start, end pointer accessors.
3387")
3388    (license #f)))
3389
3390(define-public rust-unchecked-index
3391  (package
3392    (name "rust-unchecked-index")
3393    (version "0.2.2")
3394    (source
3395      (origin
3396        (method url-fetch)
3397        (uri (crate-uri "unchecked-index" version))
3398        (file-name
3399          (string-append name "-" version ".tar.gz"))
3400        (sha256
3401          (base32
3402            "0p6qcai1mjayx59cpgk27d0zgw9hz9r1ira5jiqil66f4ba8dfpf"))))
3403    (build-system cargo-build-system)
3404    (home-page
3405      "https://github.com/bluss/unchecked-index")
3406    (synopsis
3407      "Unchecked indexing wrapper using regular index syntax.")
3408    (description
3409      "Unchecked indexing wrapper using regular index syntax.")
3410    (license #f)))
3411
3412(define-public rust-odds
3413  (package
3414    (name "rust-odds")
3415    (version "0.3.1")
3416    (source
3417      (origin
3418        (method url-fetch)
3419        (uri (crate-uri "odds" version))
3420        (file-name
3421          (string-append name "-" version ".tar.gz"))
3422        (sha256
3423          (base32
3424            "0rdnxa0na4897yb0svb3figz35g4imxjv61yfm2j21gbh5q8v8d9"))))
3425    (build-system cargo-build-system)
3426    (arguments
3427      `(#:cargo-inputs
3428        (("rust-rawpointer" ,rust-rawpointer)
3429         ("rust-rawslice" ,rust-rawslice)
3430         ("rust-unchecked-index" ,rust-unchecked-index))
3431        #:cargo-development-inputs
3432        (("rust-itertools" ,rust-itertools)
3433         ("rust-lazy-static" ,rust-lazy-static)
3434         ("rust-memchr" ,rust-memchr)
3435         ("rust-quickcheck" ,rust-quickcheck))))
3436    (home-page "https://github.com/bluss/odds")
3437    (synopsis
3438      "Odds and ends â\x80\x94 collection miscellania. Extra functionality for slices (`.find()`, `RevSlice`), strings and other things. Things in odds may move to more appropriate crates if we find them.
3439")
3440    (description
3441      "Odds and ends â\x80\x94 collection miscellania.  Extra functionality for slices (`.find()`, `RevSlice`), strings and other things.  Things in odds may move to more appropriate crates if we find them.
3442")
3443    (license #f)))
3444
3445(define-public rust-petgraph
3446  (package
3447    (name "rust-petgraph")
3448    (version "0.4.13")
3449    (source
3450      (origin
3451        (method url-fetch)
3452        (uri (crate-uri "petgraph" version))
3453        (file-name
3454          (string-append name "-" version ".tar.gz"))
3455        (sha256
3456          (base32
3457            "0kyfmca854s54jk26g2x1kjb04c3k7cjilaxyr0if8lhxv8mjdlw"))))
3458    (build-system cargo-build-system)
3459    (arguments
3460      `(#:cargo-inputs
3461        (("rust-fixedbitset" ,rust-fixedbitset)
3462         ("rust-ordermap" ,rust-ordermap)
3463         ("rust-quickcheck" ,rust-quickcheck)
3464         ("rust-serde" ,rust-serde)
3465         ("rust-serde-derive" ,rust-serde-derive))
3466        #:cargo-development-inputs
3467        (("rust-defmac" ,rust-defmac)
3468         ("rust-itertools" ,rust-itertools)
3469         ("rust-odds" ,rust-odds)
3470         ("rust-rand" ,rust-rand))))
3471    (home-page "https://github.com/bluss/petgraph")
3472    (synopsis
3473      "Graph data structure library. Provides graph types and graph algorithms.")
3474    (description
3475      "Graph data structure library.  Provides graph types and graph algorithms.")
3476    (license #f)))
3477
3478(define-public rust-redox-syscall
3479  (package
3480    (name "rust-redox-syscall")
3481    (version "0.1.56")
3482    (source
3483      (origin
3484        (method url-fetch)
3485        (uri (crate-uri "redox_syscall" version))
3486        (file-name
3487          (string-append name "-" version ".tar.gz"))
3488        (sha256
3489          (base32
3490            "110y7dyfm2vci4x5vk7gr0q551dvp31npl99fnsx2fb17wzwcf94"))))
3491    (build-system cargo-build-system)
3492    (home-page
3493      "https://gitlab.redox-os.org/redox-os/syscall")
3494    (synopsis
3495      "A Rust library to access raw Redox system calls")
3496    (description
3497      "This package provides a Rust library to access raw Redox system calls")
3498    (license license:expat)))
3499
3500(define-public rust-parking-lot-core
3501  (package
3502    (name "rust-parking-lot-core")
3503    (version "0.6.2")
3504    (source
3505      (origin
3506        (method url-fetch)
3507        (uri (crate-uri "parking_lot_core" version))
3508        (file-name
3509          (string-append name "-" version ".tar.gz"))
3510        (sha256
3511          (base32
3512            "0ay67dpnrn68ryyvp720m9i8hzp189fd4d6slrs1lvmcwywv2xmq"))))
3513    (build-system cargo-build-system)
3514    (arguments
3515      `(#:cargo-inputs
3516        (("rust-backtrace" ,rust-backtrace)
3517         ("rust-cfg-if" ,rust-cfg-if)
3518         ("rust-cloudabi" ,rust-cloudabi)
3519         ("rust-libc" ,rust-libc)
3520         ("rust-petgraph" ,rust-petgraph)
3521         ("rust-redox-syscall" ,rust-redox-syscall)
3522         ("rust-smallvec" ,rust-smallvec)
3523         ("rust-thread-id" ,rust-thread-id)
3524         ("rust-winapi" ,rust-winapi))
3525        #:cargo-development-inputs
3526        (("rust-rustc-version" ,rust-rustc-version))))
3527    (home-page
3528      "https://github.com/Amanieu/parking_lot")
3529    (synopsis
3530      "An advanced API for creating custom synchronization primitives.")
3531    (description
3532      "An advanced API for creating custom synchronization primitives.")
3533    (license #f)))
3534
3535(define-public rust-parking-lot
3536  (package
3537    (name "rust-parking-lot")
3538    (version "0.9.0")
3539    (source
3540      (origin
3541        (method url-fetch)
3542        (uri (crate-uri "parking_lot" version))
3543        (file-name
3544          (string-append name "-" version ".tar.gz"))
3545        (sha256
3546          (base32
3547            "0lk2vq3hp88ygpgsrypdr3ss71fidnqbykva0csgxhmn5scb2hpq"))))
3548    (build-system cargo-build-system)
3549    (arguments
3550      `(#:cargo-inputs
3551        (("rust-lock-api" ,rust-lock-api)
3552         ("rust-parking-lot-core" ,rust-parking-lot-core))
3553        #:cargo-development-inputs
3554        (("rust-bincode" ,rust-bincode)
3555         ("rust-lazy-static" ,rust-lazy-static)
3556         ("rust-rand" ,rust-rand)
3557         ("rust-rustc-version" ,rust-rustc-version))))
3558    (home-page
3559      "https://github.com/Amanieu/parking_lot")
3560    (synopsis
3561      "More compact and efficient implementations of the standard synchronization primitives.")
3562    (description
3563      "More compact and efficient implementations of the standard synchronization primitives.")
3564    (license #f)))
3565
3566(define-public rust-model
3567  (package
3568    (name "rust-model")
3569    (version "0.1.2")
3570    (source
3571      (origin
3572        (method url-fetch)
3573        (uri (crate-uri "model" version))
3574        (file-name
3575          (string-append name "-" version ".tar.gz"))
3576        (sha256
3577          (base32
3578            "0kx6hy5i1fn2qs4x6hpng9jixpm68g83vm24z8bqqscr317yinb6"))))
3579    (build-system cargo-build-system)
3580    (arguments
3581      `(#:cargo-inputs
3582        (("rust-permutohedron" ,rust-permutohedron)
3583         ("rust-proptest" ,rust-proptest))))
3584    (home-page "https://github.com/spacejam/model")
3585    (synopsis
3586      "model-based testing for data structures, with linearizability checking")
3587    (description
3588      "model-based testing for data structures, with linearizability checking")
3589    (license #f)))
3590
3591(define-public rust-arc-swap
3592  (package
3593    (name "rust-arc-swap")
3594    (version "0.4.3")
3595    (source
3596      (origin
3597        (method url-fetch)
3598        (uri (crate-uri "arc-swap" version))
3599        (file-name
3600          (string-append name "-" version ".tar.gz"))
3601        (sha256
3602          (base32
3603            "14lf9pg3s0diw8n7dvaga0l1qszzbwpyz4p2cjyrnwjv36iyr8gi"))))
3604    (build-system cargo-build-system)
3605    (arguments
3606      `(#:cargo-development-inputs
3607        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
3608         ("rust-itertools" ,rust-itertools)
3609         ("rust-lazy-static" ,rust-lazy-static)
3610         ("rust-model" ,rust-model)
3611         ("rust-num-cpus" ,rust-num-cpus)
3612         ("rust-proptest" ,rust-proptest)
3613         ("rust-version-sync" ,rust-version-sync))))
3614    (home-page "https://github.com/vorner/arc-swap")
3615    (synopsis "Atomically swappable Arc")
3616    (description "Atomically swappable Arc")
3617    (license #f)))
3618
3619(define-public rust-futures-executor-preview
3620  (package
3621    (name "rust-futures-executor-preview")
3622    (version "0.3.0-alpha.19")
3623    (source
3624      (origin
3625        (method url-fetch)
3626        (uri (crate-uri "futures-executor-preview" version))
3627        (file-name
3628          (string-append name "-" version ".tar.gz"))
3629        (sha256
3630          (base32
3631            "161yv7wwha60mdzj1id47kh8ylnhcnv7blgwidg8xs4zpn46w8vm"))))
3632    (build-system cargo-build-system)
3633    (arguments
3634      `(#:cargo-inputs
3635        (("rust-futures-core-preview"
3636          ,rust-futures-core-preview)
3637         ("rust-futures-util-preview"
3638          ,rust-futures-util-preview)
3639         ("rust-num-cpus" ,rust-num-cpus))))
3640    (home-page
3641      "https://rust-lang-nursery.github.io/futures-rs")
3642    (synopsis
3643      "Executors for asynchronous tasks based on the futures-rs library.
3644")
3645    (description
3646      "Executors for asynchronous tasks based on the futures-rs library.
3647")
3648    (license (list license:expat license:asl2.0))))
3649
3650(define-public rust-futures-preview
3651  (package
3652    (name "rust-futures-preview")
3653    (version "0.3.0-alpha.19")
3654    (source
3655      (origin
3656        (method url-fetch)
3657        (uri (crate-uri "futures-preview" version))
3658        (file-name
3659          (string-append name "-" version ".tar.gz"))
3660        (sha256
3661          (base32
3662            "0vnp63aicm9vgapn4hm45ag9lrsf9f3bma3mzz3abbb708mcw79v"))))
3663    (build-system cargo-build-system)
3664    (arguments
3665      `(#:cargo-inputs
3666        (("rust-futures-channel-preview"
3667          ,rust-futures-channel-preview)
3668         ("rust-futures-core-preview"
3669          ,rust-futures-core-preview)
3670         ("rust-futures-executor-preview"
3671          ,rust-futures-executor-preview)
3672         ("rust-futures-io-preview"
3673          ,rust-futures-io-preview)
3674         ("rust-futures-sink-preview"
3675          ,rust-futures-sink-preview)
3676         ("rust-futures-util-preview"
3677          ,rust-futures-util-preview))))
3678    (home-page
3679      "https://rust-lang-nursery.github.io/futures-rs")
3680    (synopsis
3681      "An implementation of futures and streams featuring zero allocations,
3682composability, and iterator-like interfaces.
3683")
3684    (description
3685      "An implementation of futures and streams featuring zero allocations,
3686composability, and iterator-like interfaces.
3687")
3688    (license (list license:expat license:asl2.0))))
3689
3690(define-public rust-tokio-io-pool
3691  (package
3692    (name "rust-tokio-io-pool")
3693    (version "0.2.0-alpha.3")
3694    (source
3695      (origin
3696        (method url-fetch)
3697        (uri (crate-uri "tokio-io-pool" version))
3698        (file-name
3699          (string-append name "-" version ".tar.gz"))
3700        (sha256
3701          (base32
3702            "0svl3fs9sc3m98nkbmv33ad8a6w83xqqqpc5dmx0w2ddj8jr596b"))))
3703    (build-system cargo-build-system)
3704    (arguments
3705      `(#:cargo-inputs
3706        (("rust-futures-core-preview"
3707          ,rust-futures-core-preview)
3708         ("rust-num-cpus" ,rust-num-cpus)
3709         ("rust-tokio" ,rust-tokio)
3710         ("rust-tokio-executor" ,rust-tokio-executor))
3711        #:cargo-development-inputs
3712        (("rust-futures-preview" ,rust-futures-preview)
3713         ("rust-futures-util-preview"
3714          ,rust-futures-util-preview))))
3715    (home-page
3716      "https://github.com/jonhoo/tokio-io-pool")
3717    (synopsis
3718      "Alternative tokio thread pool for executing short, I/O-heavy futures efficiently")
3719    (description
3720      "Alternative tokio thread pool for executing short, I/O-heavy futures efficiently")
3721    (license #f)))
3722
3723(define-public rust-tokio-reactor
3724  (package
3725    (name "rust-tokio-reactor")
3726    (version "0.2.0-alpha.1")
3727    (source
3728      (origin
3729        (method url-fetch)
3730        (uri (crate-uri "tokio-reactor" version))
3731        (file-name
3732          (string-append name "-" version ".tar.gz"))
3733        (sha256
3734          (base32
3735            "1k7wgrajhp6q87srnnbg04aw08phaml4h22dc8k75x23zfdr78mf"))))
3736    (build-system cargo-build-system)
3737    (arguments
3738      `(#:cargo-inputs
3739        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
3740         ("rust-futures-core-preview"
3741          ,rust-futures-core-preview)
3742         ("rust-lazy-static" ,rust-lazy-static)
3743         ("rust-log" ,rust-log)
3744         ("rust-mio" ,rust-mio)
3745         ("rust-num-cpus" ,rust-num-cpus)
3746         ("rust-parking-lot" ,rust-parking-lot)
3747         ("rust-slab" ,rust-slab)
3748         ("rust-tokio-executor" ,rust-tokio-executor)
3749         ("rust-tokio-io" ,rust-tokio-io)
3750         ("rust-tokio-sync" ,rust-tokio-sync))
3751        #:cargo-development-inputs
3752        (("rust-num-cpus" ,rust-num-cpus)
3753         ("rust-tokio" ,rust-tokio)
3754         ("rust-tokio-io-pool" ,rust-tokio-io-pool))))
3755    (home-page "https://tokio.rs")
3756    (synopsis
3757      "Event loop that drives Tokio I/O resources.
3758")
3759    (description
3760      "Event loop that drives Tokio I/O resources.
3761")
3762    (license license:expat)))
3763
3764(define-public rust-signal-hook
3765  (package
3766    (name "rust-signal-hook")
3767    (version "0.1.10")
3768    (source
3769      (origin
3770        (method url-fetch)
3771        (uri (crate-uri "signal-hook" version))
3772        (file-name
3773          (string-append name "-" version ".tar.gz"))
3774        (sha256
3775          (base32
3776            "0s6wysqm7i0hgag6hlfnswpkcj5sh2dhlid6pdhrzaiskzaw8qag"))))
3777    (build-system cargo-build-system)
3778    (arguments
3779      `(#:cargo-inputs
3780        (("rust-futures" ,rust-futures)
3781         ("rust-libc" ,rust-libc)
3782         ("rust-mio" ,rust-mio)
3783         ("rust-signal-hook-registry"
3784          ,rust-signal-hook-registry)
3785         ("rust-tokio-reactor" ,rust-tokio-reactor))
3786        #:cargo-development-inputs
3787        (("rust-tokio" ,rust-tokio)
3788         ("rust-version-sync" ,rust-version-sync))))
3789    (home-page
3790      "https://github.com/vorner/signal-hook")
3791    (synopsis "Unix signal handling")
3792    (description "Unix signal handling")
3793    (license #f)))
3794
3795(define-public rust-difference
3796  (package
3797    (name "rust-difference")
3798    (version "2.0.0")
3799    (source
3800      (origin
3801        (method url-fetch)
3802        (uri (crate-uri "difference" version))
3803        (file-name
3804          (string-append name "-" version ".tar.gz"))
3805        (sha256
3806          (base32
3807            "1621wx4k8h452p6xzmzzvm7mz87kxh4yqz0kzxfjj9xmjxlbyk2j"))))
3808    (build-system cargo-build-system)
3809    (arguments
3810      `(#:cargo-inputs
3811        (("rust-getopts" ,rust-getopts))
3812        #:cargo-development-inputs
3813        (("rust-quickcheck" ,rust-quickcheck)
3814         ("rust-term" ,rust-term))))
3815    (home-page
3816      "https://github.com/johannhof/difference.rs")
3817    (synopsis
3818      "A Rust text diffing and assertion library.")
3819    (description
3820      "This package provides a Rust text diffing and assertion library.")
3821    (license license:expat)))
3822
3823(define-public rust-once-cell
3824  (package
3825    (name "rust-once-cell")
3826    (version "1.2.0")
3827    (source
3828      (origin
3829        (method url-fetch)
3830        (uri (crate-uri "once_cell" version))
3831        (file-name
3832          (string-append name "-" version ".tar.gz"))
3833        (sha256
3834          (base32
3835            "1vdz8xlg3r05w3wfjimnc347hgm54i5nrqf72r4mlp0fcdplh7w9"))))
3836    (build-system cargo-build-system)
3837    (arguments
3838      `(#:cargo-inputs
3839        (("rust-parking-lot" ,rust-parking-lot))
3840        #:cargo-development-inputs
3841        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
3842         ("rust-lazy-static" ,rust-lazy-static)
3843         ("rust-regex" ,rust-regex))))
3844    (home-page
3845      "https://github.com/matklad/once_cell")
3846    (synopsis
3847      "Single assignment cells and lazy values.")
3848    (description
3849      "Single assignment cells and lazy values.")
3850    (license (list license:expat license:asl2.0))))
3851
3852(define-public rust-errno-dragonfly
3853  (package
3854    (name "rust-errno-dragonfly")
3855    (version "0.1.1")
3856    (source
3857      (origin
3858        (method url-fetch)
3859        (uri (crate-uri "errno-dragonfly" version))
3860        (file-name
3861          (string-append name "-" version ".tar.gz"))
3862        (sha256
3863          (base32
3864            "0rshlc00nv45f14v2l1w0ma2nf1jg5j7q9pvw7hh018r6r73bjhl"))))
3865    (build-system cargo-build-system)
3866    (arguments
3867      `(#:cargo-inputs
3868        (("rust-libc" ,rust-libc))
3869        #:cargo-development-inputs
3870        (("rust-gcc" ,rust-gcc))))
3871    (home-page
3872      "https://github.com/mneumann/errno-dragonfly-rs")
3873    (synopsis
3874      "Exposes errno functionality to stable Rust on DragonFlyBSD")
3875    (description
3876      "Exposes errno functionality to stable Rust on DragonFlyBSD")
3877    (license license:expat)))
3878
3879(define-public rust-errno
3880  (package
3881    (name "rust-errno")
3882    (version "0.2.4")
3883    (source
3884      (origin
3885        (method url-fetch)
3886        (uri (crate-uri "errno" version))
3887        (file-name
3888          (string-append name "-" version ".tar.gz"))
3889        (sha256
3890          (base32
3891            "0kn8mlygxxr02cm97401nppd2dbkwsalpcbai67rh6yh3rh73862"))))
3892    (build-system cargo-build-system)
3893    (arguments
3894      `(#:cargo-inputs
3895        (("rust-errno-dragonfly" ,rust-errno-dragonfly)
3896         ("rust-libc" ,rust-libc)
3897         ("rust-winapi" ,rust-winapi))))
3898    (home-page
3899      "https://github.com/lfairy/rust-errno")
3900    (synopsis
3901      "Cross-platform interface to the `errno` variable.")
3902    (description
3903      "Cross-platform interface to the `errno` variable.")
3904    (license #f)))
3905
3906(define-public rust-caps
3907  (package
3908    (name "rust-caps")
3909    (version "0.3.3")
3910    (source
3911      (origin
3912        (method url-fetch)
3913        (uri (crate-uri "caps" version))
3914        (file-name
3915          (string-append name "-" version ".tar.gz"))
3916        (sha256
3917          (base32
3918            "1vplgzx8nifzr3f0l8ca77jqnz3fdymdg0ickacgdvawc44a3n90"))))
3919    (build-system cargo-build-system)
3920    (arguments
3921      `(#:cargo-inputs
3922        (("rust-errno" ,rust-errno)
3923         ("rust-error-chain" ,rust-error-chain)
3924         ("rust-libc" ,rust-libc))))
3925    (home-page "https://github.com/lucab/caps-rs")
3926    (synopsis
3927      "A pure-Rust library to work with Linux capabilities")
3928    (description
3929      "This package provides a pure-Rust library to work with Linux capabilities")
3930    (license #f)))
3931
3932(define-public rust-sysctl
3933  (package
3934    (name "rust-sysctl")
3935    (version "0.4.0")
3936    (source
3937      (origin
3938        (method url-fetch)
3939        (uri (crate-uri "sysctl" version))
3940        (file-name
3941          (string-append name "-" version ".tar.gz"))
3942        (sha256
3943          (base32
3944            "0p6bfjsw3v12nb2qsgm6r9klwb5qyh4w55zzmccv8r5aqb8g0085"))))
3945    (build-system cargo-build-system)
3946    (arguments
3947      `(#:cargo-inputs
3948        (("rust-bitflags" ,rust-bitflags)
3949         ("rust-byteorder" ,rust-byteorder)
3950         ("rust-failure" ,rust-failure)
3951         ("rust-libc" ,rust-libc)
3952         ("rust-walkdir" ,rust-walkdir))))
3953    (home-page
3954      "https://github.com/johalun/sysctl-rs")
3955    (synopsis "Simplified interface to libc::sysctl")
3956    (description
3957      "Simplified interface to libc::sysctl")
3958    (license license:expat)))
3959
3960(define-public rust-nix
3961  (package
3962    (name "rust-nix")
3963    (version "0.15.0")
3964    (source
3965      (origin
3966        (method url-fetch)
3967        (uri (crate-uri "nix" version))
3968        (file-name
3969          (string-append name "-" version ".tar.gz"))
3970        (sha256
3971          (base32
3972            "0aa2l7wg9pzx24ks4p97gdy09a4hhs1sr9drxnm75v906d7hnbiv"))))
3973    (build-system cargo-build-system)
3974    (arguments
3975      `(#:cargo-inputs
3976        (("rust-bitflags" ,rust-bitflags)
3977         ("rust-cfg-if" ,rust-cfg-if)
3978         ("rust-libc" ,rust-libc)
3979         ("rust-void" ,rust-void))
3980        #:cargo-development-inputs
3981        (("rust-bytes" ,rust-bytes)
3982         ("rust-caps" ,rust-caps)
3983         ("rust-cc" ,rust-cc)
3984         ("rust-lazy-static" ,rust-lazy-static)
3985         ("rust-rand" ,rust-rand)
3986         ("rust-sysctl" ,rust-sysctl)
3987         ("rust-tempfile" ,rust-tempfile))))
3988    (home-page "https://github.com/nix-rust/nix")
3989    (synopsis "Rust friendly bindings to *nix APIs")
3990    (description
3991      "Rust friendly bindings to *nix APIs")
3992    (license license:expat)))
3993
3994(define-public rust-os-pipe
3995  (package
3996    (name "rust-os-pipe")
3997    (version "0.8.2")
3998    (source
3999      (origin
4000        (method url-fetch)
4001        (uri (crate-uri "os_pipe" version))
4002        (file-name
4003          (string-append name "-" version ".tar.gz"))
4004        (sha256
4005          (base32
4006            "049ax8shxik7mm68r2nf7xnrcq3z3p7hz54sbrcxwywxqsjdzs41"))))
4007    (build-system cargo-build-system)
4008    (arguments
4009      `(#:cargo-inputs
4010        (("rust-nix" ,rust-nix)
4011         ("rust-winapi" ,rust-winapi))))
4012    (home-page
4013      "https://github.com/oconnor663/os_pipe.rs")
4014    (synopsis
4015      "a cross-platform library for opening OS pipes")
4016    (description
4017      "a cross-platform library for opening OS pipes")
4018    (license license:expat)))
4019
4020(define-public rust-shared-child
4021  (package
4022    (name "rust-shared-child")
4023    (version "0.3.4")
4024    (source
4025      (origin
4026        (method url-fetch)
4027        (uri (crate-uri "shared_child" version))
4028        (file-name
4029          (string-append name "-" version ".tar.gz"))
4030        (sha256
4031          (base32
4032            "1lmjmr7931dr9cpalw2n7ss4i9mnl7285j2dygxflk9y80xczswc"))))
4033    (build-system cargo-build-system)
4034    (arguments
4035      `(#:cargo-inputs
4036        (("rust-libc" ,rust-libc)
4037         ("rust-winapi" ,rust-winapi))))
4038    (home-page
4039      "https://github.com/oconnor663/shared_child.rs")
4040    (synopsis
4041      "a library for using child processes from multiple threads")
4042    (description
4043      "a library for using child processes from multiple threads")
4044    (license license:expat)))
4045
4046(define-public rust-duct
4047  (package
4048    (name "rust-duct")
4049    (version "0.13.0")
4050    (source
4051      (origin
4052        (method url-fetch)
4053        (uri (crate-uri "duct" version))
4054        (file-name
4055          (string-append name "-" version ".tar.gz"))
4056        (sha256
4057          (base32
4058            "1ir3884i1yznkfdccqqbcb9v5sdpcgxlv41hgzncrqaljv18r0wj"))))
4059    (build-system cargo-build-system)
4060    (arguments
4061      `(#:cargo-inputs
4062        (("rust-libc" ,rust-libc)
4063         ("rust-once-cell" ,rust-once-cell)
4064         ("rust-os-pipe" ,rust-os-pipe)
4065         ("rust-shared-child" ,rust-shared-child))
4066        #:cargo-development-inputs
4067        (("rust-tempdir" ,rust-tempdir))))
4068    (home-page
4069      "https://github.com/oconnor663/duct.rs")
4070    (synopsis
4071      "a library for running child processes")
4072    (description
4073      "a library for running child processes")
4074    (license license:expat)))
4075
4076(define-public rust-bit-vec
4077  (package
4078    (name "rust-bit-vec")
4079    (version "0.6.1")
4080    (source
4081      (origin
4082        (method url-fetch)
4083        (uri (crate-uri "bit-vec" version))
4084        (file-name
4085          (string-append name "-" version ".tar.gz"))
4086        (sha256
4087          (base32
4088            "1xs6yba2jqlmzcm9ahzggrlb933c08ik9ah8zdsybylzhc83llm4"))))
4089    (build-system cargo-build-system)
4090    (arguments
4091      `(#:cargo-inputs
4092        (("rust-serde" ,rust-serde))
4093        #:cargo-development-inputs
4094        (("rust-serde-json" ,rust-serde-json))))
4095    (home-page
4096      "https://github.com/contain-rs/bit-vec")
4097    (synopsis "A vector of bits")
4098    (description
4099      "This package provides a vector of bits")
4100    (license #f)))
4101
4102(define-public rust-bit-set
4103  (package
4104    (name "rust-bit-set")
4105    (version "0.5.1")
4106    (source
4107      (origin
4108        (method url-fetch)
4109        (uri (crate-uri "bit-set" version))
4110        (file-name
4111          (string-append name "-" version ".tar.gz"))
4112        (sha256
4113          (base32
4114            "100ac8867bvbx9kv634w4xjk98b71i8nq4wdcvpf3cf4ha4j6k78"))))
4115    (build-system cargo-build-system)
4116    (arguments
4117      `(#:cargo-inputs
4118        (("rust-bit-vec" ,rust-bit-vec))
4119        #:cargo-development-inputs
4120        (("rust-rand" ,rust-rand))))
4121    (home-page
4122      "https://github.com/contain-rs/bit-set")
4123    (synopsis "A set of bits")
4124    (description
4125      "This package provides a set of bits")
4126    (license #f)))
4127
4128(define-public rust-blobby
4129  (package
4130    (name "rust-blobby")
4131    (version "0.1.2")
4132    (source
4133      (origin
4134        (method url-fetch)
4135        (uri (crate-uri "blobby" version))
4136        (file-name
4137          (string-append name "-" version ".tar.gz"))
4138        (sha256
4139          (base32
4140            "1xicpf3s2mi5xqnx8ps5mdych4ib5nh2nfsbrsg8ar8bjk1girbg"))))
4141    (build-system cargo-build-system)
4142    (arguments
4143      `(#:cargo-inputs
4144        (("rust-byteorder" ,rust-byteorder))
4145        #:cargo-development-inputs
4146        (("rust-byteorder" ,rust-byteorder)
4147         ("rust-hex" ,rust-hex))))
4148    (home-page "https://github.com/RustCrypto/utils")
4149    (synopsis
4150      "Iterator over simple binary blob storage")
4151    (description
4152      "Iterator over simple binary blob storage")
4153    (license (list license:expat license:asl2.0))))
4154
4155(define-public rust-generic-array
4156  (package
4157    (name "rust-generic-array")
4158    (version "0.13.2")
4159    (source
4160      (origin
4161        (method url-fetch)
4162        (uri (crate-uri "generic-array" version))
4163        (file-name
4164          (string-append name "-" version ".tar.gz"))
4165        (sha256
4166          (base32
4167            "1kddwxpd58y807y1r3lijg7sw3gxm6nczl6wp57gamhv6mhygl8f"))))
4168    (build-system cargo-build-system)
4169    (arguments
4170      `(#:cargo-inputs
4171        (("rust-serde" ,rust-serde)
4172         ("rust-typenum" ,rust-typenum))
4173        #:cargo-development-inputs
4174        (("rust-bincode" ,rust-bincode)
4175         ("rust-serde-json" ,rust-serde-json))))
4176    (home-page
4177      "https://github.com/fizyk20/generic-array.git")
4178    (synopsis
4179      "Generic types implementing functionality of arrays")
4180    (description
4181      "Generic types implementing functionality of arrays")
4182    (license license:expat)))
4183
4184(define-public rust-stream-cipher
4185  (package
4186    (name "rust-stream-cipher")
4187    (version "0.3.2")
4188    (source
4189      (origin
4190        (method url-fetch)
4191        (uri (crate-uri "stream-cipher" version))
4192        (file-name
4193          (string-append name "-" version ".tar.gz"))
4194        (sha256
4195          (base32
4196            "1333qng84n6b15p8kndhajlgvbp1rgdddx04xgsvrjlnb1m2acc1"))))
4197    (build-system cargo-build-system)
4198    (arguments
4199      `(#:cargo-inputs
4200        (("rust-blobby" ,rust-blobby)
4201         ("rust-generic-array" ,rust-generic-array))))
4202    (home-page
4203      "https://github.com/RustCrypto/traits")
4204    (synopsis "Stream cipher traits")
4205    (description "Stream cipher traits")
4206    (license (list license:expat license:asl2.0))))
4207
4208(define-public rust-hex-literal-impl
4209  (package
4210    (name "rust-hex-literal-impl")
4211    (version "0.2.1")
4212    (source
4213      (origin
4214        (method url-fetch)
4215        (uri (crate-uri "hex-literal-impl" version))
4216        (file-name
4217          (string-append name "-" version ".tar.gz"))
4218        (sha256
4219          (base32
4220            "0bgldhp5gdwwnikfdxigmz9b64qpgwbjqk6mfgv0pvig9s25qk4x"))))
4221    (build-system cargo-build-system)
4222    (arguments
4223      `(#:cargo-inputs
4224        (("rust-proc-macro-hack" ,rust-proc-macro-hack))))
4225    (home-page "https://github.com/RustCrypto/utils")
4226    (synopsis
4227      "Internal implementation of the hex-literal crate")
4228    (description
4229      "Internal implementation of the hex-literal crate")
4230    (license (list license:expat license:asl2.0))))
4231
4232(define-public rust-hex-literal
4233  (package
4234    (name "rust-hex-literal")
4235    (version "0.2.1")
4236    (source
4237      (origin
4238        (method url-fetch)
4239        (uri (crate-uri "hex-literal" version))
4240        (file-name
4241          (string-append name "-" version ".tar.gz"))
4242        (sha256
4243          (base32
4244            "1q36f0qq31ggh4ipcwb7a5g6jmci2010vn2v3qpaz4csxhhf47cn"))))
4245    (build-system cargo-build-system)
4246    (arguments
4247      `(#:cargo-inputs
4248        (("rust-hex-literal-impl" ,rust-hex-literal-impl)
4249         ("rust-proc-macro-hack" ,rust-proc-macro-hack))))
4250    (home-page "https://github.com/RustCrypto/utils")
4251    (synopsis
4252      "Procedural macro for converting hexadecimal string to byte array at compile time.")
4253    (description
4254      "Procedural macro for converting hexadecimal string to byte array at compile time.")
4255    (license (list license:expat license:asl2.0))))
4256
4257(define-public rust-c2-chacha
4258  (package
4259    (name "rust-c2-chacha")
4260    (version "0.2.2")
4261    (source
4262      (origin
4263        (method url-fetch)
4264        (uri (crate-uri "c2-chacha" version))
4265        (file-name
4266          (string-append name "-" version ".tar.gz"))
4267        (sha256
4268          (base32
4269            "00a11qdc8mg3z0k613rhprkc9p6xz0y7b1681x32ixg0hr3x0r3x"))))
4270    (build-system cargo-build-system)
4271    (arguments
4272      `(#:cargo-inputs
4273        (("rust-byteorder" ,rust-byteorder)
4274         ("rust-lazy-static" ,rust-lazy-static)
4275         ("rust-ppv-lite86" ,rust-ppv-lite86)
4276         ("rust-stream-cipher" ,rust-stream-cipher))
4277        #:cargo-development-inputs
4278        (("rust-hex-literal" ,rust-hex-literal))))
4279    (home-page
4280      "https://github.com/cryptocorrosion/cryptocorrosion")
4281    (synopsis "The ChaCha family of stream ciphers")
4282    (description
4283      "The ChaCha family of stream ciphers")
4284    (license #f)))
4285
4286(define-public rust-rand-chacha
4287  (package
4288    (name "rust-rand-chacha")
4289    (version "0.2.1")
4290    (source
4291      (origin
4292        (method url-fetch)
4293        (uri (crate-uri "rand_chacha" version))
4294        (file-name
4295          (string-append name "-" version ".tar.gz"))
4296        (sha256
4297          (base32
4298            "0lv8imzzl4h2glm6sjj8mkvasgi8jym23ya48dakyln7m06sk8h3"))))
4299    (build-system cargo-build-system)
4300    (arguments
4301      `(#:cargo-inputs
4302        (("rust-c2-chacha" ,rust-c2-chacha)
4303         ("rust-rand-core" ,rust-rand-core))))
4304    (home-page
4305      "https://crates.io/crates/rand_chacha")
4306    (synopsis "ChaCha random number generator
4307")
4308    (description "ChaCha random number generator
4309")
4310    (license #f)))
4311
4312(define-public rust-wait-timeout
4313  (package
4314    (name "rust-wait-timeout")
4315    (version "0.2.0")
4316    (source
4317      (origin
4318        (method url-fetch)
4319        (uri (crate-uri "wait-timeout" version))
4320        (file-name
4321          (string-append name "-" version ".tar.gz"))
4322        (sha256
4323          (base32
4324            "1xpkk0j5l9pfmjfh1pi0i89invlavfrd9av5xp0zhxgb29dhy84z"))))
4325    (build-system cargo-build-system)
4326    (arguments
4327      `(#:cargo-inputs (("rust-libc" ,rust-libc))))
4328    (home-page
4329      "https://github.com/alexcrichton/wait-timeout")
4330    (synopsis
4331      "A crate to wait on a child process with a timeout specified across Unix and
4332Windows platforms.
4333")
4334    (description
4335      "This package provides a crate to wait on a child process with a timeout specified across Unix and
4336Windows platforms.
4337")
4338    (license #f)))
4339
4340(define-public rust-rusty-fork
4341  (package
4342    (name "rust-rusty-fork")
4343    (version "0.2.2")
4344    (source
4345      (origin
4346        (method url-fetch)
4347        (uri (crate-uri "rusty-fork" version))
4348        (file-name
4349          (string-append name "-" version ".tar.gz"))
4350        (sha256
4351          (base32
4352            "1bjg8adk0i921088j52rn0hmvsry34q19g96x41pamqcw5j35n9x"))))
4353    (build-system cargo-build-system)
4354    (arguments
4355      `(#:cargo-inputs
4356        (("rust-fnv" ,rust-fnv)
4357         ("rust-quick-error" ,rust-quick-error)
4358         ("rust-tempfile" ,rust-tempfile)
4359         ("rust-wait-timeout" ,rust-wait-timeout))))
4360    (home-page
4361      "https://github.com/altsysrq/rusty-fork")
4362    (synopsis
4363      "Cross-platform library for running Rust tests in sub-processes using a
4364fork-like interface.
4365")
4366    (description
4367      "Cross-platform library for running Rust tests in sub-processes using a
4368fork-like interface.
4369")
4370    (license #f)))
4371
4372(define-public rust-proptest
4373  (package
4374    (name "rust-proptest")
4375    (version "0.9.4")
4376    (source
4377      (origin
4378        (method url-fetch)
4379        (uri (crate-uri "proptest" version))
4380        (file-name
4381          (string-append name "-" version ".tar.gz"))
4382        (sha256
4383          (base32
4384            "17sjg8isas4qk85807c4panih9k0lwa4k1mbajhciw5c5q17w56g"))))
4385    (build-system cargo-build-system)
4386    (arguments
4387      `(#:cargo-inputs
4388        (("rust-bit-set" ,rust-bit-set)
4389         ("rust-bitflags" ,rust-bitflags)
4390         ("rust-byteorder" ,rust-byteorder)
4391         ("rust-lazy-static" ,rust-lazy-static)
4392         ("rust-num-traits" ,rust-num-traits)
4393         ("rust-quick-error" ,rust-quick-error)
4394         ("rust-rand" ,rust-rand)
4395         ("rust-rand-chacha" ,rust-rand-chacha)
4396         ("rust-rand-xorshift" ,rust-rand-xorshift)
4397         ("rust-regex-syntax" ,rust-regex-syntax)
4398         ("rust-rusty-fork" ,rust-rusty-fork)
4399         ("rust-tempfile" ,rust-tempfile))
4400        #:cargo-development-inputs
4401        (("rust-regex" ,rust-regex))))
4402    (home-page
4403      "https://altsysrq.github.io/proptest-book/proptest/index.html")
4404    (synopsis
4405      "Hypothesis-like property-based testing and shrinking.
4406")
4407    (description
4408      "Hypothesis-like property-based testing and shrinking.
4409")
4410    (license #f)))
4411
4412(define-public rust-rustfix
4413  (package
4414    (name "rust-rustfix")
4415    (version "0.4.6")
4416    (source
4417      (origin
4418        (method url-fetch)
4419        (uri (crate-uri "rustfix" version))
4420        (file-name
4421          (string-append name "-" version ".tar.gz"))
4422        (sha256
4423          (base32
4424            "01zn0ysnass3mmrhxk90584y713vjfq1x97mi4saac99g9vsql3i"))))
4425    (build-system cargo-build-system)
4426    (arguments
4427      `(#:cargo-inputs
4428        (("rust-failure" ,rust-failure)
4429         ("rust-log" ,rust-log)
4430         ("rust-serde" ,rust-serde)
4431         ("rust-serde-json" ,rust-serde-json))
4432        #:cargo-development-inputs
4433        (("rust-difference" ,rust-difference)
4434         ("rust-duct" ,rust-duct)
4435         ("rust-env-logger" ,rust-env-logger)
4436         ("rust-log" ,rust-log)
4437         ("rust-proptest" ,rust-proptest)
4438         ("rust-tempdir" ,rust-tempdir))))
4439    (home-page
4440      "https://github.com/rust-lang-nursery/rustfix")
4441    (synopsis
4442      "Automatically apply the suggestions made by rustc")
4443    (description
4444      "Automatically apply the suggestions made by rustc")
4445    (license #f)))
4446
4447(define-public rust-tester
4448  (package
4449    (name "rust-tester")
4450    (version "0.5.0")
4451    (source
4452      (origin
4453        (method url-fetch)
4454        (uri (crate-uri "tester" version))
4455        (file-name
4456          (string-append name "-" version ".tar.gz"))
4457        (sha256
4458          (base32
4459            "1xkgapz2i4j977f6kh1zp6sa5llbhy5vbnr6kfj8czsrdjr2r0ay"))))
4460    (build-system cargo-build-system)
4461    (arguments
4462      `(#:cargo-inputs
4463        (("rust-getopts" ,rust-getopts)
4464         ("rust-libc" ,rust-libc)
4465         ("rust-term" ,rust-term))))
4466    (home-page
4467      "https://github.com/messense/rustc-test")
4468    (synopsis
4469      "A fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
4470    (description
4471      "This package provides a fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
4472    (license (list license:expat license:asl2.0))))
4473
4474(define-public rust-compiletest-rs
4475  (package
4476    (name "rust-compiletest-rs")
4477    (version "0.3.23")
4478    (source
4479      (origin
4480        (method url-fetch)
4481        (uri (crate-uri "compiletest_rs" version))
4482        (file-name
4483          (string-append name "-" version ".tar.gz"))
4484        (sha256
4485          (base32
4486            "0g9sms0abnirb1lv1m31xp367ar9dlczkjlwwk9w63mrmzkkyy7b"))))
4487    (build-system cargo-build-system)
4488    (arguments
4489      `(#:cargo-inputs
4490        (("rust-diff" ,rust-diff)
4491         ("rust-filetime" ,rust-filetime)
4492         ("rust-getopts" ,rust-getopts)
4493         ("rust-libc" ,rust-libc)
4494         ("rust-log" ,rust-log)
4495         ("rust-miow" ,rust-miow)
4496         ("rust-regex" ,rust-regex)
4497         ("rust-rustfix" ,rust-rustfix)
4498         ("rust-serde" ,rust-serde)
4499         ("rust-serde-derive" ,rust-serde-derive)
4500         ("rust-serde-json" ,rust-serde-json)
4501         ("rust-tempfile" ,rust-tempfile)
4502         ("rust-tester" ,rust-tester)
4503         ("rust-winapi" ,rust-winapi))))
4504    (home-page
4505      "https://github.com/laumann/compiletest-rs")
4506    (synopsis
4507      "The compiletest utility from the Rust compiler as a standalone testing harness")
4508    (description
4509      "The compiletest utility from the Rust compiler as a standalone testing harness")
4510    (license #f)))
4511
4512(define-public rust-phf-macros
4513  (package
4514    (name "rust-phf-macros")
4515    (version "0.7.24")
4516    (source
4517      (origin
4518        (method url-fetch)
4519        (uri (crate-uri "phf_macros" version))
4520        (file-name
4521          (string-append name "-" version ".tar.gz"))
4522        (sha256
4523          (base32
4524            "0dzylcy14ksy60h265l433j9ra8xhg8xlq3pd5qk658m6f1mxd5x"))))
4525    (build-system cargo-build-system)
4526    (arguments
4527      `(#:cargo-inputs
4528        (("rust-phf-generator" ,rust-phf-generator)
4529         ("rust-phf-shared" ,rust-phf-shared)
4530         ("rust-proc-macro2" ,rust-proc-macro2)
4531         ("rust-quote" ,rust-quote)
4532         ("rust-syn" ,rust-syn))
4533        #:cargo-development-inputs
4534        (("rust-compiletest-rs" ,rust-compiletest-rs))))
4535    (home-page
4536      "https://github.com/sfackler/rust-phf")
4537    (synopsis
4538      "Macros to generate types in the phf crate")
4539    (description
4540      "Macros to generate types in the phf crate")
4541    (license license:expat)))
4542
4543(define-public rust-phf
4544  (package
4545    (name "rust-phf")
4546    (version "0.7.24")
4547    (source
4548      (origin
4549        (method url-fetch)
4550        (uri (crate-uri "phf" version))
4551        (file-name
4552          (string-append name "-" version ".tar.gz"))
4553        (sha256
4554          (base32
4555            "066xwv4dr6056a9adlkarwp4n94kbpwngbmd47ngm3cfbyw49nmk"))))
4556    (build-system cargo-build-system)
4557    (arguments
4558      `(#:cargo-inputs
4559        (("rust-phf-macros" ,rust-phf-macros)
4560         ("rust-phf-shared" ,rust-phf-shared))))
4561    (home-page
4562      "https://github.com/sfackler/rust-phf")
4563    (synopsis
4564      "Runtime support for perfect hash function data structures")
4565    (description
4566      "Runtime support for perfect hash function data structures")
4567    (license license:expat)))
4568
4569(define-public rust-precomputed-hash
4570  (package
4571    (name "rust-precomputed-hash")
4572    (version "0.1.1")
4573    (source
4574      (origin
4575        (method url-fetch)
4576        (uri (crate-uri "precomputed-hash" version))
4577        (file-name
4578          (string-append name "-" version ".tar.gz"))
4579        (sha256
4580          (base32
4581            "075k9bfy39jhs53cb2fpb9klfakx2glxnf28zdw08ws6lgpq6lwj"))))
4582    (build-system cargo-build-system)
4583    (home-page
4584      "https://github.com/emilio/precomputed-hash")
4585    (synopsis
4586      "A library intending to be a base dependency to expose a precomputed hash")
4587    (description
4588      "This package provides a library intending to be a base dependency to expose a precomputed hash")
4589    (license license:expat)))
4590
4591(define-public rust-string-cache
4592  (package
4593    (name "rust-string-cache")
4594    (version "0.7.4")
4595    (source
4596      (origin
4597        (method url-fetch)
4598        (uri (crate-uri "string_cache" version))
4599        (file-name
4600          (string-append name "-" version ".tar.gz"))
4601        (sha256
4602          (base32
4603            "1w4ya29jy33am40drn1bmms4rggvq5paibdr5rzjvbrwbakv7k4n"))))
4604    (build-system cargo-build-system)
4605    (arguments
4606      `(#:cargo-inputs
4607        (("rust-lazy-static" ,rust-lazy-static)
4608         ("rust-new-debug-unreachable"
4609          ,rust-new-debug-unreachable)
4610         ("rust-phf-shared" ,rust-phf-shared)
4611         ("rust-precomputed-hash" ,rust-precomputed-hash)
4612         ("rust-serde" ,rust-serde)
4613         ("rust-string-cache-shared"
4614          ,rust-string-cache-shared))
4615        #:cargo-development-inputs
4616        (("rust-rand" ,rust-rand)
4617         ("rust-string-cache-codegen"
4618          ,rust-string-cache-codegen)
4619         ("rust-string-cache-codegen"
4620          ,rust-string-cache-codegen))))
4621    (home-page
4622      "https://github.com/servo/string-cache")
4623    (synopsis
4624      "A string interning library for Rust, developed as part of the Servo project.")
4625    (description
4626      "This package provides a string interning library for Rust, developed as part of the Servo project.")
4627    (license #f)))
4628
4629(define-public rust-phf-codegen
4630  (package
4631    (name "rust-phf-codegen")
4632    (version "0.7.24")
4633    (source
4634      (origin
4635        (method url-fetch)
4636        (uri (crate-uri "phf_codegen" version))
4637        (file-name
4638          (string-append name "-" version ".tar.gz"))
4639        (sha256
4640          (base32
4641            "0zjiblicfm0nrmr2xxrs6pnf6zz2394wgch6dcbd8jijkq98agmh"))))
4642    (build-system cargo-build-system)
4643    (arguments
4644      `(#:cargo-inputs
4645        (("rust-phf-generator" ,rust-phf-generator)
4646         ("rust-phf-shared" ,rust-phf-shared))))
4647    (home-page
4648      "https://github.com/sfackler/rust-phf")
4649    (synopsis "Codegen library for PHF types")
4650    (description "Codegen library for PHF types")
4651    (license license:expat)))
4652
4653(define-public rust-phf-generator
4654  (package
4655    (name "rust-phf-generator")
4656    (version "0.7.24")
4657    (source
4658      (origin
4659        (method url-fetch)
4660        (uri (crate-uri "phf_generator" version))
4661        (file-name
4662          (string-append name "-" version ".tar.gz"))
4663        (sha256
4664          (base32
4665            "0qi62gxk3x3whrmw5c4i71406icqk11qmpgln438p6qm7k4lqdh9"))))
4666    (build-system cargo-build-system)
4667    (arguments
4668      `(#:cargo-inputs
4669        (("rust-phf-shared" ,rust-phf-shared)
4670         ("rust-rand" ,rust-rand))))
4671    (home-page
4672      "https://github.com/sfackler/rust-phf")
4673    (synopsis "PHF generation logic")
4674    (description "PHF generation logic")
4675    (license license:expat)))
4676
4677(define-public rust-siphasher
4678  (package
4679    (name "rust-siphasher")
4680    (version "0.3.1")
4681    (source
4682      (origin
4683        (method url-fetch)
4684        (uri (crate-uri "siphasher" version))
4685        (file-name
4686          (string-append name "-" version ".tar.gz"))
4687        (sha256
4688          (base32
4689            "17cj2ynbv5zs7fa8ylrw7a6pb260q53ccj091mj9xa6ix0745nl3"))))
4690    (build-system cargo-build-system)
4691    (home-page "https://docs.rs/siphasher")
4692    (synopsis
4693      "SipHash-2-4, SipHash-1-3 and 128-bit variants in pure Rust")
4694    (description
4695      "SipHash-2-4, SipHash-1-3 and 128-bit variants in pure Rust")
4696    (license #f)))
4697
4698(define-public rust-phf-shared
4699  (package
4700    (name "rust-phf-shared")
4701    (version "0.7.24")
4702    (source
4703      (origin
4704        (method url-fetch)
4705        (uri (crate-uri "phf_shared" version))
4706        (file-name
4707          (string-append name "-" version ".tar.gz"))
4708        (sha256
4709          (base32
4710            "18371fla0vsj7d6d5rlfb747xbr2in11ar9vgv5qna72bnhp2kr3"))))
4711    (build-system cargo-build-system)
4712    (arguments
4713      `(#:cargo-inputs
4714        (("rust-siphasher" ,rust-siphasher)
4715         ("rust-unicase" ,rust-unicase))))
4716    (home-page
4717      "https://github.com/sfackler/rust-phf")
4718    (synopsis "Support code shared by PHF libraries")
4719    (description
4720      "Support code shared by PHF libraries")
4721    (license license:expat)))
4722
4723(define-public rust-string-cache-shared
4724  (package
4725    (name "rust-string-cache-shared")
4726    (version "0.3.0")
4727    (source
4728      (origin
4729        (method url-fetch)
4730        (uri (crate-uri "string_cache_shared" version))
4731        (file-name
4732          (string-append name "-" version ".tar.gz"))
4733        (sha256
4734          (base32
4735            "1z7dpdix1m42x6ddshdcpjf91ml9mhvnskmiv5kd8hcpq0dlv25i"))))
4736    (build-system cargo-build-system)
4737    (home-page
4738      "https://github.com/servo/string-cache")
4739    (synopsis
4740      "Code share between string_cache and string_cache_codegen.")
4741    (description
4742      "Code share between string_cache and string_cache_codegen.")
4743    (license #f)))
4744
4745(define-public rust-string-cache-codegen
4746  (package
4747    (name "rust-string-cache-codegen")
4748    (version "0.4.4")
4749    (source
4750      (origin
4751        (method url-fetch)
4752        (uri (crate-uri "string_cache_codegen" version))
4753        (file-name
4754          (string-append name "-" version ".tar.gz"))
4755        (sha256
4756          (base32
4757            "1ik78h9gs874i24rkyh0myg6x4ni2a9cazbv5yzs9yavnv8mxx7h"))))
4758    (build-system cargo-build-system)
4759    (arguments
4760      `(#:cargo-inputs
4761        (("rust-phf-generator" ,rust-phf-generator)
4762         ("rust-phf-shared" ,rust-phf-shared)
4763         ("rust-proc-macro2" ,rust-proc-macro2)
4764         ("rust-quote" ,rust-quote)
4765         ("rust-string-cache-shared"
4766          ,rust-string-cache-shared))))
4767    (home-page
4768      "https://github.com/servo/string-cache")
4769    (synopsis
4770      "A codegen library for string-cache, developed as part of the Servo project.")
4771    (description
4772      "This package provides a codegen library for string-cache, developed as part of the Servo project.")
4773    (license #f)))
4774
4775(define-public rust-markup5ever
4776  (package
4777    (name "rust-markup5ever")
4778    (version "0.9.0")
4779    (source
4780      (origin
4781        (method url-fetch)
4782        (uri (crate-uri "markup5ever" version))
4783        (file-name
4784          (string-append name "-" version ".tar.gz"))
4785        (sha256
4786          (base32
4787            "00wxigkiw8f777pjp7q5kfq77xpwda9zskkwp698assh8yfisf35"))))
4788    (build-system cargo-build-system)
4789    (arguments
4790      `(#:cargo-inputs
4791        (("rust-log" ,rust-log)
4792         ("rust-phf" ,rust-phf)
4793         ("rust-string-cache" ,rust-string-cache)
4794         ("rust-tendril" ,rust-tendril))
4795        #:cargo-development-inputs
4796        (("rust-phf-codegen" ,rust-phf-codegen)
4797         ("rust-serde" ,rust-serde)
4798         ("rust-serde-derive" ,rust-serde-derive)
4799         ("rust-serde-json" ,rust-serde-json)
4800         ("rust-string-cache-codegen"
4801          ,rust-string-cache-codegen))))
4802    (home-page "https://github.com/servo/html5ever")
4803    (synopsis
4804      "Common code for xml5ever and html5ever")
4805    (description
4806      "Common code for xml5ever and html5ever")
4807    (license #f)))
4808
4809(define-public rust-typed-arena
4810  (package
4811    (name "rust-typed-arena")
4812    (version "1.6.1")
4813    (source
4814      (origin
4815        (method url-fetch)
4816        (uri (crate-uri "typed-arena" version))
4817        (file-name
4818          (string-append name "-" version ".tar.gz"))
4819        (sha256
4820          (base32
4821            "01z6l9xv9izbyycxmwxiz4g6ibjb52dm2zc47mfpj56kk6kh81ww"))))
4822    (build-system cargo-build-system)
4823    (arguments
4824      `(#:cargo-development-inputs
4825        (("rust-criterion" ,rust-criterion))))
4826    (home-page
4827      "https://github.com/SimonSapin/rust-typed-arena")
4828    (synopsis
4829      "The arena, a fast but limited type of allocator")
4830    (description
4831      "The arena, a fast but limited type of allocator")
4832    (license license:expat)))
4833
4834(define-public rust-html5ever
4835  (package
4836    (name "rust-html5ever")
4837    (version "0.24.1")
4838    (source
4839      (origin
4840        (method url-fetch)
4841        (uri (crate-uri "html5ever" version))
4842        (file-name
4843          (string-append name "-" version ".tar.gz"))
4844        (sha256
4845          (base32
4846            "1js4cr04941ld4r4fqpblvfigy75ds48qcbqhnr7nmz4l6q86m02"))))
4847    (build-system cargo-build-system)
4848    (arguments
4849      `(#:cargo-inputs
4850        (("rust-log" ,rust-log)
4851         ("rust-mac" ,rust-mac)
4852         ("rust-markup5ever" ,rust-markup5ever))
4853        #:cargo-development-inputs
4854        (("rust-criterion" ,rust-criterion)
4855         ("rust-proc-macro2" ,rust-proc-macro2)
4856         ("rust-quote" ,rust-quote)
4857         ("rust-rustc-test" ,rust-rustc-test)
4858         ("rust-serde-json" ,rust-serde-json)
4859         ("rust-syn" ,rust-syn)
4860         ("rust-typed-arena" ,rust-typed-arena))))
4861    (home-page "https://github.com/servo/html5ever")
4862    (synopsis
4863      "High-performance browser-grade HTML5 parser")
4864    (description
4865      "High-performance browser-grade HTML5 parser")
4866    (license #f)))
4867
4868(define-public rust-encoding-index-japanese
4869  (package
4870    (name "rust-encoding-index-japanese")
4871    (version "1.20141219.5")
4872    (source
4873      (origin
4874        (method url-fetch)
4875        (uri (crate-uri "encoding-index-japanese" version))
4876        (file-name
4877          (string-append name "-" version ".tar.gz"))
4878        (sha256
4879          (base32
4880            "148c1lmd640p1d7fzk0nv7892mbyavvwddgqvcsm78798bzv5s04"))))
4881    (build-system cargo-build-system)
4882    (arguments
4883      `(#:cargo-inputs
4884        (("rust-encoding-index-tests"
4885          ,rust-encoding-index-tests))))
4886    (home-page
4887      "https://github.com/lifthrasiir/rust-encoding")
4888    (synopsis
4889      "Index tables for Japanese character encodings")
4890    (description
4891      "Index tables for Japanese character encodings")
4892    (license license:cc0)))
4893
4894(define-public rust-encoding-index-korean
4895  (package
4896    (name "rust-encoding-index-korean")
4897    (version "1.20141219.5")
4898    (source
4899      (origin
4900        (method url-fetch)
4901        (uri (crate-uri "encoding-index-korean" version))
4902        (file-name
4903          (string-append name "-" version ".tar.gz"))
4904        (sha256
4905          (base32
4906            "10cxabp5ppygbq4y6y680856zl9zjvq7ahpiw8zj3fmwwsw3zhsd"))))
4907    (build-system cargo-build-system)
4908    (arguments
4909      `(#:cargo-inputs
4910        (("rust-encoding-index-tests"
4911          ,rust-encoding-index-tests))))
4912    (home-page
4913      "https://github.com/lifthrasiir/rust-encoding")
4914    (synopsis
4915      "Index tables for Korean character encodings")
4916    (description
4917      "Index tables for Korean character encodings")
4918    (license license:cc0)))
4919
4920(define-public rust-encoding-index-simpchinese
4921  (package
4922    (name "rust-encoding-index-simpchinese")
4923    (version "1.20141219.5")
4924    (source
4925      (origin
4926        (method url-fetch)
4927        (uri (crate-uri "encoding-index-simpchinese" version))
4928        (file-name
4929          (string-append name "-" version ".tar.gz"))
4930        (sha256
4931          (base32
4932            "1xria2i7mc5dqdrpqxasdbxv1qx46jjbm53if3y1i4cvj2a72ynq"))))
4933    (build-system cargo-build-system)
4934    (arguments
4935      `(#:cargo-inputs
4936        (("rust-encoding-index-tests"
4937          ,rust-encoding-index-tests))))
4938    (home-page
4939      "https://github.com/lifthrasiir/rust-encoding")
4940    (synopsis
4941      "Index tables for simplified Chinese character encodings")
4942    (description
4943      "Index tables for simplified Chinese character encodings")
4944    (license license:cc0)))
4945
4946(define-public rust-encoding-index-singlebyte
4947  (package
4948    (name "rust-encoding-index-singlebyte")
4949    (version "1.20141219.5")
4950    (source
4951      (origin
4952        (method url-fetch)
4953        (uri (crate-uri "encoding-index-singlebyte" version))
4954        (file-name
4955          (string-append name "-" version ".tar.gz"))
4956        (sha256
4957          (base32
4958            "0jp85bz2pprzvg9m95w4q0vibh67b6w3bx35lafay95jzyndal9k"))))
4959    (build-system cargo-build-system)
4960    (arguments
4961      `(#:cargo-inputs
4962        (("rust-encoding-index-tests"
4963          ,rust-encoding-index-tests))))
4964    (home-page
4965      "https://github.com/lifthrasiir/rust-encoding")
4966    (synopsis
4967      "Index tables for various single-byte character encodings")
4968    (description
4969      "Index tables for various single-byte character encodings")
4970    (license license:cc0)))
4971
4972(define-public rust-encoding-index-tests
4973  (package
4974    (name "rust-encoding-index-tests")
4975    (version "0.1.4")
4976    (source
4977      (origin
4978        (method url-fetch)
4979        (uri (crate-uri "encoding_index_tests" version))
4980        (file-name
4981          (string-append name "-" version ".tar.gz"))
4982        (sha256
4983          (base32
4984            "0s85y091gl17ixass49bzaivng7w8p82p6nyvz2r3my9w4mxhim2"))))
4985    (build-system cargo-build-system)
4986    (home-page
4987      "https://github.com/lifthrasiir/rust-encoding")
4988    (synopsis
4989      "Helper macros used to test index tables for character encodings")
4990    (description
4991      "Helper macros used to test index tables for character encodings")
4992    (license license:cc0)))
4993
4994(define-public rust-encoding-index-tradchinese
4995  (package
4996    (name "rust-encoding-index-tradchinese")
4997    (version "1.20141219.5")
4998    (source
4999      (origin
5000        (method url-fetch)
5001        (uri (crate-uri "encoding-index-tradchinese" version))
5002        (file-name
5003          (string-append name "-" version ".tar.gz"))
5004        (sha256
5005          (base32
5006            "060ci4iz6xfvzk38syfbjvs7pix5hch3mvxkksswmqwcd3aj03px"))))
5007    (build-system cargo-build-system)
5008    (arguments
5009      `(#:cargo-inputs
5010        (("rust-encoding-index-tests"
5011          ,rust-encoding-index-tests))))
5012    (home-page
5013      "https://github.com/lifthrasiir/rust-encoding")
5014    (synopsis
5015      "Index tables for traditional Chinese character encodings")
5016    (description
5017      "Index tables for traditional Chinese character encodings")
5018    (license license:cc0)))
5019
5020(define-public rust-encoding
5021  (package
5022    (name "rust-encoding")
5023    (version "0.2.33")
5024    (source
5025      (origin
5026        (method url-fetch)
5027        (uri (crate-uri "encoding" version))
5028        (file-name
5029          (string-append name "-" version ".tar.gz"))
5030        (sha256
5031          (base32
5032            "1v1ndmkarh9z3n5hk53da4z56hgk9wa5kcsm7cnx345raqw983bb"))))
5033    (build-system cargo-build-system)
5034    (arguments
5035      `(#:cargo-inputs
5036        (("rust-encoding-index-japanese"
5037          ,rust-encoding-index-japanese)
5038         ("rust-encoding-index-korean"
5039          ,rust-encoding-index-korean)
5040         ("rust-encoding-index-simpchinese"
5041          ,rust-encoding-index-simpchinese)
5042         ("rust-encoding-index-singlebyte"
5043          ,rust-encoding-index-singlebyte)
5044         ("rust-encoding-index-tradchinese"
5045          ,rust-encoding-index-tradchinese))
5046        #:cargo-development-inputs
5047        (("rust-getopts" ,rust-getopts))))
5048    (home-page
5049      "https://github.com/lifthrasiir/rust-encoding")
5050    (synopsis "Character encoding support for Rust")
5051    (description
5052      "Character encoding support for Rust")
5053    (license license:expat)))
5054
5055(define-public rust-core-arch
5056  (package
5057    (name "rust-core-arch")
5058    (version "0.1.5")
5059    (source
5060      (origin
5061        (method url-fetch)
5062        (uri (crate-uri "core_arch" version))
5063        (file-name
5064          (string-append name "-" version ".tar.gz"))
5065        (sha256
5066          (base32
5067            "04vdvr9vj0f1cv2p54nsszmrrk9w1js4c0z4i0bdlajl1lydslim"))))
5068    (build-system cargo-build-system)
5069    (arguments
5070      `(#:cargo-development-inputs
5071        (("rust-wasm-bindgen-test"
5072          ,rust-wasm-bindgen-test))))
5073    (home-page
5074      "https://github.com/rust-lang-nursery/stdsimd")
5075    (synopsis
5076      "`core::arch` - Rust's core library architecture-specific intrinsics.")
5077    (description
5078      "`core::arch` - Rust's core library architecture-specific intrinsics.")
5079    (license #f)))
5080
5081(define-public rust-cexpr
5082  (package
5083    (name "rust-cexpr")
5084    (version "0.3.5")
5085    (source
5086      (origin
5087        (method url-fetch)
5088        (uri (crate-uri "cexpr" version))
5089        (file-name
5090          (string-append name "-" version ".tar.gz"))
5091        (sha256
5092          (base32
5093            "1by64ini3f058pwad3immx5cc12wr0m0kwgaxa8apzym03mj9ym7"))))
5094    (build-system cargo-build-system)
5095    (arguments
5096      `(#:cargo-inputs
5097        (("rust-nom" ,rust-nom))
5098        #:cargo-development-inputs
5099        (("rust-clang-sys" ,rust-clang-sys))))
5100    (home-page
5101      "https://github.com/jethrogb/rust-cexpr")
5102    (synopsis "A C expression parser and evaluator")
5103    (description
5104      "This package provides a C expression parser and evaluator")
5105    (license #f)))
5106
5107(define-public rust-which
5108  (package
5109    (name "rust-which")
5110    (version "3.0.0")
5111    (source
5112      (origin
5113        (method url-fetch)
5114        (uri (crate-uri "which" version))
5115        (file-name
5116          (string-append name "-" version ".tar.gz"))
5117        (sha256
5118          (base32
5119            "0scs6d0kaww66sgrs07b0xdkaday91c2pd1mkzjfixvj70b322i4"))))
5120    (build-system cargo-build-system)
5121    (arguments
5122      `(#:cargo-inputs
5123        (("rust-failure" ,rust-failure)
5124         ("rust-libc" ,rust-libc))
5125        #:cargo-development-inputs
5126        (("rust-tempdir" ,rust-tempdir))))
5127    (home-page
5128      "https://github.com/harryfei/which-rs.git")
5129    (synopsis
5130      "A Rust equivalent of Unix command \"which\". Locate installed executable in cross platforms.")
5131    (description
5132      "This package provides a Rust equivalent of Unix command \"which\".  Locate installed executable in cross platforms.")
5133    (license license:expat)))
5134
5135(define-public rust-bindgen
5136  (package
5137    (name "rust-bindgen")
5138    (version "0.51.1")
5139    (source
5140      (origin
5141        (method url-fetch)
5142        (uri (crate-uri "bindgen" version))
5143        (file-name
5144          (string-append name "-" version ".tar.gz"))
5145        (sha256
5146          (base32
5147            "0x9gndlnwmxsihxvsc3izyyss7g8b2djn0daafshj1gcy69i7mzb"))))
5148    (build-system cargo-build-system)
5149    (arguments
5150      `(#:cargo-inputs
5151        (("rust-bitflags" ,rust-bitflags)
5152         ("rust-cexpr" ,rust-cexpr)
5153         ("rust-cfg-if" ,rust-cfg-if)
5154         ("rust-clang-sys" ,rust-clang-sys)
5155         ("rust-clap" ,rust-clap)
5156         ("rust-env-logger" ,rust-env-logger)
5157         ("rust-lazy-static" ,rust-lazy-static)
5158         ("rust-log" ,rust-log)
5159         ("rust-peeking-take-while"
5160          ,rust-peeking-take-while)
5161         ("rust-proc-macro2" ,rust-proc-macro2)
5162         ("rust-quote" ,rust-quote)
5163         ("rust-regex" ,rust-regex)
5164         ("rust-rustc-hash" ,rust-rustc-hash)
5165         ("rust-shlex" ,rust-shlex)
5166         ("rust-which" ,rust-which))
5167        #:cargo-development-inputs
5168        (("rust-clap" ,rust-clap)
5169         ("rust-diff" ,rust-diff)
5170         ("rust-shlex" ,rust-shlex))))
5171    (home-page
5172      "https://rust-lang.github.io/rust-bindgen/")
5173    (synopsis
5174      "Automatically generates Rust FFI bindings to C and C++ libraries.")
5175    (description
5176      "Automatically generates Rust FFI bindings to C and C++ libraries.")
5177    (license license:bsd-3)))
5178
5179(define-public rust-sleef-sys
5180  (package
5181    (name "rust-sleef-sys")
5182    (version "0.1.2")
5183    (source
5184      (origin
5185        (method url-fetch)
5186        (uri (crate-uri "sleef-sys" version))
5187        (file-name
5188          (string-append name "-" version ".tar.gz"))
5189        (sha256
5190          (base32
5191            "1881q2yc17j2m1yvh01447c93ws1mspnrj3k2nbvwbvcm8z81kkv"))))
5192    (build-system cargo-build-system)
5193    (arguments
5194      `(#:cargo-inputs
5195        (("rust-cfg-if" ,rust-cfg-if)
5196         ("rust-libc" ,rust-libc))
5197        #:cargo-development-inputs
5198        (("rust-bindgen" ,rust-bindgen)
5199         ("rust-cmake" ,rust-cmake)
5200         ("rust-env-logger" ,rust-env-logger))))
5201    (home-page "https://github.com/gnzlbg/sleef-sys")
5202    (synopsis
5203      "Rust FFI bindings to the SLEEF Vectorized Math Library
5204")
5205    (description
5206      "Rust FFI bindings to the SLEEF Vectorized Math Library
5207")
5208    (license #f)))
5209
5210(define-public rust-paste-impl
5211  (package
5212    (name "rust-paste-impl")
5213    (version "0.1.6")
5214    (source
5215      (origin
5216        (method url-fetch)
5217        (uri (crate-uri "paste-impl" version))
5218        (file-name
5219          (string-append name "-" version ".tar.gz"))
5220        (sha256
5221          (base32
5222            "1ig6ahgh27kdz4midarryzx2y6xdi9za9a8vp11byqgg2blwj522"))))
5223    (build-system cargo-build-system)
5224    (arguments
5225      `(#:cargo-inputs
5226        (("rust-proc-macro-hack" ,rust-proc-macro-hack)
5227         ("rust-proc-macro2" ,rust-proc-macro2)
5228         ("rust-quote" ,rust-quote)
5229         ("rust-syn" ,rust-syn))))
5230    (home-page "https://github.com/dtolnay/paste")
5231    (synopsis
5232      "Implementation detail of the `paste` crate")
5233    (description
5234      "Implementation detail of the `paste` crate")
5235    (license (list license:expat license:asl2.0))))
5236
5237(define-public rust-demo-hack
5238  (package
5239    (name "rust-demo-hack")
5240    (version "0.0.5")
5241    (source
5242      (origin
5243        (method url-fetch)
5244        (uri (crate-uri "demo-hack" version))
5245        (file-name
5246          (string-append name "-" version ".tar.gz"))
5247        (sha256
5248          (base32
5249            "0m0114p1g0zzrdph5bg03i8m8p70vrwn3whs191jrbjcrmh5lmnp"))))
5250    (build-system cargo-build-system)
5251    (arguments
5252      `(#:cargo-inputs
5253        (("rust-demo-hack-impl" ,rust-demo-hack-impl)
5254         ("rust-proc-macro-hack" ,rust-proc-macro-hack))))
5255    (home-page
5256      "https://github.com/dtolnay/proc-macro-hack")
5257    (synopsis "Demo of proc-macro-hack")
5258    (description "Demo of proc-macro-hack")
5259    (license #f)))
5260
5261(define-public rust-demo-hack-impl
5262  (package
5263    (name "rust-demo-hack-impl")
5264    (version "0.0.5")
5265    (source
5266      (origin
5267        (method url-fetch)
5268        (uri (crate-uri "demo-hack-impl" version))
5269        (file-name
5270          (string-append name "-" version ".tar.gz"))
5271        (sha256
5272          (base32
5273            "1f1fdl60xjas9wlmcl9v6f56vgm3mzwr019kcifav5464rx3w3ld"))))
5274    (build-system cargo-build-system)
5275    (arguments
5276      `(#:cargo-inputs
5277        (("rust-proc-macro-hack" ,rust-proc-macro-hack)
5278         ("rust-quote" ,rust-quote)
5279         ("rust-syn" ,rust-syn))))
5280    (home-page
5281      "https://github.com/dtolnay/proc-macro-hack")
5282    (synopsis "Demo of proc-macro-hack")
5283    (description "Demo of proc-macro-hack")
5284    (license #f)))
5285
5286(define-public rust-proc-macro-hack
5287  (package
5288    (name "rust-proc-macro-hack")
5289    (version "0.5.10")
5290    (source
5291      (origin
5292        (method url-fetch)
5293        (uri (crate-uri "proc-macro-hack" version))
5294        (file-name
5295          (string-append name "-" version ".tar.gz"))
5296        (sha256
5297          (base32
5298            "17cs9y27xmrvkf9yqjl1yrb635606cxgbx8sy18gbdvf88gxyk0i"))))
5299    (build-system cargo-build-system)
5300    (arguments
5301      `(#:cargo-inputs
5302        (("rust-proc-macro2" ,rust-proc-macro2)
5303         ("rust-quote" ,rust-quote)
5304         ("rust-syn" ,rust-syn))
5305        #:cargo-development-inputs
5306        (("rust-demo-hack" ,rust-demo-hack)
5307         ("rust-demo-hack-impl" ,rust-demo-hack-impl))))
5308    (home-page
5309      "https://github.com/dtolnay/proc-macro-hack")
5310    (synopsis
5311      "Procedural macros in expression position")
5312    (description
5313      "Procedural macros in expression position")
5314    (license (list license:expat license:asl2.0))))
5315
5316(define-public rust-paste
5317  (package
5318    (name "rust-paste")
5319    (version "0.1.6")
5320    (source
5321      (origin
5322        (method url-fetch)
5323        (uri (crate-uri "paste" version))
5324        (file-name
5325          (string-append name "-" version ".tar.gz"))
5326        (sha256
5327          (base32
5328            "0jdaxr0hpkim6as7ywx7x3f479igxpczj85pfcg8z0kf3jg52fj2"))))
5329    (build-system cargo-build-system)
5330    (arguments
5331      `(#:cargo-inputs
5332        (("rust-paste-impl" ,rust-paste-impl)
5333         ("rust-proc-macro-hack" ,rust-proc-macro-hack))))
5334    (home-page "https://github.com/dtolnay/paste")
5335    (synopsis
5336      "Macros for all your token pasting needs")
5337    (description
5338      "Macros for all your token pasting needs")
5339    (license (list license:expat license:asl2.0))))
5340
5341(define-public rust-packed-simd
5342  (package
5343    (name "rust-packed-simd")
5344    (version "0.3.3")
5345    (source
5346      (origin
5347        (method url-fetch)
5348        (uri (crate-uri "packed_simd" version))
5349        (file-name
5350          (string-append name "-" version ".tar.gz"))
5351        (sha256
5352          (base32
5353            "0822wqf6kzw4ig9ykndg348w2bxkhs3x64brzsvdxh2a1pyajpm8"))))
5354    (build-system cargo-build-system)
5355    (arguments
5356      `(#:cargo-inputs
5357        (("rust-cfg-if" ,rust-cfg-if)
5358         ("rust-core-arch" ,rust-core-arch)
5359         ("rust-sleef-sys" ,rust-sleef-sys))
5360        #:cargo-development-inputs
5361        (("rust-arrayvec" ,rust-arrayvec)
5362         ("rust-paste" ,rust-paste)
5363         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
5364         ("rust-wasm-bindgen-test"
5365          ,rust-wasm-bindgen-test))))
5366    (home-page
5367      "https://github.com/rust-lang-nursery/packed_simd")
5368    (synopsis "Portable Packed SIMD vectors")
5369    (description "Portable Packed SIMD vectors")
5370    (license #f)))
5371
5372(define-public rust-encoding-rs
5373  (package
5374    (name "rust-encoding-rs")
5375    (version "0.8.20")
5376    (source
5377      (origin
5378        (method url-fetch)
5379        (uri (crate-uri "encoding_rs" version))
5380        (file-name
5381          (string-append name "-" version ".tar.gz"))
5382        (sha256
5383          (base32
5384            "1s8jgqx26q2p6msyq0b4ik8rd0g9wszqbvf2jabgf5kpj8c0a947"))))
5385    (build-system cargo-build-system)
5386    (arguments
5387      `(#:cargo-inputs
5388        (("rust-cfg-if" ,rust-cfg-if)
5389         ("rust-packed-simd" ,rust-packed-simd)
5390         ("rust-serde" ,rust-serde))
5391        #:cargo-development-inputs
5392        (("rust-bincode" ,rust-bincode)
5393         ("rust-serde-derive" ,rust-serde-derive)
5394         ("rust-serde-json" ,rust-serde-json))))
5395    (home-page "https://docs.rs/encoding_rs/")
5396    (synopsis
5397      "A Gecko-oriented implementation of the Encoding Standard")
5398    (description
5399      "This package provides a Gecko-oriented implementation of the Encoding Standard")
5400    (license #f)))
5401
5402(define-public rust-new-debug-unreachable
5403  (package
5404    (name "rust-new-debug-unreachable")
5405    (version "1.0.3")
5406    (source
5407      (origin
5408        (method url-fetch)
5409        (uri (crate-uri "new_debug_unreachable" version))
5410        (file-name
5411          (string-append name "-" version ".tar.gz"))
5412        (sha256
5413          (base32
5414            "0c1br326qa0rrzxrn2rd5ah7xaprig2i9r4rwsx06vnvc1f003zl"))))
5415    (build-system cargo-build-system)
5416    (home-page
5417      "https://github.com/mbrubeck/rust-debug-unreachable")
5418    (synopsis
5419      "panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)")
5420    (description
5421      "panic in debug, intrinsics::unreachable() in release (fork of debug_unreachable)")
5422    (license license:expat)))
5423
5424(define-public rust-futf
5425  (package
5426    (name "rust-futf")
5427    (version "0.1.4")
5428    (source
5429      (origin
5430        (method url-fetch)
5431        (uri (crate-uri "futf" version))
5432        (file-name
5433          (string-append name "-" version ".tar.gz"))
5434        (sha256
5435          (base32
5436            "0fxc18bnabird5jl941nsd6d25vq8cn8barmz4d30dlkzbiir73w"))))
5437    (build-system cargo-build-system)
5438    (arguments
5439      `(#:cargo-inputs
5440        (("rust-mac" ,rust-mac)
5441         ("rust-new-debug-unreachable"
5442          ,rust-new-debug-unreachable))))
5443    (home-page "https://github.com/servo/futf")
5444    (synopsis "Handling fragments of UTF-8")
5445    (description "Handling fragments of UTF-8")
5446    (license #f)))
5447
5448(define-public rust-mac
5449  (package
5450    (name "rust-mac")
5451    (version "0.1.1")
5452    (source
5453      (origin
5454        (method url-fetch)
5455        (uri (crate-uri "mac" version))
5456        (file-name
5457          (string-append name "-" version ".tar.gz"))
5458        (sha256
5459          (base32
5460            "194vc7vrshqff72rl56f9xgb0cazyl4jda7qsv31m5l6xx7hq7n4"))))
5461    (build-system cargo-build-system)
5462    (home-page
5463      "https://github.com/reem/rust-mac.git")
5464    (synopsis
5465      "A collection of great and ubiqutitous macros.")
5466    (description
5467      "This package provides a collection of great and ubiqutitous macros.")
5468    (license #f)))
5469
5470(define-public rust-utf-8
5471  (package
5472    (name "rust-utf-8")
5473    (version "0.7.5")
5474    (source
5475      (origin
5476        (method url-fetch)
5477        (uri (crate-uri "utf-8" version))
5478        (file-name
5479          (string-append name "-" version ".tar.gz"))
5480        (sha256
5481          (base32
5482            "1iw5rp4i3mfi9k51picbr5bgjqhjcmnxx7001clh5ydq31y2zr05"))))
5483    (build-system cargo-build-system)
5484    (home-page
5485      "https://github.com/SimonSapin/rust-utf8")
5486    (synopsis
5487      "Incremental, zero-copy UTF-8 decoding with error handling")
5488    (description
5489      "Incremental, zero-copy UTF-8 decoding with error handling")
5490    (license (list license:expat license:asl2.0))))
5491
5492(define-public rust-tendril
5493  (package
5494    (name "rust-tendril")
5495    (version "0.4.1")
5496    (source
5497      (origin
5498        (method url-fetch)
5499        (uri (crate-uri "tendril" version))
5500        (file-name
5501          (string-append name "-" version ".tar.gz"))
5502        (sha256
5503          (base32
5504            "0fsx7blrrzgca8aa2yqy8zxyi8s7amskhgkk1ml5sbaqyalyszvh"))))
5505    (build-system cargo-build-system)
5506    (arguments
5507      `(#:cargo-inputs
5508        (("rust-encoding" ,rust-encoding)
5509         ("rust-encoding-rs" ,rust-encoding-rs)
5510         ("rust-futf" ,rust-futf)
5511         ("rust-mac" ,rust-mac)
5512         ("rust-utf-8" ,rust-utf-8))
5513        #:cargo-development-inputs
5514        (("rust-rand" ,rust-rand))))
5515    (home-page "https://github.com/servo/tendril")
5516    (synopsis
5517      "Compact buffer/string type for zero-copy parsing")
5518    (description
5519      "Compact buffer/string type for zero-copy parsing")
5520    (license #f)))
5521
5522(define-public rust-pulldown-cmark
5523  (package
5524    (name "rust-pulldown-cmark")
5525    (version "0.6.0")
5526    (source
5527      (origin
5528        (method url-fetch)
5529        (uri (crate-uri "pulldown-cmark" version))
5530        (file-name
5531          (string-append name "-" version ".tar.gz"))
5532        (sha256
5533          (base32
5534            "1916kszqfa9h8ja7wjbx945qb0qzwzslynxvwrg9c0hp9h6svc45"))))
5535    (build-system cargo-build-system)
5536    (arguments
5537      `(#:cargo-inputs
5538        (("rust-bitflags" ,rust-bitflags)
5539         ("rust-getopts" ,rust-getopts)
5540         ("rust-memchr" ,rust-memchr)
5541         ("rust-unicase" ,rust-unicase))
5542        #:cargo-development-inputs
5543        (("rust-criterion" ,rust-criterion)
5544         ("rust-html5ever" ,rust-html5ever)
5545         ("rust-lazy-static" ,rust-lazy-static)
5546         ("rust-regex" ,rust-regex)
5547         ("rust-tendril" ,rust-tendril))))
5548    (home-page
5549      "https://github.com/raphlinus/pulldown-cmark")
5550    (synopsis "A pull parser for CommonMark")
5551    (description
5552      "This package provides a pull parser for CommonMark")
5553    (license license:expat)))
5554
5555(define-public rust-linked-hash-map
5556  (package
5557    (name "rust-linked-hash-map")
5558    (version "0.5.2")
5559    (source
5560      (origin
5561        (method url-fetch)
5562        (uri (crate-uri "linked-hash-map" version))
5563        (file-name
5564          (string-append name "-" version ".tar.gz"))
5565        (sha256
5566          (base32
5567            "10qgbvh00q36ql0jh00rxh2jlq6qvl11n6mig0cvkpf4xf5bd4df"))))
5568    (build-system cargo-build-system)
5569    (arguments
5570      `(#:cargo-inputs
5571        (("rust-clippy" ,rust-clippy)
5572         ("rust-heapsize" ,rust-heapsize)
5573         ("rust-serde" ,rust-serde)
5574         ("rust-serde-test" ,rust-serde-test))))
5575    (home-page
5576      "https://github.com/contain-rs/linked-hash-map")
5577    (synopsis
5578      "A HashMap wrapper that holds key-value pairs in insertion order")
5579    (description
5580      "This package provides a HashMap wrapper that holds key-value pairs in insertion order")
5581    (license #f)))
5582
5583(define-public rust-toml
5584  (package
5585    (name "rust-toml")
5586    (version "0.5.3")
5587    (source
5588      (origin
5589        (method url-fetch)
5590        (uri (crate-uri "toml" version))
5591        (file-name
5592          (string-append name "-" version ".tar.gz"))
5593        (sha256
5594          (base32
5595            "093p48vpqm4bb8q3514xsij0dkljxlr3jp9ypxr4p48xjisvxan7"))))
5596    (build-system cargo-build-system)
5597    (arguments
5598      `(#:cargo-inputs
5599        (("rust-linked-hash-map" ,rust-linked-hash-map)
5600         ("rust-serde" ,rust-serde))
5601        #:cargo-development-inputs
5602        (("rust-serde-derive" ,rust-serde-derive)
5603         ("rust-serde-json" ,rust-serde-json))))
5604    (home-page
5605      "https://github.com/alexcrichton/toml-rs")
5606    (synopsis
5607      "A native Rust encoder and decoder of TOML-formatted files and streams. Provides
5608implementations of the standard Serialize/Deserialize traits for TOML data to
5609facilitate deserializing and serializing Rust structures.
5610")
5611    (description
5612      "This package provides a native Rust encoder and decoder of TOML-formatted files and streams.  Provides
5613implementations of the standard Serialize/Deserialize traits for TOML data to
5614facilitate deserializing and serializing Rust structures.
5615")
5616    (license #f)))
5617
5618(define-public rust-version-sync
5619  (package
5620    (name "rust-version-sync")
5621    (version "0.8.1")
5622    (source
5623      (origin
5624        (method url-fetch)
5625        (uri (crate-uri "version-sync" version))
5626        (file-name
5627          (string-append name "-" version ".tar.gz"))
5628        (sha256
5629          (base32
5630            "01pq0ia7ak7d69c3chjgdmaaq271yrspgbzmk6wmrwb74hx3skw4"))))
5631    (build-system cargo-build-system)
5632    (arguments
5633      `(#:cargo-inputs
5634        (("rust-itertools" ,rust-itertools)
5635         ("rust-proc-macro2" ,rust-proc-macro2)
5636         ("rust-pulldown-cmark" ,rust-pulldown-cmark)
5637         ("rust-regex" ,rust-regex)
5638         ("rust-semver-parser" ,rust-semver-parser)
5639         ("rust-syn" ,rust-syn)
5640         ("rust-toml" ,rust-toml)
5641         ("rust-url" ,rust-url))))
5642    (home-page
5643      "https://github.com/mgeisler/version-sync")
5644    (synopsis
5645      "Simple crate for ensuring that version numbers in README files are
5646updated when the crate version changes.
5647")
5648    (description
5649      "Simple crate for ensuring that version numbers in README files are
5650updated when the crate version changes.
5651")
5652    (license license:expat)))
5653
5654(define-public rust-signal-hook-registry
5655  (package
5656    (name "rust-signal-hook-registry")
5657    (version "1.1.1")
5658    (source
5659      (origin
5660        (method url-fetch)
5661        (uri (crate-uri "signal-hook-registry" version))
5662        (file-name
5663          (string-append name "-" version ".tar.gz"))
5664        (sha256
5665          (base32
5666            "1p2q8cdrkq6xcjjj097vrsrz9y98k7kkakmiif8465pr727x95qp"))))
5667    (build-system cargo-build-system)
5668    (arguments
5669      `(#:cargo-inputs
5670        (("rust-arc-swap" ,rust-arc-swap)
5671         ("rust-libc" ,rust-libc))
5672        #:cargo-development-inputs
5673        (("rust-signal-hook" ,rust-signal-hook)
5674         ("rust-version-sync" ,rust-version-sync))))
5675    (home-page
5676      "https://github.com/vorner/signal-hook")
5677    (synopsis "Backend crate for signal-hook")
5678    (description "Backend crate for signal-hook")
5679    (license #f)))
5680
5681(define-public rust-tracing-attributes
5682  (package
5683    (name "rust-tracing-attributes")
5684    (version "0.1.4")
5685    (source
5686      (origin
5687        (method url-fetch)
5688        (uri (crate-uri "tracing-attributes" version))
5689        (file-name
5690          (string-append name "-" version ".tar.gz"))
5691        (sha256
5692          (base32
5693            "0g2cmg9rbrjxrsymqc126iml1ii16iqlgqkiqv4jrzlskkypiy9z"))))
5694    (build-system cargo-build-system)
5695    (arguments
5696      `(#:cargo-inputs
5697        (("rust-quote" ,rust-quote)
5698         ("rust-syn" ,rust-syn))
5699        #:cargo-development-inputs
5700        (("rust-tracing" ,rust-tracing))))
5701    (home-page "https://tokio.rs")
5702    (synopsis
5703      "Procedural macro attributes for automatically instrumenting functions.
5704")
5705    (description
5706      "Procedural macro attributes for automatically instrumenting functions.
5707")
5708    (license license:expat)))
5709
5710(define-public rust-tracing
5711  (package
5712    (name "rust-tracing")
5713    (version "0.1.9")
5714    (source
5715      (origin
5716        (method url-fetch)
5717        (uri (crate-uri "tracing" version))
5718        (file-name
5719          (string-append name "-" version ".tar.gz"))
5720        (sha256
5721          (base32
5722            "1zz5swjx2c22y2225psy69zfcndhs1aggs10dhw97hncg92zj7y2"))))
5723    (build-system cargo-build-system)
5724    (arguments
5725      `(#:cargo-inputs
5726        (("rust-cfg-if" ,rust-cfg-if)
5727         ("rust-log" ,rust-log)
5728         ("rust-spin" ,rust-spin)
5729         ("rust-tracing-attributes"
5730          ,rust-tracing-attributes)
5731         ("rust-tracing-core" ,rust-tracing-core))
5732        #:cargo-development-inputs
5733        (("rust-criterion" ,rust-criterion)
5734         ("rust-futures" ,rust-futures)
5735         ("rust-log" ,rust-log))))
5736    (home-page "https://tokio.rs")
5737    (synopsis
5738      "Application-level tracing for Rust.
5739")
5740    (description
5741      "Application-level tracing for Rust.
5742")
5743    (license license:expat)))
5744
5745(define-public rust-tokio-net
5746  (package
5747    (name "rust-tokio-net")
5748    (version "0.2.0-alpha.6")
5749    (source
5750      (origin
5751        (method url-fetch)
5752        (uri (crate-uri "tokio-net" version))
5753        (file-name
5754          (string-append name "-" version ".tar.gz"))
5755        (sha256
5756          (base32
5757            "0m16ik7a4x2js26qrky5a0czmjgmfbrsgi0j64w5jd9gscn6hhd4"))))
5758    (build-system cargo-build-system)
5759    (arguments
5760      `(#:cargo-inputs
5761        (("rust-bytes" ,rust-bytes)
5762         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
5763         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
5764         ("rust-futures-core-preview"
5765          ,rust-futures-core-preview)
5766         ("rust-futures-sink-preview"
5767          ,rust-futures-sink-preview)
5768         ("rust-futures-util-preview"
5769          ,rust-futures-util-preview)
5770         ("rust-iovec" ,rust-iovec)
5771         ("rust-lazy-static" ,rust-lazy-static)
5772         ("rust-libc" ,rust-libc)
5773         ("rust-mio" ,rust-mio)
5774         ("rust-mio-named-pipes" ,rust-mio-named-pipes)
5775         ("rust-mio-uds" ,rust-mio-uds)
5776         ("rust-num-cpus" ,rust-num-cpus)
5777         ("rust-parking-lot" ,rust-parking-lot)
5778         ("rust-signal-hook-registry"
5779          ,rust-signal-hook-registry)
5780         ("rust-slab" ,rust-slab)
5781         ("rust-tokio-codec" ,rust-tokio-codec)
5782         ("rust-tokio-executor" ,rust-tokio-executor)
5783         ("rust-tokio-io" ,rust-tokio-io)
5784         ("rust-tokio-sync" ,rust-tokio-sync)
5785         ("rust-tracing" ,rust-tracing)
5786         ("rust-tracing" ,rust-tracing)
5787         ("rust-winapi" ,rust-winapi))))
5788    (home-page "https://tokio.rs")
5789    (synopsis
5790      "Event loop that drives Tokio I/O resources.
5791")
5792    (description
5793      "Event loop that drives Tokio I/O resources.
5794")
5795    (license license:expat)))
5796
5797(define-public rust-tokio
5798  (package
5799    (name "rust-tokio")
5800    (version "0.2.0-alpha.6")
5801    (source
5802      (origin
5803        (method url-fetch)
5804        (uri (crate-uri "tokio" version))
5805        (file-name
5806          (string-append name "-" version ".tar.gz"))
5807        (sha256
5808          (base32
5809            "0f5sdr13xdqpgcy89s9pnzy79pwbg6qqzckqcr8c2d8gmgbga5qz"))))
5810    (build-system cargo-build-system)
5811    (arguments
5812      `(#:cargo-inputs
5813        (("rust-bytes" ,rust-bytes)
5814         ("rust-futures-core-preview"
5815          ,rust-futures-core-preview)
5816         ("rust-futures-sink-preview"
5817          ,rust-futures-sink-preview)
5818         ("rust-futures-util-preview"
5819          ,rust-futures-util-preview)
5820         ("rust-num-cpus" ,rust-num-cpus)
5821         ("rust-tokio-codec" ,rust-tokio-codec)
5822         ("rust-tokio-executor" ,rust-tokio-executor)
5823         ("rust-tokio-executor" ,rust-tokio-executor)
5824         ("rust-tokio-fs" ,rust-tokio-fs)
5825         ("rust-tokio-io" ,rust-tokio-io)
5826         ("rust-tokio-macros" ,rust-tokio-macros)
5827         ("rust-tokio-net" ,rust-tokio-net)
5828         ("rust-tokio-net" ,rust-tokio-net)
5829         ("rust-tokio-sync" ,rust-tokio-sync)
5830         ("rust-tokio-timer" ,rust-tokio-timer)
5831         ("rust-tracing-core" ,rust-tracing-core))))
5832    (home-page "https://tokio.rs")
5833    (synopsis
5834      "An event-driven, non-blocking I/O platform for writing asynchronous I/O
5835backed applications.
5836")
5837    (description
5838      "An event-driven, non-blocking I/O platform for writing asynchronous I/O
5839backed applications.
5840")
5841    (license license:expat)))
5842
5843(define-public rust-pin-convert
5844  (package
5845    (name "rust-pin-convert")
5846    (version "0.1.0")
5847    (source
5848      (origin
5849        (method url-fetch)
5850        (uri (crate-uri "pin-convert" version))
5851        (file-name
5852          (string-append name "-" version ".tar.gz"))
5853        (sha256
5854          (base32
5855            "01j8zskmg91xqk39126a93n82a5xdl0fkirqcd3017mlg271dk90"))))
5856    (build-system cargo-build-system)
5857    (home-page
5858      "https://github.com/carllerche/pin-convert")
5859    (synopsis
5860      "Traits for converting to `Pin` variants.
5861")
5862    (description
5863      "Traits for converting to `Pin` variants.
5864")
5865    (license license:expat)))
5866
5867(define-public rust-tokio-timer
5868  (package
5869    (name "rust-tokio-timer")
5870    (version "0.3.0-alpha.6")
5871    (source
5872      (origin
5873        (method url-fetch)
5874        (uri (crate-uri "tokio-timer" version))
5875        (file-name
5876          (string-append name "-" version ".tar.gz"))
5877        (sha256
5878          (base32
5879            "04rc8x0y2827wbgxlzqzphdnhfss7ahxmad48nr8w0bizs3iaz5r"))))
5880    (build-system cargo-build-system)
5881    (arguments
5882      `(#:cargo-inputs
5883        (("rust-crossbeam-utils" ,rust-crossbeam-utils)
5884         ("rust-futures-core-preview"
5885          ,rust-futures-core-preview)
5886         ("rust-futures-util-preview"
5887          ,rust-futures-util-preview)
5888         ("rust-slab" ,rust-slab)
5889         ("rust-tokio-executor" ,rust-tokio-executor)
5890         ("rust-tokio-sync" ,rust-tokio-sync))))
5891    (home-page "https://github.com/tokio-rs/tokio")
5892    (synopsis "Timer facilities for Tokio
5893")
5894    (description "Timer facilities for Tokio
5895")
5896    (license license:expat)))
5897
5898(define-public rust-tokio-test
5899  (package
5900    (name "rust-tokio-test")
5901    (version "0.2.0-alpha.6")
5902    (source
5903      (origin
5904        (method url-fetch)
5905        (uri (crate-uri "tokio-test" version))
5906        (file-name
5907          (string-append name "-" version ".tar.gz"))
5908        (sha256
5909          (base32
5910            "003j9cyaaq79ypf8bbzi2x6f1cq1d086yshjy2dbj6l8zw6hhdqp"))))
5911    (build-system cargo-build-system)
5912    (arguments
5913      `(#:cargo-inputs
5914        (("rust-futures-core-preview"
5915          ,rust-futures-core-preview)
5916         ("rust-pin-convert" ,rust-pin-convert)
5917         ("rust-tokio" ,rust-tokio)
5918         ("rust-tokio-executor" ,rust-tokio-executor)
5919         ("rust-tokio-io" ,rust-tokio-io)
5920         ("rust-tokio-sync" ,rust-tokio-sync)
5921         ("rust-tokio-timer" ,rust-tokio-timer))
5922        #:cargo-development-inputs
5923        (("rust-futures-util-preview"
5924          ,rust-futures-util-preview))))
5925    (home-page "https://tokio.rs")
5926    (synopsis
5927      "Testing utilities for Tokio- and futures-based code
5928")
5929    (description
5930      "Testing utilities for Tokio- and futures-based code
5931")
5932    (license license:expat)))
5933
5934(define-public rust-tokio-threadpool
5935  (package
5936    (name "rust-tokio-threadpool")
5937    (version "0.2.0-alpha.1")
5938    (source
5939      (origin
5940        (method url-fetch)
5941        (uri (crate-uri "tokio-threadpool" version))
5942        (file-name
5943          (string-append name "-" version ".tar.gz"))
5944        (sha256
5945          (base32
5946            "16g4zqk0h1ng1pws6m7v3yajwklsyhpm9r5c901zz532fsv3nb0z"))))
5947    (build-system cargo-build-system)
5948    (arguments
5949      `(#:cargo-inputs
5950        (("rust-crossbeam-deque" ,rust-crossbeam-deque)
5951         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
5952         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
5953         ("rust-futures-core-preview"
5954          ,rust-futures-core-preview)
5955         ("rust-futures-util-preview"
5956          ,rust-futures-util-preview)
5957         ("rust-lazy-static" ,rust-lazy-static)
5958         ("rust-log" ,rust-log)
5959         ("rust-num-cpus" ,rust-num-cpus)
5960         ("rust-slab" ,rust-slab)
5961         ("rust-tokio-executor" ,rust-tokio-executor)
5962         ("rust-tokio-sync" ,rust-tokio-sync))
5963        #:cargo-development-inputs
5964        (("rust-env-logger" ,rust-env-logger)
5965         ("rust-rand" ,rust-rand)
5966         ("rust-tokio" ,rust-tokio)
5967         ("rust-tokio-test" ,rust-tokio-test))))
5968    (home-page "https://github.com/tokio-rs/tokio")
5969    (synopsis
5970      "A task scheduler backed by a work-stealing thread pool.
5971")
5972    (description
5973      "This package provides a task scheduler backed by a work-stealing thread pool.
5974")
5975    (license license:expat)))
5976
5977(define-public rust-flate2
5978  (package
5979    (name "rust-flate2")
5980    (version "1.0.12")
5981    (source
5982      (origin
5983        (method url-fetch)
5984        (uri (crate-uri "flate2" version))
5985        (file-name
5986          (string-append name "-" version ".tar.gz"))
5987        (sha256
5988          (base32
5989            "1lw1y5dj9xcn105l5c0w0dpgcsn1wvbj7d1ij1qwhh59r4rm4g5d"))))
5990    (build-system cargo-build-system)
5991    (arguments
5992      `(#:cargo-inputs
5993        (("rust-cfg-if" ,rust-cfg-if)
5994         ("rust-crc32fast" ,rust-crc32fast)
5995         ("rust-futures" ,rust-futures)
5996         ("rust-libc" ,rust-libc)
5997         ("rust-libz-sys" ,rust-libz-sys)
5998         ("rust-miniz-sys" ,rust-miniz-sys)
5999         ("rust-miniz-oxide" ,rust-miniz-oxide)
6000         ("rust-miniz-oxide" ,rust-miniz-oxide)
6001         ("rust-tokio-io" ,rust-tokio-io))
6002        #:cargo-development-inputs
6003        (("rust-futures" ,rust-futures)
6004         ("rust-quickcheck" ,rust-quickcheck)
6005         ("rust-rand" ,rust-rand)
6006         ("rust-tokio-io" ,rust-tokio-io)
6007         ("rust-tokio-tcp" ,rust-tokio-tcp)
6008         ("rust-tokio-threadpool" ,rust-tokio-threadpool))))
6009    (home-page
6010      "https://github.com/alexcrichton/flate2-rs")
6011    (synopsis
6012      "Bindings to miniz.c for DEFLATE compression and decompression exposed as
6013Reader/Writer streams. Contains bindings for zlib, deflate, and gzip-based
6014streams.
6015")
6016    (description
6017      "Bindings to miniz.c for DEFLATE compression and decompression exposed as
6018Reader/Writer streams.  Contains bindings for zlib, deflate, and gzip-based
6019streams.
6020")
6021    (license #f)))
6022
6023(define-public rust-indexmap
6024  (package
6025    (name "rust-indexmap")
6026    (version "1.2.0")
6027    (source
6028      (origin
6029        (method url-fetch)
6030        (uri (crate-uri "indexmap" version))
6031        (file-name
6032          (string-append name "-" version ".tar.gz"))
6033        (sha256
6034          (base32
6035            "1wwr29axr92bbk5kbmshqw935kqb32h219q4jhg9ajkcwkxh44m6"))))
6036    (build-system cargo-build-system)
6037    (arguments
6038      `(#:cargo-inputs
6039        (("rust-rayon" ,rust-rayon)
6040         ("rust-serde" ,rust-serde))
6041        #:cargo-development-inputs
6042        (("rust-fnv" ,rust-fnv)
6043         ("rust-itertools" ,rust-itertools)
6044         ("rust-lazy-static" ,rust-lazy-static)
6045         ("rust-quickcheck" ,rust-quickcheck)
6046         ("rust-rand" ,rust-rand)
6047         ("rust-serde-test" ,rust-serde-test))))
6048    (home-page "https://github.com/bluss/indexmap")
6049    (synopsis
6050      "A hash table with consistent order and fast iteration.
6051
6052The indexmap is a hash table where the iteration order of the key-value
6053pairs is independent of the hash values of the keys. It has the usual
6054hash table functionality, it preserves insertion order except after
6055removals, and it allows lookup of its elements by either hash table key
6056or numerical index. A corresponding hash set type is also provided.
6057
6058This crate was initially published under the name ordermap, but it was renamed to
6059indexmap.
6060")
6061    (description
6062      "This package provides a hash table with consistent order and fast iteration.
6063
6064The indexmap is a hash table where the iteration order of the key-value
6065pairs is independent of the hash values of the keys.  It has the usual
6066hash table functionality, it preserves insertion order except after
6067removals, and it allows lookup of its elements by either hash table key
6068or numerical index.  A corresponding hash set type is also provided.
6069
6070This crate was initially published under the name ordermap, but it was renamed to
6071indexmap.
6072")
6073    (license #f)))
6074
6075(define-public rust-synstructure
6076  (package
6077    (name "rust-synstructure")
6078    (version "0.12.1")
6079    (source
6080      (origin
6081        (method url-fetch)
6082        (uri (crate-uri "synstructure" version))
6083        (file-name
6084          (string-append name "-" version ".tar.gz"))
6085        (sha256
6086          (base32
6087            "00x28sjln2w7vfmnh5m98d7wzbm49q2cz20jr90h834kamc5l21z"))))
6088    (build-system cargo-build-system)
6089    (arguments
6090      `(#:cargo-inputs
6091        (("rust-proc-macro2" ,rust-proc-macro2)
6092         ("rust-quote" ,rust-quote)
6093         ("rust-syn" ,rust-syn)
6094         ("rust-unicode-xid" ,rust-unicode-xid))
6095        #:cargo-development-inputs
6096        (("rust-synstructure-test-traits"
6097          ,rust-synstructure-test-traits))))
6098    (home-page
6099      "https://github.com/mystor/synstructure")
6100    (synopsis
6101      "Helper methods and macros for custom derives")
6102    (description
6103      "Helper methods and macros for custom derives")
6104    (license license:expat)))
6105
6106(define-public rust-failure-derive
6107  (package
6108    (name "rust-failure-derive")
6109    (version "0.1.5")
6110    (source
6111      (origin
6112        (method url-fetch)
6113        (uri (crate-uri "failure_derive" version))
6114        (file-name
6115          (string-append name "-" version ".tar.gz"))
6116        (sha256
6117          (base32
6118            "1q97n7dp51j5hndzic9ng2fgn6f3z5ya1992w84l7vypby8n647a"))))
6119    (build-system cargo-build-system)
6120    (arguments
6121      `(#:cargo-inputs
6122        (("rust-proc-macro2" ,rust-proc-macro2)
6123         ("rust-quote" ,rust-quote)
6124         ("rust-syn" ,rust-syn)
6125         ("rust-synstructure" ,rust-synstructure))
6126        #:cargo-development-inputs
6127        (("rust-failure" ,rust-failure))))
6128    (home-page
6129      "https://rust-lang-nursery.github.io/failure/")
6130    (synopsis "derives for the failure crate")
6131    (description "derives for the failure crate")
6132    (license (list license:expat license:asl2.0))))
6133
6134(define-public rust-target-lexicon
6135  (package
6136    (name "rust-target-lexicon")
6137    (version "0.8.1")
6138    (source
6139      (origin
6140        (method url-fetch)
6141        (uri (crate-uri "target-lexicon" version))
6142        (file-name
6143          (string-append name "-" version ".tar.gz"))
6144        (sha256
6145          (base32
6146            "06kl5bd5llhscla9bpkgfmj195qmn0mll0651ccppmrpdwncnxbr"))))
6147    (build-system cargo-build-system)
6148    (arguments
6149      `(#:cargo-inputs
6150        (("rust-failure" ,rust-failure)
6151         ("rust-failure-derive" ,rust-failure-derive))
6152        #:cargo-development-inputs
6153        (("rust-serde-json" ,rust-serde-json))))
6154    (home-page
6155      "https://github.com/CraneStation/target-lexicon")
6156    (synopsis
6157      "Targeting utilities for compilers and related tools")
6158    (description
6159      "Targeting utilities for compilers and related tools")
6160    (license #f)))
6161
6162(define-public rust-foreign-types-macros
6163  (package
6164    (name "rust-foreign-types-macros")
6165    (version "0.1.1")
6166    (source
6167      (origin
6168        (method url-fetch)
6169        (uri (crate-uri "foreign-types-macros" version))
6170        (file-name
6171          (string-append name "-" version ".tar.gz"))
6172        (sha256
6173          (base32
6174            "0bh6z5rwdhfm987idal8r0ha5svz1li7md5l1g2a5966gya1jns0"))))
6175    (build-system cargo-build-system)
6176    (arguments
6177      `(#:cargo-inputs
6178        (("rust-proc-macro2" ,rust-proc-macro2)
6179         ("rust-quote" ,rust-quote)
6180         ("rust-syn" ,rust-syn))))
6181    (home-page
6182      "https://github.com/sfackler/foreign-types")
6183    (synopsis
6184      "An internal crate used by foreign-types")
6185    (description
6186      "An internal crate used by foreign-types")
6187    (license #f)))
6188
6189(define-public rust-foreign-types
6190  (package
6191    (name "rust-foreign-types")
6192    (version "0.4.0")
6193    (source
6194      (origin
6195        (method url-fetch)
6196        (uri (crate-uri "foreign-types" version))
6197        (file-name
6198          (string-append name "-" version ".tar.gz"))
6199        (sha256
6200          (base32
6201            "0ca4i38yrf9iy5k47lr1ylb3rvcbn36d81k5pr5kzf6kmj6p111n"))))
6202    (build-system cargo-build-system)
6203    (arguments
6204      `(#:cargo-inputs
6205        (("rust-foreign-types-macros"
6206          ,rust-foreign-types-macros)
6207         ("rust-foreign-types-shared"
6208          ,rust-foreign-types-shared))))
6209    (home-page
6210      "https://github.com/sfackler/foreign-types")
6211    (synopsis
6212      "A framework for Rust wrappers over C APIs")
6213    (description
6214      "This package provides a framework for Rust wrappers over C APIs")
6215    (license #f)))
6216
6217(define-public rust-openssl
6218  (package
6219    (name "rust-openssl")
6220    (version "0.10.25")
6221    (source
6222      (origin
6223        (method url-fetch)
6224        (uri (crate-uri "openssl" version))
6225        (file-name
6226          (string-append name "-" version ".tar.gz"))
6227        (sha256
6228          (base32
6229            "0jblcmpdh2zzyk868qkwjlmhfz9s9rkslyik7a1gn46facmjndrg"))))
6230    (build-system cargo-build-system)
6231    (arguments
6232      `(#:cargo-inputs
6233        (("rust-bitflags" ,rust-bitflags)
6234         ("rust-cfg-if" ,rust-cfg-if)
6235         ("rust-foreign-types" ,rust-foreign-types)
6236         ("rust-lazy-static" ,rust-lazy-static)
6237         ("rust-libc" ,rust-libc)
6238         ("rust-openssl-sys" ,rust-openssl-sys))
6239        #:cargo-development-inputs
6240        (("rust-hex" ,rust-hex)
6241         ("rust-tempdir" ,rust-tempdir))))
6242    (home-page
6243      "https://github.com/sfackler/rust-openssl")
6244    (synopsis "OpenSSL bindings")
6245    (description "OpenSSL bindings")
6246    (license license:asl2.0)))
6247
6248(define-public rust-sha1
6249  (package
6250    (name "rust-sha1")
6251    (version "0.6.0")
6252    (source
6253      (origin
6254        (method url-fetch)
6255        (uri (crate-uri "sha1" version))
6256        (file-name
6257          (string-append name "-" version ".tar.gz"))
6258        (sha256
6259          (base32
6260            "03gs2q4m67rn2p8xcdfxhip6mpgahdwm12bnb3vh90ahv9grhy95"))))
6261    (build-system cargo-build-system)
6262    (arguments
6263      `(#:cargo-inputs
6264        (("rust-serde" ,rust-serde))
6265        #:cargo-development-inputs
6266        (("rust-openssl" ,rust-openssl)
6267         ("rust-rand" ,rust-rand)
6268         ("rust-serde-json" ,rust-serde-json))))
6269    (home-page
6270      "https://github.com/mitsuhiko/rust-sha1")
6271    (synopsis
6272      "Minimal implementation of SHA1 for Rust.")
6273    (description
6274      "Minimal implementation of SHA1 for Rust.")
6275    (license license:bsd-3)))
6276
6277(define-public rust-half
6278  (package
6279    (name "rust-half")
6280    (version "1.3.0")
6281    (source
6282      (origin
6283        (method url-fetch)
6284        (uri (crate-uri "half" version))
6285        (file-name
6286          (string-append name "-" version ".tar.gz"))
6287        (sha256
6288          (base32
6289            "0diqajg3mgar511hxswl4kgqqz9a026yvn3103x5h2smknlc4lwk"))))
6290    (build-system cargo-build-system)
6291    (arguments
6292      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
6293    (home-page
6294      "https://github.com/starkat99/half-rs")
6295    (synopsis
6296      "Half-precision floating point f16 type for Rust implementing the IEEE 754-2008 binary16 type.")
6297    (description
6298      "Half-precision floating point f16 type for Rust implementing the IEEE 754-2008 binary16 type.")
6299    (license #f)))
6300
6301(define-public rust-serde-cbor
6302  (package
6303    (name "rust-serde-cbor")
6304    (version "0.10.1")
6305    (source
6306      (origin
6307        (method url-fetch)
6308        (uri (crate-uri "serde_cbor" version))
6309        (file-name
6310          (string-append name "-" version ".tar.gz"))
6311        (sha256
6312          (base32
6313            "0jcb4j637vdlqk2z38jixaqmp6f92h36r17kclv5brjay32911ii"))))
6314    (build-system cargo-build-system)
6315    (arguments
6316      `(#:cargo-inputs
6317        (("rust-byteorder" ,rust-byteorder)
6318         ("rust-half" ,rust-half)
6319         ("rust-serde" ,rust-serde))
6320        #:cargo-development-inputs
6321        (("rust-serde-derive" ,rust-serde-derive))))
6322    (home-page "https://github.com/pyfisch/cbor")
6323    (synopsis "CBOR support for serde.")
6324    (description "CBOR support for serde.")
6325    (license #f)))
6326
6327(define-public rust-erased-serde
6328  (package
6329    (name "rust-erased-serde")
6330    (version "0.3.9")
6331    (source
6332      (origin
6333        (method url-fetch)
6334        (uri (crate-uri "erased-serde" version))
6335        (file-name
6336          (string-append name "-" version ".tar.gz"))
6337        (sha256
6338          (base32
6339            "0q7bnxs5zskfq5iillig55g7891dllcxh2p8y8k1p2j72syf9viv"))))
6340    (build-system cargo-build-system)
6341    (arguments
6342      `(#:cargo-inputs
6343        (("rust-serde" ,rust-serde))
6344        #:cargo-development-inputs
6345        (("rust-serde-cbor" ,rust-serde-cbor)
6346         ("rust-serde-derive" ,rust-serde-derive)
6347         ("rust-serde-json" ,rust-serde-json))))
6348    (home-page
6349      "https://github.com/dtolnay/erased-serde")
6350    (synopsis
6351      "Type-erased Serialize and Serializer traits")
6352    (description
6353      "Type-erased Serialize and Serializer traits")
6354    (license #f)))
6355
6356(define-public rust-slog
6357  (package
6358    (name "rust-slog")
6359    (version "2.5.2")
6360    (source
6361      (origin
6362        (method url-fetch)
6363        (uri (crate-uri "slog" version))
6364        (file-name
6365          (string-append name "-" version ".tar.gz"))
6366        (sha256
6367          (base32
6368            "16bv6zrdn1sm315vbnia02g31xvsmbjyz5gv3z0vrgxdli0cdj8w"))))
6369    (build-system cargo-build-system)
6370    (arguments
6371      `(#:cargo-inputs
6372        (("rust-erased-serde" ,rust-erased-serde))))
6373    (home-page "https://github.com/slog-rs/slog")
6374    (synopsis
6375      "Structured, extensible, composable logging for Rust")
6376    (description
6377      "Structured, extensible, composable logging for Rust")
6378    (license (list #f license:asl2.0))))
6379
6380(define-public rust-uuid
6381  (package
6382    (name "rust-uuid")
6383    (version "0.7.4")
6384    (source
6385      (origin
6386        (method url-fetch)
6387        (uri (crate-uri "uuid" version))
6388        (file-name
6389          (string-append name "-" version ".tar.gz"))
6390        (sha256
6391          (base32
6392            "0ank4xk20x3nrz926w8j9mz53bi3v8bykxmhlq2pffa8xc8wdnwh"))))
6393    (build-system cargo-build-system)
6394    (arguments
6395      `(#:cargo-inputs
6396        (("rust-byteorder" ,rust-byteorder)
6397         ("rust-md5" ,rust-md5)
6398         ("rust-rand" ,rust-rand)
6399         ("rust-serde" ,rust-serde)
6400         ("rust-sha1" ,rust-sha1)
6401         ("rust-slog" ,rust-slog)
6402         ("rust-winapi" ,rust-winapi))
6403        #:cargo-development-inputs
6404        (("rust-bincode" ,rust-bincode)
6405         ("rust-serde-derive" ,rust-serde-derive)
6406         ("rust-serde-json" ,rust-serde-json)
6407         ("rust-serde-test" ,rust-serde-test))))
6408    (home-page "https://github.com/uuid-rs/uuid")
6409    (synopsis
6410      "A library to generate and parse UUIDs.")
6411    (description
6412      "This package provides a library to generate and parse UUIDs.")
6413    (license (list license:asl2.0 license:expat))))
6414
6415(define-public rust-object
6416  (package
6417    (name "rust-object")
6418    (version "0.14.0")
6419    (source
6420      (origin
6421        (method url-fetch)
6422        (uri (crate-uri "object" version))
6423        (file-name
6424          (string-append name "-" version ".tar.gz"))
6425        (sha256
6426          (base32
6427            "1hnlfv7krq5shhav9vpls3f33r9pmkgkk9fq6fazx7p9fdbvrbw1"))))
6428    (build-system cargo-build-system)
6429    (arguments
6430      `(#:cargo-inputs
6431        (("rust-crc32fast" ,rust-crc32fast)
6432         ("rust-flate2" ,rust-flate2)
6433         ("rust-goblin" ,rust-goblin)
6434         ("rust-indexmap" ,rust-indexmap)
6435         ("rust-parity-wasm" ,rust-parity-wasm)
6436         ("rust-scroll" ,rust-scroll)
6437         ("rust-target-lexicon" ,rust-target-lexicon)
6438         ("rust-uuid" ,rust-uuid))
6439        #:cargo-development-inputs
6440        (("rust-memmap" ,rust-memmap))))
6441    (home-page "https://github.com/gimli-rs/object")
6442    (synopsis
6443      "A unified interface for parsing object file formats.")
6444    (description
6445      "This package provides a unified interface for parsing object file formats.")
6446    (license #f)))
6447
6448(define-public rust-addr2line
6449  (package
6450    (name "rust-addr2line")
6451    (version "0.10.0")
6452    (source
6453      (origin
6454        (method url-fetch)
6455        (uri (crate-uri "addr2line" version))
6456        (file-name
6457          (string-append name "-" version ".tar.gz"))
6458        (sha256
6459          (base32
6460            "1daaxrzk6fmfzaqi06y704hcw0rjz199l0n9214ybfm3m3jnmc4m"))))
6461    (build-system cargo-build-system)
6462    (arguments
6463      `(#:cargo-inputs
6464        (("rust-cpp-demangle" ,rust-cpp-demangle)
6465         ("rust-fallible-iterator"
6466          ,rust-fallible-iterator)
6467         ("rust-gimli" ,rust-gimli)
6468         ("rust-intervaltree" ,rust-intervaltree)
6469         ("rust-lazycell" ,rust-lazycell)
6470         ("rust-object" ,rust-object)
6471         ("rust-rustc-demangle" ,rust-rustc-demangle)
6472         ("rust-smallvec" ,rust-smallvec))
6473        #:cargo-development-inputs
6474        (("rust-backtrace" ,rust-backtrace)
6475         ("rust-clap" ,rust-clap)
6476         ("rust-findshlibs" ,rust-findshlibs)
6477         ("rust-memmap" ,rust-memmap)
6478         ("rust-rustc-test" ,rust-rustc-test))))
6479    (home-page
6480      "https://github.com/gimli-rs/addr2line")
6481    (synopsis
6482      "A cross-platform symbolication library written in Rust, using `gimli`")
6483    (description
6484      "This package provides a cross-platform symbolication library written in Rust, using `gimli`")
6485    (license #f)))
6486
6487(define-public rust-afl
6488  (package
6489    (name "rust-afl")
6490    (version "0.4.4")
6491    (source
6492      (origin
6493        (method url-fetch)
6494        (uri (crate-uri "afl" version))
6495        (file-name
6496          (string-append name "-" version ".tar.gz"))
6497        (sha256
6498          (base32
6499            "14k6hnwzqn7rrs0hs87vcfqj4334k9wff38d15378frlxpviaard"))))
6500    (build-system cargo-build-system)
6501    (arguments
6502      `(#:cargo-inputs
6503        (("rust-cc" ,rust-cc)
6504         ("rust-clap" ,rust-clap)
6505         ("rust-rustc-version" ,rust-rustc-version)
6506         ("rust-xdg" ,rust-xdg))
6507        #:cargo-development-inputs
6508        (("rust-rustc-version" ,rust-rustc-version)
6509         ("rust-xdg" ,rust-xdg))))
6510    (home-page "https://github.com/rust-fuzz/afl.rs")
6511    (synopsis
6512      "Fuzzing Rust code with american-fuzzy-lop")
6513    (description
6514      "Fuzzing Rust code with american-fuzzy-lop")
6515    (license license:asl2.0)))
6516
6517(define-public rust-speculate
6518  (package
6519    (name "rust-speculate")
6520    (version "0.1.2")
6521    (source
6522      (origin
6523        (method url-fetch)
6524        (uri (crate-uri "speculate" version))
6525        (file-name
6526          (string-append name "-" version ".tar.gz"))
6527        (sha256
6528          (base32
6529            "0ph01n3fqkmnfr1wd13dqsi4znv06xy6p4h3hqqdzk81r0r5vd1w"))))
6530    (build-system cargo-build-system)
6531    (arguments
6532      `(#:cargo-inputs
6533        (("rust-proc-macro2" ,rust-proc-macro2)
6534         ("rust-quote" ,rust-quote)
6535         ("rust-syn" ,rust-syn)
6536         ("rust-unicode-xid" ,rust-unicode-xid))))
6537    (home-page
6538      "https://github.com/utkarshkukreti/speculate.rs")
6539    (synopsis
6540      "An RSpec inspired minimal testing framework for Rust.")
6541    (description
6542      "An RSpec inspired minimal testing framework for Rust.")
6543    (license license:expat)))
6544
6545(define-public rust-diff
6546  (package
6547    (name "rust-diff")
6548    (version "0.1.11")
6549    (source
6550      (origin
6551        (method url-fetch)
6552        (uri (crate-uri "diff" version))
6553        (file-name
6554          (string-append name "-" version ".tar.gz"))
6555        (sha256
6556          (base32
6557            "0fhavni46a2rib93ig5fgbqmm48ysms5sxzb3h9bp7vp2bwnjarw"))))
6558    (build-system cargo-build-system)
6559    (arguments
6560      `(#:cargo-development-inputs
6561        (("rust-quickcheck" ,rust-quickcheck)
6562         ("rust-speculate" ,rust-speculate))))
6563    (home-page
6564      "https://github.com/utkarshkukreti/diff.rs")
6565    (synopsis
6566      "An LCS based slice and string diffing implementation.")
6567    (description
6568      "An LCS based slice and string diffing implementation.")
6569    (license (list license:expat license:asl2.0))))
6570
6571(define-public rust-cpp-demangle
6572  (package
6573    (name "rust-cpp-demangle")
6574    (version "0.2.13")
6575    (source
6576      (origin
6577        (method url-fetch)
6578        (uri (crate-uri "cpp_demangle" version))
6579        (file-name
6580          (string-append name "-" version ".tar.gz"))
6581        (sha256
6582          (base32
6583            "1d04jmvvzf9b0dqyfmrr75k5838d0ayqs7mr5lad83gvqr8m8d8x"))))
6584    (build-system cargo-build-system)
6585    (arguments
6586      `(#:cargo-inputs
6587        (("rust-afl" ,rust-afl)
6588         ("rust-cfg-if" ,rust-cfg-if))
6589        #:cargo-development-inputs
6590        (("rust-clap" ,rust-clap)
6591         ("rust-diff" ,rust-diff)
6592         ("rust-glob" ,rust-glob))))
6593    (home-page
6594      "https://github.com/gimli-rs/cpp_demangle")
6595    (synopsis "A crate for demangling C++ symbols")
6596    (description
6597      "This package provides a crate for demangling C++ symbols")
6598    (license #f)))
6599
6600(define-public rust-scroll-derive
6601  (package
6602    (name "rust-scroll-derive")
6603    (version "0.9.5")
6604    (source
6605      (origin
6606        (method url-fetch)
6607        (uri (crate-uri "scroll_derive" version))
6608        (file-name
6609          (string-append name "-" version ".tar.gz"))
6610        (sha256
6611          (base32
6612            "1jqg5mm8nvii6avl1z1rc89agzh2kwkppgpsnwfakxg78mnaj6lg"))))
6613    (build-system cargo-build-system)
6614    (arguments
6615      `(#:cargo-inputs
6616        (("rust-proc-macro2" ,rust-proc-macro2)
6617         ("rust-quote" ,rust-quote)
6618         ("rust-syn" ,rust-syn))
6619        #:cargo-development-inputs
6620        (("rust-scroll" ,rust-scroll))))
6621    (home-page
6622      "https://github.com/m4b/scroll_derive")
6623    (synopsis
6624      "A macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate")
6625    (description
6626      "This package provides a macros 1.1 derive implementation for Pread and Pwrite traits from the scroll crate")
6627    (license license:expat)))
6628
6629(define-public rust-scroll
6630  (package
6631    (name "rust-scroll")
6632    (version "0.9.2")
6633    (source
6634      (origin
6635        (method url-fetch)
6636        (uri (crate-uri "scroll" version))
6637        (file-name
6638          (string-append name "-" version ".tar.gz"))
6639        (sha256
6640          (base32
6641            "10q3w86bn22xrjlfg1c90dfi9c26qjkzn26nad0i9z8pxwad311g"))))
6642    (build-system cargo-build-system)
6643    (arguments
6644      `(#:cargo-inputs
6645        (("rust-scroll-derive" ,rust-scroll-derive))
6646        #:cargo-development-inputs
6647        (("rust-byteorder" ,rust-byteorder)
6648         ("rust-rayon" ,rust-rayon)
6649         ("rust-rustc-version" ,rust-rustc-version))))
6650    (home-page "https://github.com/m4b/scroll")
6651    (synopsis
6652      "A suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers")
6653    (description
6654      "This package provides a suite of powerful, extensible, generic, endian-aware Read/Write traits for byte buffers")
6655    (license license:expat)))
6656
6657(define-public rust-goblin
6658  (package
6659    (name "rust-goblin")
6660    (version "0.0.24")
6661    (source
6662      (origin
6663        (method url-fetch)
6664        (uri (crate-uri "goblin" version))
6665        (file-name
6666          (string-append name "-" version ".tar.gz"))
6667        (sha256
6668          (base32
6669            "1c31nrraiixy0mnda2227ih3h2g1k4pllg2kwk8yj6lwj4fjdyp3"))))
6670    (build-system cargo-build-system)
6671    (arguments
6672      `(#:cargo-inputs
6673        (("rust-log" ,rust-log)
6674         ("rust-plain" ,rust-plain)
6675         ("rust-scroll" ,rust-scroll))))
6676    (home-page "https://github.com/m4b/goblin")
6677    (synopsis
6678      "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
6679    (description
6680      "An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate")
6681    (license license:expat)))
6682
6683(define-public rust-backtrace
6684  (package
6685    (name "rust-backtrace")
6686    (version "0.3.38")
6687    (source
6688      (origin
6689        (method url-fetch)
6690        (uri (crate-uri "backtrace" version))
6691        (file-name
6692          (string-append name "-" version ".tar.gz"))
6693        (sha256
6694          (base32
6695            "1xgxaplllarhhqib3mcbv96743lvcil0kvq0xrrzgk10i6z642k9"))))
6696    (build-system cargo-build-system)
6697    (arguments
6698      `(#:cargo-inputs
6699        (("rust-addr2line" ,rust-addr2line)
6700         ("rust-backtrace-sys" ,rust-backtrace-sys)
6701         ("rust-cfg-if" ,rust-cfg-if)
6702         ("rust-compiler-builtins"
6703          ,rust-compiler-builtins)
6704         ("rust-cpp-demangle" ,rust-cpp-demangle)
6705         ("rust-findshlibs" ,rust-findshlibs)
6706         ("rust-goblin" ,rust-goblin)
6707         ("rust-libc" ,rust-libc)
6708         ("rust-memmap" ,rust-memmap)
6709         ("rust-rustc-demangle" ,rust-rustc-demangle)
6710         ("rust-rustc-serialize" ,rust-rustc-serialize)
6711         ("rust-rustc-std-workspace-core"
6712          ,rust-rustc-std-workspace-core)
6713         ("rust-serde" ,rust-serde)
6714         ("rust-winapi" ,rust-winapi))))
6715    (home-page
6716      "https://github.com/rust-lang/backtrace-rs")
6717    (synopsis
6718      "A library to acquire a stack trace (backtrace) at runtime in a Rust program.
6719")
6720    (description
6721      "This package provides a library to acquire a stack trace (backtrace) at runtime in a Rust program.
6722")
6723    (license #f)))
6724
6725(define-public rust-error-chain
6726  (package
6727    (name "rust-error-chain")
6728    (version "0.12.1")
6729    (source
6730      (origin
6731        (method url-fetch)
6732        (uri (crate-uri "error-chain" version))
6733        (file-name
6734          (string-append name "-" version ".tar.gz"))
6735        (sha256
6736          (base32
6737            "1ndpw1ny2kxqpw6k1shq8k56z4vfpk4xz9zr8ay988k0rffrxd1s"))))
6738    (build-system cargo-build-system)
6739    (arguments
6740      `(#:cargo-inputs
6741        (("rust-backtrace" ,rust-backtrace))
6742        #:cargo-development-inputs
6743        (("rust-version-check" ,rust-version-check))))
6744    (home-page
6745      "https://github.com/rust-lang-nursery/error-chain")
6746    (synopsis
6747      "Yet another error boilerplate library.")
6748    (description
6749      "Yet another error boilerplate library.")
6750    (license #f)))
6751
6752(define-public rust-flame
6753  (package
6754    (name "rust-flame")
6755    (version "0.2.2")
6756    (source
6757      (origin
6758        (method url-fetch)
6759        (uri (crate-uri "flame" version))
6760        (file-name
6761          (string-append name "-" version ".tar.gz"))
6762        (sha256
6763          (base32
6764            "0c5bmhyimzxch3pmh0w3z9n57saasgix4bmbbksr9vp1c5j71hhz"))))
6765    (build-system cargo-build-system)
6766    (arguments
6767      `(#:cargo-inputs
6768        (("rust-lazy-static" ,rust-lazy-static)
6769         ("rust-serde" ,rust-serde)
6770         ("rust-serde-derive" ,rust-serde-derive)
6771         ("rust-serde-json" ,rust-serde-json)
6772         ("rust-thread-id" ,rust-thread-id))))
6773    (home-page "https://github.com/TyOverby/flame")
6774    (synopsis "a profiling / flamegraph library")
6775    (description "a profiling / flamegraph library")
6776    (license #f)))
6777
6778(define-public rust-flamer
6779  (package
6780    (name "rust-flamer")
6781    (version "0.4.0")
6782    (source
6783      (origin
6784        (method url-fetch)
6785        (uri (crate-uri "flamer" version))
6786        (file-name
6787          (string-append name "-" version ".tar.gz"))
6788        (sha256
6789          (base32
6790            "1avszq3fn4ix7p6wjfdkli6fjyxccks1qhzja92a6kpxakd35drn"))))
6791    (build-system cargo-build-system)
6792    (arguments
6793      `(#:cargo-inputs
6794        (("rust-flame" ,rust-flame)
6795         ("rust-quote" ,rust-quote)
6796         ("rust-syn" ,rust-syn))))
6797    (home-page "https://github.com/llogiq/flamer")
6798    (synopsis
6799      "a procedural macro to insert `flame::start_guard(_)` calls")
6800    (description
6801      "a procedural macro to insert `flame::start_guard(_)` calls")
6802    (license license:asl2.0)))
6803
6804(define-public rust-unicode-bidi
6805  (package
6806    (name "rust-unicode-bidi")
6807    (version "0.3.4")
6808    (source
6809      (origin
6810        (method url-fetch)
6811        (uri (crate-uri "unicode-bidi" version))
6812        (file-name
6813          (string-append name "-" version ".tar.gz"))
6814        (sha256
6815          (base32
6816            "1malx8ljgm7v1gbaazkn7iicy5wj0bwcyadj3l727a38ch6bvwj9"))))
6817    (build-system cargo-build-system)
6818    (arguments
6819      `(#:cargo-inputs
6820        (("rust-flame" ,rust-flame)
6821         ("rust-flamer" ,rust-flamer)
6822         ("rust-matches" ,rust-matches)
6823         ("rust-serde" ,rust-serde))
6824        #:cargo-development-inputs
6825        (("rust-serde-test" ,rust-serde-test))))
6826    (home-page
6827      "https://github.com/servo/unicode-bidi")
6828    (synopsis
6829      "Implementation of the Unicode Bidirectional Algorithm")
6830    (description
6831      "Implementation of the Unicode Bidirectional Algorithm")
6832    (license #f)))
6833
6834(define-public rust-smallvec
6835  (package
6836    (name "rust-smallvec")
6837    (version "0.6.10")
6838    (source
6839      (origin
6840        (method url-fetch)
6841        (uri (crate-uri "smallvec" version))
6842        (file-name
6843          (string-append name "-" version ".tar.gz"))
6844        (sha256
6845          (base32
6846            "1dyl43rgzny79jjpgzi07y0ly2ggx1xwsn64csxj0j91bsf6lq5b"))))
6847    (build-system cargo-build-system)
6848    (arguments
6849      `(#:cargo-inputs
6850        (("rust-serde" ,rust-serde))
6851        #:cargo-development-inputs
6852        (("rust-bincode" ,rust-bincode))))
6853    (home-page
6854      "https://github.com/servo/rust-smallvec")
6855    (synopsis
6856      "'Small vector' optimization: store up to a small number of items on the stack")
6857    (description
6858      "'Small vector' optimization: store up to a small number of items on the stack")
6859    (license #f)))
6860
6861(define-public rust-unicode-normalization
6862  (package
6863    (name "rust-unicode-normalization")
6864    (version "0.1.8")
6865    (source
6866      (origin
6867        (method url-fetch)
6868        (uri (crate-uri "unicode-normalization" version))
6869        (file-name
6870          (string-append name "-" version ".tar.gz"))
6871        (sha256
6872          (base32
6873            "09i49va90rvia1agvgni4gicnqv50y5zy1naw8mr8bcqifh3j4ql"))))
6874    (build-system cargo-build-system)
6875    (arguments
6876      `(#:cargo-inputs
6877        (("rust-smallvec" ,rust-smallvec))))
6878    (home-page
6879      "https://github.com/unicode-rs/unicode-normalization")
6880    (synopsis
6881      "This crate provides functions for normalization of
6882Unicode strings, including Canonical and Compatible
6883Decomposition and Recomposition, as described in
6884Unicode Standard Annex #15.
6885")
6886    (description
6887      "This crate provides functions for normalization of
6888Unicode strings, including Canonical and Compatible
6889Decomposition and Recomposition, as described in
6890Unicode Standard Annex #15.
6891")
6892    (license #f)))
6893
6894(define-public rust-idna
6895  (package
6896    (name "rust-idna")
6897    (version "0.2.0")
6898    (source
6899      (origin
6900        (method url-fetch)
6901        (uri (crate-uri "idna" version))
6902        (file-name
6903          (string-append name "-" version ".tar.gz"))
6904        (sha256
6905          (base32
6906            "1a9066imqpdrm1aavfasdyb1zahqaz8jmdcwdawvb1pf60y6gqh2"))))
6907    (build-system cargo-build-system)
6908    (arguments
6909      `(#:cargo-inputs
6910        (("rust-matches" ,rust-matches)
6911         ("rust-unicode-bidi" ,rust-unicode-bidi)
6912         ("rust-unicode-normalization"
6913          ,rust-unicode-normalization))
6914        #:cargo-development-inputs
6915        (("rust-rustc-test" ,rust-rustc-test)
6916         ("rust-serde-json" ,rust-serde-json))))
6917    (home-page "https://github.com/servo/rust-url/")
6918    (synopsis
6919      "IDNA (Internationalizing Domain Names in Applications) and Punycode.")
6920    (description
6921      "IDNA (Internationalizing Domain Names in Applications) and Punycode.")
6922    (license #f)))
6923
6924(define-public rust-rustc-test
6925  (package
6926    (name "rust-rustc-test")
6927    (version "0.3.0")
6928    (source
6929      (origin
6930        (method url-fetch)
6931        (uri (crate-uri "rustc-test" version))
6932        (file-name
6933          (string-append name "-" version ".tar.gz"))
6934        (sha256
6935          (base32
6936            "0a27mlcg0ck0hgsdvwk792x9z1k1qq1wj091f1l5yggbdbcsnx5w"))))
6937    (build-system cargo-build-system)
6938    (arguments
6939      `(#:cargo-inputs
6940        (("rust-getopts" ,rust-getopts)
6941         ("rust-libc" ,rust-libc)
6942         ("rust-rustc-serialize" ,rust-rustc-serialize)
6943         ("rust-term" ,rust-term)
6944         ("rust-time" ,rust-time))
6945        #:cargo-development-inputs
6946        (("rust-rustc-version" ,rust-rustc-version))))
6947    (home-page
6948      "https://github.com/SimonSapin/rustc-test")
6949    (synopsis
6950      "A fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
6951    (description
6952      "This package provides a fork of Rustâ\x80\x99s `test` crate that doesnâ\x80\x99t require unstable language features.")
6953    (license (list license:expat license:asl2.0))))
6954
6955(define-public rust-url
6956  (package
6957    (name "rust-url")
6958    (version "2.1.0")
6959    (source
6960      (origin
6961        (method url-fetch)
6962        (uri (crate-uri "url" version))
6963        (file-name
6964          (string-append name "-" version ".tar.gz"))
6965        (sha256
6966          (base32
6967            "0qcxx9kr0wfawsr83h0kfgxl6dxw4cgrbgxsz7bpkj34qkv19d3m"))))
6968    (build-system cargo-build-system)
6969    (arguments
6970      `(#:cargo-inputs
6971        (("rust-idna" ,rust-idna)
6972         ("rust-matches" ,rust-matches)
6973         ("rust-percent-encoding" ,rust-percent-encoding)
6974         ("rust-serde" ,rust-serde))
6975        #:cargo-development-inputs
6976        (("rust-bencher" ,rust-bencher)
6977         ("rust-rustc-test" ,rust-rustc-test)
6978         ("rust-serde-json" ,rust-serde-json))))
6979    (home-page "https://github.com/servo/rust-url")
6980    (synopsis
6981      "URL library for Rust, based on the WHATWG URL Standard")
6982    (description
6983      "URL library for Rust, based on the WHATWG URL Standard")
6984    (license #f)))
6985
6986(define-public rust-git2
6987  (package
6988    (name "rust-git2")
6989    (version "0.10.1")
6990    (source
6991      (origin
6992        (method url-fetch)
6993        (uri (crate-uri "git2" version))
6994        (file-name
6995          (string-append name "-" version ".tar.gz"))
6996        (sha256
6997          (base32
6998            "10jazcfnni2j1dxv1faizk1x7bn55clr0sd5x7n6gv5mzf373wir"))))
6999    (build-system cargo-build-system)
7000    (arguments
7001      `(#:cargo-inputs
7002        (("rust-bitflags" ,rust-bitflags)
7003         ("rust-libc" ,rust-libc)
7004         ("rust-libgit2-sys" ,rust-libgit2-sys)
7005         ("rust-log" ,rust-log)
7006         ("rust-openssl-probe" ,rust-openssl-probe)
7007         ("rust-openssl-sys" ,rust-openssl-sys)
7008         ("rust-url" ,rust-url))
7009        #:cargo-development-inputs
7010        (("rust-docopt" ,rust-docopt)
7011         ("rust-serde" ,rust-serde)
7012         ("rust-serde-derive" ,rust-serde-derive)
7013         ("rust-tempfile" ,rust-tempfile)
7014         ("rust-thread-id" ,rust-thread-id)
7015         ("rust-time" ,rust-time))))
7016    (home-page
7017      "https://github.com/rust-lang/git2-rs")
7018    (synopsis
7019      "Bindings to libgit2 for interoperating with git repositories. This library is
7020both threadsafe and memory safe and allows both reading and writing git
7021repositories.
7022")
7023    (description
7024      "Bindings to libgit2 for interoperating with git repositories.  This library is
7025both threadsafe and memory safe and allows both reading and writing git
7026repositories.
7027")
7028    (license #f)))
7029
7030(define-public rust-home
7031  (package
7032    (name "rust-home")
7033    (version "0.5.0")
7034    (source
7035      (origin
7036        (method url-fetch)
7037        (uri (crate-uri "home" version))
7038        (file-name
7039          (string-append name "-" version ".tar.gz"))
7040        (sha256
7041          (base32
7042            "1cwmx2h3ibfa6zfxrc8d94p7h1i7xypds83a08zzimkb21g32z60"))))
7043    (build-system cargo-build-system)
7044    (arguments
7045      `(#:cargo-inputs
7046        (("rust-scopeguard" ,rust-scopeguard)
7047         ("rust-winapi" ,rust-winapi))))
7048    (home-page "https://github.com/brson/home")
7049    (synopsis
7050      "Shared definitions of home directories")
7051    (description
7052      "Shared definitions of home directories")
7053    (license #f)))
7054
7055(define-public rust-crates-index
7056  (package
7057    (name "rust-crates-index")
7058    (version "0.13.3")
7059    (source
7060      (origin
7061        (method url-fetch)
7062        (uri (crate-uri "crates-index" version))
7063        (file-name
7064          (string-append name "-" version ".tar.gz"))
7065        (sha256
7066          (base32
7067            "0hvqxzj144yvrjymrvbmv8r4kqz587dkkg52cdvrxjinwpg1kds7"))))
7068    (build-system cargo-build-system)
7069    (arguments
7070      `(#:cargo-inputs
7071        (("rust-error-chain" ,rust-error-chain)
7072         ("rust-git2" ,rust-git2)
7073         ("rust-glob" ,rust-glob)
7074         ("rust-home" ,rust-home)
7075         ("rust-serde" ,rust-serde)
7076         ("rust-serde-derive" ,rust-serde-derive)
7077         ("rust-serde-json" ,rust-serde-json))
7078        #:cargo-development-inputs
7079        (("rust-tempdir" ,rust-tempdir))))
7080    (home-page
7081      "https://github.com/frewsxcv/rust-crates-index")
7082    (synopsis
7083      "Library for retrieving and interacting with the crates.io index")
7084    (description
7085      "Library for retrieving and interacting with the crates.io index")
7086    (license license:asl2.0)))
7087
7088(define-public rust-semver
7089  (package
7090    (name "rust-semver")
7091    (version "0.9.0")
7092    (source
7093      (origin
7094        (method url-fetch)
7095        (uri (crate-uri "semver" version))
7096        (file-name
7097          (string-append name "-" version ".tar.gz"))
7098        (sha256
7099          (base32
7100            "00q4lkcj0rrgbhviv9sd4p6qmdsipkwkbra7rh11jrhq5kpvjzhx"))))
7101    (build-system cargo-build-system)
7102    (arguments
7103      `(#:cargo-inputs
7104        (("rust-semver-parser" ,rust-semver-parser)
7105         ("rust-serde" ,rust-serde))
7106        #:cargo-development-inputs
7107        (("rust-crates-index" ,rust-crates-index)
7108         ("rust-serde-derive" ,rust-serde-derive)
7109         ("rust-serde-json" ,rust-serde-json)
7110         ("rust-tempdir" ,rust-tempdir))))
7111    (home-page "https://docs.rs/crate/semver/")
7112    (synopsis
7113      "Semantic version parsing and comparison.
7114")
7115    (description
7116      "Semantic version parsing and comparison.
7117")
7118    (license #f)))
7119
7120(define-public rust-rustc-version
7121  (package
7122    (name "rust-rustc-version")
7123    (version "0.2.3")
7124    (source
7125      (origin
7126        (method url-fetch)
7127        (uri (crate-uri "rustc_version" version))
7128        (file-name
7129          (string-append name "-" version ".tar.gz"))
7130        (sha256
7131          (base32
7132            "02h3x57lcr8l2pm0a645s9whdh33pn5cnrwvn5cb57vcrc53x3hk"))))
7133    (build-system cargo-build-system)
7134    (arguments
7135      `(#:cargo-inputs (("rust-semver" ,rust-semver))))
7136    (home-page
7137      "https://github.com/Kimundi/rustc-version-rs")
7138    (synopsis
7139      "A library for querying the version of a installed rustc compiler")
7140    (description
7141      "This package provides a library for querying the version of a installed rustc compiler")
7142    (license #f)))
7143
7144(define-public rust-memoffset
7145  (package
7146    (name "rust-memoffset")
7147    (version "0.5.1")
7148    (source
7149      (origin
7150        (method url-fetch)
7151        (uri (crate-uri "memoffset" version))
7152        (file-name
7153          (string-append name "-" version ".tar.gz"))
7154        (sha256
7155          (base32
7156            "0zqpz1apkxvzbi41q07vaxpn3bmvhqqkmg8bbbpbgfrv0gdpaq6f"))))
7157    (build-system cargo-build-system)
7158    (arguments
7159      `(#:cargo-development-inputs
7160        (("rust-rustc-version" ,rust-rustc-version))))
7161    (home-page "https://github.com/Gilnaa/memoffset")
7162    (synopsis
7163      "offset_of functionality for Rust structs.")
7164    (description
7165      "offset_of functionality for Rust structs.")
7166    (license license:expat)))
7167
7168(define-public rust-crossbeam-epoch
7169  (package
7170    (name "rust-crossbeam-epoch")
7171    (version "0.7.2")
7172    (source
7173      (origin
7174        (method url-fetch)
7175        (uri (crate-uri "crossbeam-epoch" version))
7176        (file-name
7177          (string-append name "-" version ".tar.gz"))
7178        (sha256
7179          (base32
7180            "1a9prma2nalqvys7f8wrazkdzh26w3mi5gzrk8mdmwrp5rvxdp7y"))))
7181    (build-system cargo-build-system)
7182    (arguments
7183      `(#:cargo-inputs
7184        (("rust-arrayvec" ,rust-arrayvec)
7185         ("rust-cfg-if" ,rust-cfg-if)
7186         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
7187         ("rust-lazy-static" ,rust-lazy-static)
7188         ("rust-memoffset" ,rust-memoffset)
7189         ("rust-scopeguard" ,rust-scopeguard))
7190        #:cargo-development-inputs
7191        (("rust-rand" ,rust-rand))))
7192    (home-page
7193      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-epoch")
7194    (synopsis "Epoch-based garbage collection")
7195    (description "Epoch-based garbage collection")
7196    (license #f)))
7197
7198(define-public rust-crossbeam-deque
7199  (package
7200    (name "rust-crossbeam-deque")
7201    (version "0.7.1")
7202    (source
7203      (origin
7204        (method url-fetch)
7205        (uri (crate-uri "crossbeam-deque" version))
7206        (file-name
7207          (string-append name "-" version ".tar.gz"))
7208        (sha256
7209          (base32
7210            "0was9x71cz5g1y3670cyy6jdmsdfg6k9mbf0ddz2k1mdd7hx535i"))))
7211    (build-system cargo-build-system)
7212    (arguments
7213      `(#:cargo-inputs
7214        (("rust-crossbeam-epoch" ,rust-crossbeam-epoch)
7215         ("rust-crossbeam-utils" ,rust-crossbeam-utils))
7216        #:cargo-development-inputs
7217        (("rust-rand" ,rust-rand))))
7218    (home-page
7219      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-deque")
7220    (synopsis "Concurrent work-stealing deque")
7221    (description "Concurrent work-stealing deque")
7222    (license #f)))
7223
7224(define-public rust-either
7225  (package
7226    (name "rust-either")
7227    (version "1.5.3")
7228    (source
7229      (origin
7230        (method url-fetch)
7231        (uri (crate-uri "either" version))
7232        (file-name
7233          (string-append name "-" version ".tar.gz"))
7234        (sha256
7235          (base32
7236            "1qyz1b1acad6w0k5928jw5zaq900zhsk7p8dlcp4hh61w4f6n7xv"))))
7237    (build-system cargo-build-system)
7238    (arguments
7239      `(#:cargo-inputs (("rust-serde" ,rust-serde))))
7240    (home-page "https://github.com/bluss/either")
7241    (synopsis
7242      "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.
7243")
7244    (description
7245      "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases.
7246")
7247    (license #f)))
7248
7249(define-public rust-crossbeam-queue
7250  (package
7251    (name "rust-crossbeam-queue")
7252    (version "0.1.2")
7253    (source
7254      (origin
7255        (method url-fetch)
7256        (uri (crate-uri "crossbeam-queue" version))
7257        (file-name
7258          (string-append name "-" version ".tar.gz"))
7259        (sha256
7260          (base32
7261            "0jsa9dbxnwqcxfws09vaschf92d4imlbbikmcn4ka8z7rzb9r5vw"))))
7262    (build-system cargo-build-system)
7263    (arguments
7264      `(#:cargo-inputs
7265        (("rust-crossbeam-utils" ,rust-crossbeam-utils))
7266        #:cargo-development-inputs
7267        (("rust-rand" ,rust-rand))))
7268    (home-page
7269      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils")
7270    (synopsis "Concurrent queues")
7271    (description "Concurrent queues")
7272    (license #f)))
7273
7274(define-public rust-crossbeam-utils
7275  (package
7276    (name "rust-crossbeam-utils")
7277    (version "0.6.6")
7278    (source
7279      (origin
7280        (method url-fetch)
7281        (uri (crate-uri "crossbeam-utils" version))
7282        (file-name
7283          (string-append name "-" version ".tar.gz"))
7284        (sha256
7285          (base32
7286            "1rk0r9n04bmq4a3g2q5qhvvlmrmx780gc6h9lmc94mwndslkz5q4"))))
7287    (build-system cargo-build-system)
7288    (arguments
7289      `(#:cargo-inputs
7290        (("rust-cfg-if" ,rust-cfg-if)
7291         ("rust-lazy-static" ,rust-lazy-static))
7292        #:cargo-development-inputs
7293        (("rust-rand" ,rust-rand))))
7294    (home-page
7295      "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils")
7296    (synopsis "Utilities for concurrent programming")
7297    (description
7298      "Utilities for concurrent programming")
7299    (license #f)))
7300
7301(define-public rust-rayon-core
7302  (package
7303    (name "rust-rayon-core")
7304    (version "1.6.0")
7305    (source
7306      (origin
7307        (method url-fetch)
7308        (uri (crate-uri "rayon-core" version))
7309        (file-name
7310          (string-append name "-" version ".tar.gz"))
7311        (sha256
7312          (base32
7313            "0yzc8x7ra1yy40nqlixpi9lzpjraxcqj89b111yv30sh40sgdp4q"))))
7314    (build-system cargo-build-system)
7315    (arguments
7316      `(#:cargo-inputs
7317        (("rust-crossbeam-deque" ,rust-crossbeam-deque)
7318         ("rust-crossbeam-queue" ,rust-crossbeam-queue)
7319         ("rust-crossbeam-utils" ,rust-crossbeam-utils)
7320         ("rust-lazy-static" ,rust-lazy-static)
7321         ("rust-num-cpus" ,rust-num-cpus))
7322        #:cargo-development-inputs
7323        (("rust-libc" ,rust-libc)
7324         ("rust-rand" ,rust-rand)
7325         ("rust-rand-xorshift" ,rust-rand-xorshift)
7326         ("rust-scoped-tls" ,rust-scoped-tls))))
7327    (home-page "https://github.com/rayon-rs/rayon")
7328    (synopsis "Core APIs for Rayon")
7329    (description "Core APIs for Rayon")
7330    (license #f)))
7331
7332(define-public rust-docopt
7333  (package
7334    (name "rust-docopt")
7335    (version "1.1.0")
7336    (source
7337      (origin
7338        (method url-fetch)
7339        (uri (crate-uri "docopt" version))
7340        (file-name
7341          (string-append name "-" version ".tar.gz"))
7342        (sha256
7343          (base32
7344            "0s9rcpmnnivs502q69lc1h1wrwapkq09ikgbfbgqf31idmc5llkz"))))
7345    (build-system cargo-build-system)
7346    (arguments
7347      `(#:cargo-inputs
7348        (("rust-lazy-static" ,rust-lazy-static)
7349         ("rust-regex" ,rust-regex)
7350         ("rust-serde" ,rust-serde)
7351         ("rust-strsim" ,rust-strsim))))
7352    (home-page "https://github.com/docopt/docopt.rs")
7353    (synopsis "Command line argument parsing.")
7354    (description "Command line argument parsing.")
7355    (license #f)))
7356
7357(define-public rust-byteorder
7358  (package
7359    (name "rust-byteorder")
7360    (version "1.3.2")
7361    (source
7362      (origin
7363        (method url-fetch)
7364        (uri (crate-uri "byteorder" version))
7365        (file-name
7366          (string-append name "-" version ".tar.gz"))
7367        (sha256
7368          (base32
7369            "1xbwjlmq2ziqjmjvkqxdx1yh136xxhilxd40bky1w4d7hn4xvhx7"))))
7370    (build-system cargo-build-system)
7371    (arguments
7372      `(#:cargo-development-inputs
7373        (("rust-doc-comment" ,rust-doc-comment)
7374         ("rust-quickcheck" ,rust-quickcheck)
7375         ("rust-rand" ,rust-rand))))
7376    (home-page
7377      "https://github.com/BurntSushi/byteorder")
7378    (synopsis
7379      "Library for reading/writing numbers in big-endian and little-endian.")
7380    (description
7381      "Library for reading/writing numbers in big-endian and little-endian.")
7382    (license (list license:unlicense license:expat))))
7383
7384(define-public rust-serde-test
7385  (package
7386    (name "rust-serde-test")
7387    (version "1.0.101")
7388    (source
7389      (origin
7390        (method url-fetch)
7391        (uri (crate-uri "serde_test" version))
7392        (file-name
7393          (string-append name "-" version ".tar.gz"))
7394        (sha256
7395          (base32
7396            "0070ycbh47yhxb5vxwa15vi2wpdkw3v1m14v4mjryz1568fqkbsa"))))
7397    (build-system cargo-build-system)
7398    (arguments
7399      `(#:cargo-inputs
7400        (("rust-serde" ,rust-serde))
7401        #:cargo-development-inputs
7402        (("rust-serde" ,rust-serde)
7403         ("rust-serde-derive" ,rust-serde-derive))))
7404    (home-page "https://serde.rs")
7405    (synopsis
7406      "Token De/Serializer for testing De/Serialize implementations")
7407    (description
7408      "Token De/Serializer for testing De/Serialize implementations")
7409    (license (list license:expat license:asl2.0))))
7410
7411(define-public rust-serde-bytes
7412  (package
7413    (name "rust-serde-bytes")
7414    (version "0.11.2")
7415    (source
7416      (origin
7417        (method url-fetch)
7418        (uri (crate-uri "serde_bytes" version))
7419        (file-name
7420          (string-append name "-" version ".tar.gz"))
7421        (sha256
7422          (base32
7423            "1z7gwq92wrav9ln68gnmqmvaa99qv9kynd8257maxav4zy103bs5"))))
7424    (build-system cargo-build-system)
7425    (arguments
7426      `(#:cargo-inputs
7427        (("rust-serde" ,rust-serde))
7428        #:cargo-development-inputs
7429        (("rust-bincode" ,rust-bincode)
7430         ("rust-serde-derive" ,rust-serde-derive)
7431         ("rust-serde-test" ,rust-serde-test))))
7432    (home-page "https://github.com/serde-rs/bytes")
7433    (synopsis
7434      "Optimized handling of `&[u8]` and `Vec<u8>` for Serde")
7435    (description
7436      "Optimized handling of `&[u8]` and `Vec<u8>` for Serde")
7437    (license (list license:expat license:asl2.0))))
7438
7439(define-public rust-bincode
7440  (package
7441    (name "rust-bincode")
7442    (version "1.2.0")
7443    (source
7444      (origin
7445        (method url-fetch)
7446        (uri (crate-uri "bincode" version))
7447        (file-name
7448          (string-append name "-" version ".tar.gz"))
7449        (sha256
7450          (base32
7451            "14jzj61c145s9jwr1i213b7mdcmv1ny4z1lns9s8gvp34j9n7axq"))))
7452    (build-system cargo-build-system)
7453    (arguments
7454      `(#:cargo-inputs
7455        (("rust-byteorder" ,rust-byteorder)
7456         ("rust-serde" ,rust-serde))
7457        #:cargo-development-inputs
7458        (("rust-autocfg" ,rust-autocfg)
7459         ("rust-serde-bytes" ,rust-serde-bytes)
7460         ("rust-serde-derive" ,rust-serde-derive))))
7461    (home-page "https://github.com/servo/bincode")
7462    (synopsis
7463      "A binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!")
7464    (description
7465      "This package provides a binary serialization / deserialization strategy that uses Serde for transforming structs into bytes and vice versa!")
7466    (license license:expat)))
7467
7468(define-public rust-rand-xorshift
7469  (package
7470    (name "rust-rand-xorshift")
7471    (version "0.2.0")
7472    (source
7473      (origin
7474        (method url-fetch)
7475        (uri (crate-uri "rand_xorshift" version))
7476        (file-name
7477          (string-append name "-" version ".tar.gz"))
7478        (sha256
7479          (base32
7480            "1a6wy76lc5fimm1n9n8fzhp4cfjwfwxh4hx63bg3vlh1d2w1dm3p"))))
7481    (build-system cargo-build-system)
7482    (arguments
7483      `(#:cargo-inputs
7484        (("rust-rand-core" ,rust-rand-core)
7485         ("rust-serde" ,rust-serde))
7486        #:cargo-development-inputs
7487        (("rust-bincode" ,rust-bincode))))
7488    (home-page
7489      "https://crates.io/crates/rand_xorshift")
7490    (synopsis "Xorshift random number generator
7491")
7492    (description
7493      "Xorshift random number generator
7494")
7495    (license #f)))
7496
7497(define-public rust-rayon
7498  (package
7499    (name "rust-rayon")
7500    (version "1.2.0")
7501    (source
7502      (origin
7503        (method url-fetch)
7504        (uri (crate-uri "rayon" version))
7505        (file-name
7506          (string-append name "-" version ".tar.gz"))
7507        (sha256
7508          (base32
7509            "08x117r5f3129h04f0vg5wqsv2fvfvz1389m005bx89kllr7g8l3"))))
7510    (build-system cargo-build-system)
7511    (arguments
7512      `(#:cargo-inputs
7513        (("rust-crossbeam-deque" ,rust-crossbeam-deque)
7514         ("rust-either" ,rust-either)
7515         ("rust-rayon-core" ,rust-rayon-core))
7516        #:cargo-development-inputs
7517        (("rust-doc-comment" ,rust-doc-comment)
7518         ("rust-docopt" ,rust-docopt)
7519         ("rust-lazy-static" ,rust-lazy-static)
7520         ("rust-rand" ,rust-rand)
7521         ("rust-rand-xorshift" ,rust-rand-xorshift)
7522         ("rust-serde" ,rust-serde)
7523         ("rust-serde-derive" ,rust-serde-derive))))
7524    (home-page "https://github.com/rayon-rs/rayon")
7525    (synopsis
7526      "Simple work-stealing parallelism for Rust")
7527    (description
7528      "Simple work-stealing parallelism for Rust")
7529    (license #f)))
7530
7531(define-public rust-tinytemplate
7532  (package
7533    (name "rust-tinytemplate")
7534    (version "1.0.2")
7535    (source
7536      (origin
7537        (method url-fetch)
7538        (uri (crate-uri "tinytemplate" version))
7539        (file-name
7540          (string-append name "-" version ".tar.gz"))
7541        (sha256
7542          (base32
7543            "084w41m75i95sdid1wwlnav80jsl1ggyryl4nawxvb6amigvfx25"))))
7544    (build-system cargo-build-system)
7545    (arguments
7546      `(#:cargo-inputs
7547        (("rust-serde" ,rust-serde)
7548         ("rust-serde-json" ,rust-serde-json))
7549        #:cargo-development-inputs
7550        (("rust-criterion" ,rust-criterion)
7551         ("rust-serde-derive" ,rust-serde-derive))))
7552    (home-page
7553      "https://github.com/bheisler/TinyTemplate")
7554    (synopsis "Simple, lightweight template engine")
7555    (description
7556      "Simple, lightweight template engine")
7557    (license (list license:asl2.0 license:expat))))
7558
7559(define-public rust-num-complex
7560  (package
7561    (name "rust-num-complex")
7562    (version "0.2.3")
7563    (source
7564      (origin
7565        (method url-fetch)
7566        (uri (crate-uri "num-complex" version))
7567        (file-name
7568          (string-append name "-" version ".tar.gz"))
7569        (sha256
7570          (base32
7571            "1z6zjdzx1g1hj4y132ddy83d3p3zvw06igbf59npxxrzzcqwzc7w"))))
7572    (build-system cargo-build-system)
7573    (arguments
7574      `(#:cargo-inputs
7575        (("rust-num-traits" ,rust-num-traits)
7576         ("rust-rand" ,rust-rand)
7577         ("rust-serde" ,rust-serde))
7578        #:cargo-development-inputs
7579        (("rust-autocfg" ,rust-autocfg))))
7580    (home-page
7581      "https://github.com/rust-num/num-complex")
7582    (synopsis
7583      "Complex numbers implementation for Rust")
7584    (description
7585      "Complex numbers implementation for Rust")
7586    (license #f)))
7587
7588(define-public rust-approx
7589  (package
7590    (name "rust-approx")
7591    (version "0.3.2")
7592    (source
7593      (origin
7594        (method url-fetch)
7595        (uri (crate-uri "approx" version))
7596        (file-name
7597          (string-append name "-" version ".tar.gz"))
7598        (sha256
7599          (base32
7600            "1hx580xjdxl3766js9b49rnbnmr8gw8c060809l43k9f0xshprph"))))
7601    (build-system cargo-build-system)
7602    (arguments
7603      `(#:cargo-inputs
7604        (("rust-num-complex" ,rust-num-complex)
7605         ("rust-num-traits" ,rust-num-traits))))
7606    (home-page
7607      "https://github.com/brendanzab/approx")
7608    (synopsis
7609      "Approximate floating point equality comparisons and assertions.")
7610    (description
7611      "Approximate floating point equality comparisons and assertions.")
7612    (license license:asl2.0)))
7613
7614(define-public rust-criterion
7615  (package
7616    (name "rust-criterion")
7617    (version "0.3.0")
7618    (source
7619      (origin
7620        (method url-fetch)
7621        (uri (crate-uri "criterion" version))
7622        (file-name
7623          (string-append name "-" version ".tar.gz"))
7624        (sha256
7625          (base32
7626            "1iig7r9c6bkn5qb6axxkblc1amif6k49lix35rhqs728cphh71wk"))))
7627    (build-system cargo-build-system)
7628    (arguments
7629      `(#:cargo-inputs
7630        (("rust-atty" ,rust-atty)
7631         ("rust-cast" ,rust-cast)
7632         ("rust-clap" ,rust-clap)
7633         ("rust-criterion-plot" ,rust-criterion-plot)
7634         ("rust-csv" ,rust-csv)
7635         ("rust-itertools" ,rust-itertools)
7636         ("rust-lazy-static" ,rust-lazy-static)
7637         ("rust-num-traits" ,rust-num-traits)
7638         ("rust-rand-core" ,rust-rand-core)
7639         ("rust-rand-os" ,rust-rand-os)
7640         ("rust-rand-xoshiro" ,rust-rand-xoshiro)
7641         ("rust-rayon" ,rust-rayon)
7642         ("rust-serde" ,rust-serde)
7643         ("rust-serde-derive" ,rust-serde-derive)
7644         ("rust-serde-json" ,rust-serde-json)
7645         ("rust-tinytemplate" ,rust-tinytemplate)
7646         ("rust-walkdir" ,rust-walkdir))
7647        #:cargo-development-inputs
7648        (("rust-approx" ,rust-approx)
7649         ("rust-quickcheck" ,rust-quickcheck)
7650         ("rust-rand" ,rust-rand)
7651         ("rust-tempdir" ,rust-tempdir))))
7652    (home-page
7653      "https://bheisler.github.io/criterion.rs/book/index.html")
7654    (synopsis
7655      "Statistics-driven micro-benchmarking library")
7656    (description
7657      "Statistics-driven micro-benchmarking library")
7658    (license #f)))
7659
7660(define-public rust-nom
7661  (package
7662    (name "rust-nom")
7663    (version "5.0.1")
7664    (source
7665      (origin
7666        (method url-fetch)
7667        (uri (crate-uri "nom" version))
7668        (file-name
7669          (string-append name "-" version ".tar.gz"))
7670        (sha256
7671          (base32
7672            "1jimv9sh1l5dh6dzbxaixw3a26gq766ndrl470l02i6s48sbc666"))))
7673    (build-system cargo-build-system)
7674    (arguments
7675      `(#:cargo-inputs
7676        (("rust-lazy-static" ,rust-lazy-static)
7677         ("rust-lexical-core" ,rust-lexical-core)
7678         ("rust-memchr" ,rust-memchr)
7679         ("rust-regex" ,rust-regex))
7680        #:cargo-development-inputs
7681        (("rust-criterion" ,rust-criterion)
7682         ("rust-doc-comment" ,rust-doc-comment)
7683         ("rust-jemallocator" ,rust-jemallocator)
7684         ("rust-version-check" ,rust-version-check))))
7685    (home-page "https://github.com/Geal/nom")
7686    (synopsis
7687      "A byte-oriented, zero-copy, parser combinators library")
7688    (description
7689      "This package provides a byte-oriented, zero-copy, parser combinators library")
7690    (license license:expat)))
7691
7692(define-public rust-weedle
7693  (package
7694    (name "rust-weedle")
7695    (version "0.10.0")
7696    (source
7697      (origin
7698        (method url-fetch)
7699        (uri (crate-uri "weedle" version))
7700        (file-name
7701          (string-append name "-" version ".tar.gz"))
7702        (sha256
7703          (base32
7704            "0r0i2kllvkn9jil6cjzxdi1zsc6p1gjyk751w8lyclaii1q3zd1v"))))
7705    (build-system cargo-build-system)
7706    (arguments
7707      `(#:cargo-inputs (("rust-nom" ,rust-nom))))
7708    (home-page "https://github.com/rustwasm/weedle")
7709    (synopsis "A WebIDL Parser")
7710    (description
7711      "This package provides a WebIDL Parser")
7712    (license license:expat)))
7713
7714(define-public rust-wasm-bindgen-webidl
7715  (package
7716    (name "rust-wasm-bindgen-webidl")
7717    (version "0.2.51")
7718    (source
7719      (origin
7720        (method url-fetch)
7721        (uri (crate-uri "wasm-bindgen-webidl" version))
7722        (file-name
7723          (string-append name "-" version ".tar.gz"))
7724        (sha256
7725          (base32
7726            "0z60nz63mxij6ba32qs6xy5dw48jvf140rvaj14lgzim0pxrm5wv"))))
7727    (build-system cargo-build-system)
7728    (arguments
7729      `(#:cargo-inputs
7730        (("rust-failure" ,rust-failure)
7731         ("rust-heck" ,rust-heck)
7732         ("rust-log" ,rust-log)
7733         ("rust-proc-macro2" ,rust-proc-macro2)
7734         ("rust-quote" ,rust-quote)
7735         ("rust-syn" ,rust-syn)
7736         ("rust-wasm-bindgen-backend"
7737          ,rust-wasm-bindgen-backend)
7738         ("rust-weedle" ,rust-weedle))))
7739    (home-page
7740      "https://rustwasm.github.io/wasm-bindgen/")
7741    (synopsis
7742      "Support for parsing WebIDL specific to wasm-bindgen
7743")
7744    (description
7745      "Support for parsing WebIDL specific to wasm-bindgen
7746")
7747    (license #f)))
7748
7749(define-public rust-web-sys
7750  (package
7751    (name "rust-web-sys")
7752    (version "0.3.28")
7753    (source
7754      (origin
7755        (method url-fetch)
7756        (uri (crate-uri "web-sys" version))
7757        (file-name
7758          (string-append name "-" version ".tar.gz"))
7759        (sha256
7760          (base32
7761            "0sygmam6y64k40zd32v2qaiiig4p2kxmy13gxlxs4b6hkill0i68"))))
7762    (build-system cargo-build-system)
7763    (arguments
7764      `(#:cargo-inputs
7765        (("rust-js-sys" ,rust-js-sys)
7766         ("rust-wasm-bindgen" ,rust-wasm-bindgen))
7767        #:cargo-development-inputs
7768        (("rust-env-logger" ,rust-env-logger)
7769         ("rust-failure" ,rust-failure)
7770         ("rust-sourcefile" ,rust-sourcefile)
7771         ("rust-wasm-bindgen-futures"
7772          ,rust-wasm-bindgen-futures)
7773         ("rust-wasm-bindgen-test"
7774          ,rust-wasm-bindgen-test)
7775         ("rust-wasm-bindgen-webidl"
7776          ,rust-wasm-bindgen-webidl))))
7777    (home-page
7778      "https://rustwasm.github.io/wasm-bindgen/web-sys/index.html")
7779    (synopsis
7780      "Bindings for all Web APIs, a procedurally generated crate from WebIDL
7781")
7782    (description
7783      "Bindings for all Web APIs, a procedurally generated crate from WebIDL
7784")
7785    (license #f)))
7786
7787(define-public rust-futures-channel-preview
7788  (package
7789    (name "rust-futures-channel-preview")
7790    (version "0.3.0-alpha.19")
7791    (source
7792      (origin
7793        (method url-fetch)
7794        (uri (crate-uri "futures-channel-preview" version))
7795        (file-name
7796          (string-append name "-" version ".tar.gz"))
7797        (sha256
7798          (base32
7799            "0fi6bi4lpyxjigy11y5sjg6wlc8nc71vbpmxz31c3aagjvgz9rfm"))))
7800    (build-system cargo-build-system)
7801    (arguments
7802      `(#:cargo-inputs
7803        (("rust-futures-core-preview"
7804          ,rust-futures-core-preview)
7805         ("rust-futures-sink-preview"
7806          ,rust-futures-sink-preview))))
7807    (home-page
7808      "https://rust-lang-nursery.github.io/futures-rs")
7809    (synopsis
7810      "Channels for asynchronous communication using futures-rs.
7811")
7812    (description
7813      "Channels for asynchronous communication using futures-rs.
7814")
7815    (license (list license:expat license:asl2.0))))
7816
7817(define-public rust-console-error-panic-hook
7818  (package
7819    (name "rust-console-error-panic-hook")
7820    (version "0.1.6")
7821    (source
7822      (origin
7823        (method url-fetch)
7824        (uri (crate-uri "console_error_panic_hook" version))
7825        (file-name
7826          (string-append name "-" version ".tar.gz"))
7827        (sha256
7828          (base32
7829            "04d2narcrzk9bnddz17rr2l819l82pr0h6d98s2w9q236n87dndq"))))
7830    (build-system cargo-build-system)
7831    (arguments
7832      `(#:cargo-inputs
7833        (("rust-cfg-if" ,rust-cfg-if)
7834         ("rust-wasm-bindgen" ,rust-wasm-bindgen))))
7835    (home-page
7836      "https://github.com/rustwasm/console_error_panic_hook")
7837    (synopsis
7838      "A panic hook for `wasm32-unknown-unknown` that logs panics to `console.error`")
7839    (description
7840      "This package provides a panic hook for `wasm32-unknown-unknown` that logs panics to `console.error`")
7841    (license #f)))
7842
7843(define-public rust-wasm-bindgen-test
7844  (package
7845    (name "rust-wasm-bindgen-test")
7846    (version "0.3.1")
7847    (source
7848      (origin
7849        (method url-fetch)
7850        (uri (crate-uri "wasm-bindgen-test" version))
7851        (file-name
7852          (string-append name "-" version ".tar.gz"))
7853        (sha256
7854          (base32
7855            "1a4fbzpq1il04sr4qhii31ndv0vgs5b385pq6m44rfrywk0k0g9c"))))
7856    (build-system cargo-build-system)
7857    (arguments
7858      `(#:cargo-inputs
7859        (("rust-console-error-panic-hook"
7860          ,rust-console-error-panic-hook)
7861         ("rust-js-sys" ,rust-js-sys)
7862         ("rust-scoped-tls" ,rust-scoped-tls)
7863         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
7864         ("rust-wasm-bindgen-futures"
7865          ,rust-wasm-bindgen-futures)
7866         ("rust-wasm-bindgen-test-macro"
7867          ,rust-wasm-bindgen-test-macro))))
7868    (home-page
7869      "https://github.com/rustwasm/wasm-bindgen")
7870    (synopsis
7871      "Internal testing crate for wasm-bindgen")
7872    (description
7873      "Internal testing crate for wasm-bindgen")
7874    (license #f)))
7875
7876(define-public rust-wasm-bindgen-futures
7877  (package
7878    (name "rust-wasm-bindgen-futures")
7879    (version "0.4.1")
7880    (source
7881      (origin
7882        (method url-fetch)
7883        (uri (crate-uri "wasm-bindgen-futures" version))
7884        (file-name
7885          (string-append name "-" version ".tar.gz"))
7886        (sha256
7887          (base32
7888            "0j6bxlkg6gvs617l4b3f89ncsdlmv7i9a782qcw1r6ncrq5l3d4g"))))
7889    (build-system cargo-build-system)
7890    (arguments
7891      `(#:cargo-inputs
7892        (("rust-cfg-if" ,rust-cfg-if)
7893         ("rust-js-sys" ,rust-js-sys)
7894         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
7895         ("rust-web-sys" ,rust-web-sys))
7896        #:cargo-development-inputs
7897        (("rust-futures-channel-preview"
7898          ,rust-futures-channel-preview)
7899         ("rust-wasm-bindgen-test"
7900          ,rust-wasm-bindgen-test))))
7901    (home-page
7902      "https://rustwasm.github.io/wasm-bindgen/")
7903    (synopsis
7904      "Bridging the gap between Rust Futures and JavaScript Promises")
7905    (description
7906      "Bridging the gap between Rust Futures and JavaScript Promises")
7907    (license #f)))
7908
7909(define-public rust-wasm-bindgen-macro
7910  (package
7911    (name "rust-wasm-bindgen-macro")
7912    (version "0.2.51")
7913    (source
7914      (origin
7915        (method url-fetch)
7916        (uri (crate-uri "wasm-bindgen-macro" version))
7917        (file-name
7918          (string-append name "-" version ".tar.gz"))
7919        (sha256
7920          (base32
7921            "0jib9jqga5skil1117vsk3dghyj0zg1j02352ql7k2ady0ml9hlj"))))
7922    (build-system cargo-build-system)
7923    (arguments
7924      `(#:cargo-inputs
7925        (("rust-quote" ,rust-quote)
7926         ("rust-wasm-bindgen-macro-support"
7927          ,rust-wasm-bindgen-macro-support))
7928        #:cargo-development-inputs
7929        (("rust-trybuild" ,rust-trybuild)
7930         ("rust-wasm-bindgen" ,rust-wasm-bindgen)
7931         ("rust-wasm-bindgen-futures"
7932          ,rust-wasm-bindgen-futures))))
7933    (home-page
7934      "https://rustwasm.github.io/wasm-bindgen/")
7935    (synopsis
7936      "Definition of the `#[wasm_bindgen]` attribute, an internal dependency
7937")
7938    (description
7939      "Definition of the `#[wasm_bindgen]` attribute, an internal dependency
7940")
7941    (license #f)))
7942
7943(define-public rust-wasm-bindgen
7944  (package
7945    (name "rust-wasm-bindgen")
7946    (version "0.2.51")
7947    (source
7948      (origin
7949        (method url-fetch)
7950        (uri (crate-uri "wasm-bindgen" version))
7951        (file-name
7952          (string-append name "-" version ".tar.gz"))
7953        (sha256
7954          (base32
7955            "1bsnlq3slnp34m7fn7skwyixqzn56d3751wf7371g0r21nxcad6d"))))
7956    (build-system cargo-build-system)
7957    (arguments
7958      `(#:cargo-inputs
7959        (("rust-cfg-if" ,rust-cfg-if)
7960         ("rust-serde" ,rust-serde)
7961         ("rust-serde-json" ,rust-serde-json)
7962         ("rust-wasm-bindgen-macro"
7963          ,rust-wasm-bindgen-macro))))
7964    (home-page "https://rustwasm.github.io/")
7965    (synopsis
7966      "Easy support for interacting between JS and Rust.
7967")
7968    (description
7969      "Easy support for interacting between JS and Rust.
7970")
7971    (license #f)))
7972
7973(define-public rust-getrandom
7974  (package
7975    (name "rust-getrandom")
7976    (version "0.1.12")
7977    (source
7978      (origin
7979        (method url-fetch)
7980        (uri (crate-uri "getrandom" version))
7981        (file-name
7982          (string-append name "-" version ".tar.gz"))
7983        (sha256
7984          (base32
7985            "0w9mj0nrzhhkl4n8l18n14hfabiwxs6az8fhij01xzy8miji4fj7"))))
7986    (build-system cargo-build-system)
7987    (arguments
7988      `(#:cargo-inputs
7989        (("rust-cfg-if" ,rust-cfg-if)
7990         ("rust-compiler-builtins"
7991          ,rust-compiler-builtins)
7992         ("rust-libc" ,rust-libc)
7993         ("rust-log" ,rust-log)
7994         ("rust-rustc-std-workspace-core"
7995          ,rust-rustc-std-workspace-core)
7996         ("rust-stdweb" ,rust-stdweb)
7997         ("rust-wasi" ,rust-wasi)
7998         ("rust-wasm-bindgen" ,rust-wasm-bindgen))))
7999    (home-page
8000      "https://github.com/rust-random/getrandom")
8001    (synopsis
8002      "A small cross-platform library for retrieving random data from system source")
8003    (description
8004      "This package provides a small cross-platform library for retrieving random data from system source")
8005    (license (list license:expat license:asl2.0))))
8006
8007(define-public rust-rand-core
8008  (package
8009    (name "rust-rand-core")
8010    (version "0.5.1")
8011    (source
8012      (origin
8013        (method url-fetch)
8014        (uri (crate-uri "rand_core" version))
8015        (file-name
8016          (string-append name "-" version ".tar.gz"))
8017        (sha256
8018          (base32
8019            "06bdvx08v3rkz451cm7z59xwwqn1rkfh6v9ay77b14f8dwlybgch"))))
8020    (build-system cargo-build-system)
8021    (arguments
8022      `(#:cargo-inputs
8023        (("rust-getrandom" ,rust-getrandom)
8024         ("rust-serde" ,rust-serde))))
8025    (home-page "https://crates.io/crates/rand_core")
8026    (synopsis
8027      "Core random number generator traits and tools for implementation.
8028")
8029    (description
8030      "Core random number generator traits and tools for implementation.
8031")
8032    (license (list license:expat license:asl2.0))))
8033
8034(define-public rust-quickcheck
8035  (package
8036    (name "rust-quickcheck")
8037    (version "0.9.0")
8038    (source
8039      (origin
8040        (method url-fetch)
8041        (uri (crate-uri "quickcheck" version))
8042        (file-name
8043          (string-append name "-" version ".tar.gz"))
8044        (sha256
8045          (base32
8046            "0qi67dg7cf50i23ac7n5qhg4vhhsm6xznhpl2wsqv86s5x551jnm"))))
8047    (build-system cargo-build-system)
8048    (arguments
8049      `(#:cargo-inputs
8050        (("rust-env-logger" ,rust-env-logger)
8051         ("rust-log" ,rust-log)
8052         ("rust-rand" ,rust-rand)
8053         ("rust-rand-core" ,rust-rand-core))))
8054    (home-page
8055      "https://github.com/BurntSushi/quickcheck")
8056    (synopsis
8057      "Automatic property based testing with shrinking.")
8058    (description
8059      "Automatic property based testing with shrinking.")
8060    (license #f)))
8061
8062(define-public rust-ucd-parse
8063  (package
8064    (name "rust-ucd-parse")
8065    (version "0.1.4")
8066    (source
8067      (origin
8068        (method url-fetch)
8069        (uri (crate-uri "ucd-parse" version))
8070        (file-name
8071          (string-append name "-" version ".tar.gz"))
8072        (sha256
8073          (base32
8074            "1d06wcnzs1kqdc0wszlycclhvr92j9v08nkq0w7jyld69nzm4sya"))))
8075    (build-system cargo-build-system)
8076    (arguments
8077      `(#:cargo-inputs
8078        (("rust-lazy-static" ,rust-lazy-static)
8079         ("rust-regex" ,rust-regex))))
8080    (home-page
8081      "https://github.com/BurntSushi/ucd-generate")
8082    (synopsis
8083      "A library for parsing data files in the Unicode character database.
8084")
8085    (description
8086      "This package provides a library for parsing data files in the Unicode character database.
8087")
8088    (license #f)))
8089
8090(define-public rust-unicode-segmentation
8091  (package
8092    (name "rust-unicode-segmentation")
8093    (version "1.3.0")
8094    (source
8095      (origin
8096        (method url-fetch)
8097        (uri (crate-uri "unicode-segmentation" version))
8098        (file-name
8099          (string-append name "-" version ".tar.gz"))
8100        (sha256
8101          (base32
8102            "1a9jqg7rb1yq6w2xc9jgxcs111yk5vxm9afjfvykfnrmzk6z8rqr"))))
8103    (build-system cargo-build-system)
8104    (arguments
8105      `(#:cargo-development-inputs
8106        (("rust-quickcheck" ,rust-quickcheck))))
8107    (home-page
8108      "https://github.com/unicode-rs/unicode-segmentation")
8109    (synopsis
8110      "This crate provides Grapheme Cluster, Word and Sentence boundaries
8111according to Unicode Standard Annex #29 rules.
8112")
8113    (description
8114      "This crate provides Grapheme Cluster, Word and Sentence boundaries
8115according to Unicode Standard Annex #29 rules.
8116")
8117    (license #f)))
8118
8119(define-public rust-bstr
8120  (package
8121    (name "rust-bstr")
8122    (version "0.2.8")
8123    (source
8124      (origin
8125        (method url-fetch)
8126        (uri (crate-uri "bstr" version))
8127        (file-name
8128          (string-append name "-" version ".tar.gz"))
8129        (sha256
8130          (base32
8131            "0i82qr3z4vwcdx7gjsjrqy64w1w88i5s7b7ab97hm4mbb1djqv4d"))))
8132    (build-system cargo-build-system)
8133    (arguments
8134      `(#:cargo-inputs
8135        (("rust-lazy-static" ,rust-lazy-static)
8136         ("rust-memchr" ,rust-memchr)
8137         ("rust-regex-automata" ,rust-regex-automata)
8138         ("rust-serde" ,rust-serde))
8139        #:cargo-development-inputs
8140        (("rust-quickcheck" ,rust-quickcheck)
8141         ("rust-ucd-parse" ,rust-ucd-parse)
8142         ("rust-unicode-segmentation"
8143          ,rust-unicode-segmentation))))
8144    (home-page "https://github.com/BurntSushi/bstr")
8145    (synopsis
8146      "A string type that is not required to be valid UTF-8.")
8147    (description
8148      "This package provides a string type that is not required to be valid UTF-8.")
8149    (license (list license:expat license:asl2.0))))
8150
8151(define-public rust-ripgrep
8152  (package
8153    (name "rust-ripgrep")
8154    (version "11.0.2")
8155    (source
8156      (origin
8157        (method url-fetch)
8158        (uri (crate-uri "ripgrep" version))
8159        (file-name
8160          (string-append name "-" version ".tar.gz"))
8161        (sha256
8162          (base32
8163            "0vqjr96s2rs45715hzf0g0wjahig4zjyiqfijmzzg4jyh9ni80yr"))))
8164    (build-system cargo-build-system)
8165    (arguments
8166      `(#:cargo-inputs
8167        (("rust-bstr" ,rust-bstr)
8168         ("rust-clap" ,rust-clap)
8169         ("rust-grep" ,rust-grep)
8170         ("rust-ignore" ,rust-ignore)
8171         ("rust-jemallocator" ,rust-jemallocator)
8172         ("rust-lazy-static" ,rust-lazy-static)
8173         ("rust-log" ,rust-log)
8174         ("rust-num-cpus" ,rust-num-cpus)
8175         ("rust-regex" ,rust-regex)
8176         ("rust-serde-json" ,rust-serde-json)
8177         ("rust-termcolor" ,rust-termcolor))
8178        #:cargo-development-inputs
8179        (("rust-clap" ,rust-clap)
8180         ("rust-lazy-static" ,rust-lazy-static)
8181         ("rust-serde" ,rust-serde)
8182         ("rust-serde-derive" ,rust-serde-derive))))
8183    (home-page
8184      "https://github.com/BurntSushi/ripgrep")
8185    (synopsis
8186      "ripgrep is a line-oriented search tool that recursively searches your current
8187directory for a regex pattern while respecting your gitignore rules. ripgrep
8188has first class support on Windows, macOS and Linux.
8189")
8190    (description
8191      "ripgrep is a line-oriented search tool that recursively searches your current
8192directory for a regex pattern while respecting your gitignore rules.  ripgrep
8193has first class support on Windows, macOS and Linux.
8194")
8195    (license (list license:unlicense license:expat))))