Crate of the Week

The new experimental 5.0 release seems to be faster than FFTW:

7 Likes

Autograd: Tensors and differentiable operations (like TensorFlow) in Rust

3 Likes

nom-supreme is a crate of utilities for nom parsers, especially for great parse error handling.

2 Likes

Just stumbled across this project and I'm pretty stoked about it. It helps you automatically "absorb" changes into your git history without having to manually find the relevant commits. I have often wanted to have this functionality and haven't been able to find this until now.

If this isn't making sense, learn more about git fixup and autosquash.

4 Likes

It seems to be faster than the lexical crate.

5 Likes
2 Likes

A nice crate implementing some numeric algorithms.

1 Like

StructOpt if you ever want easy commandline parser

2 Likes

Yes, StructOpt is cool as is CLAP. Looks like both will merge in a future version of CLAP.
StructOpt was already crate of the week in issue 186.

broccoli: A 2D collision detection crate.

This looks nice, I wonder how it compares to ncollide.

Allows you to have some nice diagrams in your docs.

3 Likes

A Rust macro for writing regex pattern matching.

Usage

fn main() {
    let text1 = "2020-01-01";
    regexm::regexm!(match text1 {
        r"^\d{4}$" => println!("y"),
        r"^\d{4}-\d{2}$" => println!("y-m"),
        r"^\d{4}-\d{2}-\d{2}$" => {
            let y_m_d = "y-m-d";
            println!("{}", y_m_d);
        }
        _ => println!("default"),
    });
}
2 Likes

Pals, Processes' Arguments LiSt

The pals command dumps all running processes' pid,ppid,command name,arguments and prints JSON to reflect the process trees.

Example of output

[{cmd: "alpha", pid:105, args:[ "alpha" ], subs:[
  {cmd: "beta", pid:107, args:[ "beta", "--help" ]},
  {cmd: "gamma", pid:106 }]},
 {cmd: "lorum", pid:102, subs:[
  {cmd: "ipsumipsum", pid:104, args:[ "ipsumipsumipsum", "--name-too-long" ]}]}]

The pals library provides pals() which returns a list of process trees.

Example of API usage

use pals::{Proc, pals};

pals().map( |proc_list| {
    fn assert_ppid_is_parent_pid( proc: Proc ) {
        proc.parent()
            .map( |parent| assert_eq!( parent.pid, proc.ppid ));
        proc.children()
            .for_each( |subproc| assert_ppid_is_parent_pid( subproc ));
    }

    proc_list
        .children()
        .for_each( |proc| assert_ppid_is_parent_pid( proc ))
}).unwrap();
1 Like

fancy-regex is really cool. It implements backtracking and look-around for regular expressions while delegating as much as possible to the regex crate.

In essence, it is a backtracking VM (as well explained in Regular Expression Matching: the Virtual Machine Approach) in which one of the "instructions" in the VM delegates to an inner NFA implementation (in Rust, the regex crate, though a similar approach would certainly be possible using RE2 or the Go regexp package). Then there's an analysis which decides for each subexpression whether it is "hard", or can be delegated to the NFA matcher. At the moment, it is eager, and delegates as much as possible to the NFA engine.

5 Likes

iai looks really nice. From the README:

Iai is an experimental benchmarking harness that uses Cachegrind to perform extremely precise single-shot measurements of Rust code.

2 Likes

Rocket is a great crate!
Really old thread, surprised to see it still going!

1 Like

These crate nominations are looked through to find a "crate of the week" to highlight in the "this week in rust" community newsletter.

This thread and "quote of the week" are special in the same way :slight_smile:

2 Likes

Small but useful: I recently discovered the thread-io crate, which makes it easy to put a reader into a background thread so that processing can happen concurrently. The win for this for me was to have one thread decoding a zstd-compressed file while the main thread parsed its contents using the csv crate. It sped things up by about 1.6x parsing a large csv file (8.7GB compressed, 79GB uncompressed) with very modest code changes.

6 Likes

Lever: library for writing transactional systems.

3 Likes