stdx - The missing batteries of Rust

bitflags = "0.9.1"  📖

#[macro_use]externcrate bitflags;bitflags!{structFlags:u32{constFLAG_A       =0b00000001;constFLAG_B       =0b00000010;constFLAG_C       =0b00000100;constFLAG_ABC     =FLAG_A.bits                           |FLAG_B.bits                           |FLAG_C.bits;}}fnmain(){let e1 =FLAG_A |FLAG_C;let e2 =FLAG_B |FLAG_C;assert_eq!((e1 | e2),FLAG_ABC);// unionassert_eq!((e1& e2),FLAG_C);// intersectionassert_eq!((e1 - e2),FLAG_A);// set differenceassert_eq!(!e2,FLAG_A);// set complement}

byteorder = "1.1.0"  📖

externcrate byteorder;use std::io::Cursor;use byteorder::{BigEndian,ReadBytesExt};use byteorder::{LittleEndian,WriteBytesExt};fnmain(){// Read unsigned 16 bit big-endian integers from a Read type:letmut rdr =Cursor::new(vec![2,5,3,0]);// Note that we use type parameters to indicate which kind of byte// order we want!assert_eq!(517, rdr.read_u16::<BigEndian>().unwrap());assert_eq!(768, rdr.read_u16::<BigEndian>().unwrap());// Write unsigned 16 bit little-endian integers to a Write type:letmut wtr =vec![];    wtr.write_u16::<LittleEndian>(517).unwrap();    wtr.write_u16::<LittleEndian>(768).unwrap();assert_eq!(wtr, vec![5,2,0,3]);}

chrono = "0.4.0"  📖

externcrate chrono;use chrono::*;fnmain(){let local:DateTime<Local> =Local::now();let utc:DateTime<Utc> =Utc::now();let dt =Utc.ymd(2014,11,28).and_hms(12,0,9);assert_eq!((dt.year(), dt.month(), dt.day()),(2014,11,28));assert_eq!((dt.hour(), dt.minute(), dt.second()),(12,0,9));assert_eq!(dt.format("%Y-%m-%d %H:%M:%S").to_string(),"2014-11-28 12:00:09");assert_eq!(dt.format("%a %b %e %T %Y").to_string(),"Fri Nov 28 12:00:09 2014");assert_eq!(format!("{}", dt),"2014-11-28 12:00:09 UTC");}

clap = "2.25.0"  📖

externcrate clap;use clap::{Arg,App,SubCommand};fnmain(){let app =App::new("My Super Program").version("1.0").author("Kevin K. <kbknapp@gmail.com>").about("Does awesome things").arg(Arg::with_name("config").short("c").long("config").value_name("FILE").help("Sets a custom config file").takes_value(true)).arg(Arg::with_name("INPUT").help("Sets the input file to use").required(true).index(1)).subcommand(SubCommand::with_name("test").about("controls testing features").arg(Arg::with_name("debug").short("d").help("print debug information verbosely")));// Parse the command line argumentslet matches = app.get_matches();let config = matches.value_of("config").unwrap_or("default.conf");let input = matches.value_of("INPUT").unwrap();// Handle subcommandsmatch matches.subcommand(){("clone",Some(sub_matches)) =>{if matches.is_present("d"){// ...}},("push",Some(sub_matches)) =>{},("commit",Some(sub_matches)) =>{},        _ =>{},}}

encoding_rs = "0.6.11"  📖

externcrate encoding_rs;use encoding_rs::*;fnmain(){let expected ="\u{30CF}\u{30ED}\u{30FC}\u{30FB}\u{30EF}\u{30FC}\u{30EB}\u{30C9}";let encoded =b"\x83n\x83\x8D\x81[\x81E\x83\x8F\x81[\x83\x8B\x83h";let(decoded, encoding_used, had_errors) =SHIFT_JIS.decode(encoded);assert_eq!(&decoded[..], expected);assert_eq!(encoding_used,SHIFT_JIS);assert!(!had_errors);println!("Decoded result: {}", decoded);}

error-chain = "0.10.0"  📖

// `error_chain!` can recurse deeply#![recursion_limit ="1024"]#[macro_use]externcrate error_chain;// We'll put our errors in an `errors` module, and other modules in// this crate will `use errors::*;` to get access to everything// `error_chain!` creates.mod errors{// Create the Error, ErrorKind, ResultExt, and Result typeserror_chain!{}}use errors::*;fnmain(){ifletErr(ref e) =run(){use::std::io::Write;let stderr =&mut::std::io::stderr();let errmsg ="Error writing to stderr";writeln!(stderr,"error: {}", e).expect(errmsg);for ein e.iter().skip(1){writeln!(stderr,"caused by: {}", e).expect(errmsg);}// The backtrace is not always generated. Try to run this example// with `RUST_BACKTRACE=1`.ifletSome(backtrace) = e.backtrace(){writeln!(stderr,"backtrace: {:?}", backtrace).expect(errmsg);}::std::process::exit(1);}}// Most functions will return the `Result` type, imported from the// `errors` module. It is a typedef of the standard `Result` type// for which the error type is always our own `Error`.fnrun() ->Result<()>{use std::fs::File;// Use chain_err to attach your own context to errorsFile::open("my secret file").chain_err(||"unable to open my secret file")?;// Use the `bail!` macro to return an error Result, ala `println!`bail!("giving up");}

flate2 = "0.2.19"  📖

externcrate flate2;externcrate tar;use flate2::read::GzDecoder;use std::env;use std::fs::File;use std::io::{self,BufReader};use tar::Archive;fnrun() ->Result<(), io::Error>{letmut args = env::args().skip(1);let tarball = args.next().expect("incorrect argument");let outdir = args.next().expect("incorrect argument");let archive =File::open(tarball)?;let archive =BufReader::new(archive);let archive =GzDecoder::new(archive)?;letmut archive =Archive::new(archive);    archive.unpack(outdir)?;Ok(())}fnmain(){run().unwrap()}

fnv = "1.0.5"  📖

externcrate fnv;use fnv::FnvHashMap;fnmain(){letmut map =FnvHashMap::default();    map.insert(1,"one");    map.insert(2,"two");    map.insert(3,"three");for(number, word)in map.iter(){println!("Number {}: {}", number, word);}    map.remove(&(2));println!("The length of HashMap is {}.", map.len());println!("The first element is {}.", map.get(&(1)).unwrap());}

itertools = "0.6.0"  📖

externcrate itertools;use itertools::{join, max, sorted};fnmain(){let a =[3,2,5,8,7];// Combine all iterator elements into one String,// seperated by *.println!("{:?}", join(&a,"*"));// Return the maximum value of the iterable.println!("{:?}", max(a.iter()).unwrap());// Collect all the iterable's elements into a// sorted vector in ascending order.println!("{:?}", sorted(a.iter()));}

lazy_static = "0.2.8"  📖

#[macro_use]externcrate lazy_static;use std::collections::HashMap;lazy_static!{static refHASHMAP:HashMap<u32,&'staticstr> ={letmut m =HashMap::new();        m.insert(0,"foo");        m.insert(1,"bar");        m.insert(2,"baz");        m};static refCOUNT:usize =HASHMAP.len();static refNUMBER:u32 = times_two(21);}fntimes_two(n:u32) ->u32{ n*2}fnmain(){println!("The map has {} entries.",*COUNT);println!("The entry for `0` is\"{}\".",HASHMAP.get(&0).unwrap());println!("A expensive calculation on a static results in: {}.",*NUMBER);}

libc = "0.2.25"  📖

externcrate libc;fnmain(){unsafe{        libc::exit(0);}}

log = "0.3.8"  📖

#[macro_use]externcrate log;externcrate env_logger;use log::LogLevel;fnmain(){    env_logger::init().unwrap();debug!("this is a debug {}","message");error!("this is printed by default");iflog_enabled!(LogLevel::Info){let x =3*4;// expensive computationinfo!("the answer was: {}", x);}}

memmap = "0.5.2"  📖

externcrate memmap;use memmap::{Mmap,Protection};use std::env;use std::io;use std::str;fnrun() ->Result<(), io::Error>{letmut args = env::args().skip(1);let input = args.next().expect("incorrect argument");let map =Mmap::open_path(input,Protection::Read)?;unsafe{let all_bytes = map.as_slice();ifletOk(file_str) = str::from_utf8(all_bytes){println!("{}", file_str);}else{println!("not utf8");}}Ok(())}fnmain(){run().unwrap()}

ndarray = "0.9.1"  📖

#[macro_use(s)]externcrate ndarray;use ndarray::{Array3, arr3};fnmain(){// Create a three-dimensional f64 array, initialized with zerosletmut temperature =Array3::<f64>::zeros((3,4,5));// Increase the temperature in this location, notice the// double-brackets indexing `temperature`    temperature[[2,2,2]] +=0.5;// Create a 3-dimensional matrix,// 2 submatrices of 2 rows with 3 elements per row, means a shape// of `[2, 2, 3]`.let a =arr3(&[[[1,2,3],// -- 2 rows  \_[4,5,6]],// --         /[[7,8,9],//            \_ 2 submatrices[10,11,12]]]);//            ///  3 columns ..../.../.../// This is a 2 x 2 x 3 arrayassert_eq!(a.shape(),&[2,2,3]);// Let’s create a slice of `a` with//// - Both of the submatrices of the greatest dimension: `..`// - Only the first row in each submatrix: `0..1`// - Every element in each row: `..`let b = a.slice(s![..,0..1, ..]);// This is the result of the above slice into `a`let c =arr3(&[[[1,2,3]],[[7,8,9]]]);assert_eq!(b, c);assert_eq!(b.shape(),&[2,1,3]);}

num = "0.1.40"  📖

externcrate num;use num::FromPrimitive;use num::bigint::BigInt;use num::rational::{Ratio,BigRational};fnapprox_sqrt(number:u64,iterations:usize) ->BigRational{let start:Ratio<BigInt>        =Ratio::from_integer(FromPrimitive::from_u64(number).unwrap());letmut approx = start.clone();for _in0..iterations{        approx =(&approx +(&start /&approx)) /Ratio::from_integer(FromPrimitive::from_u64(2).unwrap());}    approx}fnmain(){println!("{}", approx_sqrt(10,4));// prints 4057691201/1283082416}

num_cpus = "1.6.2"  📖

externcrate threadpool;externcrate num_cpus;use threadpool::ThreadPool;use std::sync::mpsc::channel;fnmain(){// Get the number of cpus on current machinelet n_workers = num_cpus::get();let n_jobs =8;// Create the thread pool with amount of workers equal to coreslet pool =ThreadPool::new(n_workers);// Create transmitter and receiver channellet(tx, rx) =channel();// For each job grab a free worker from the pool and executefor _in0..n_jobs{let tx = tx.clone();        pool.execute(move ||{            tx.send(1).unwrap();});}assert_eq!(rx.iter().take(n_jobs).fold(0, |a, b| a + b),8);}

rand = "0.3.15"  📖

externcrate rand;use rand::Rng;fnmain(){letmut rng = rand::thread_rng();if rng.gen(){// random boolprintln!("i32: {}, u32: {}", rng.gen::<i32>(), rng.gen::<u32>())}let tuple = rand::random::<(f64,char)>();println!("{:?}", tuple)}

rayon = "0.8.2"  📖

externcrate rayon;use rayon::prelude::*;fnmain(){letmut input =(0..1000).collect::<Vec<_>>();// Calculate the sum of squareslet sq_sum:i32 = input.par_iter().map(|&i| i* i).sum();// Increment each element in parallel    input.par_iter_mut().for_each(|p|*p +=1);// Parallel quicksortletmut input =(0..1000).rev().collect::<Vec<_>>();quick_sort(&mut input);}fnquick_sort<T:PartialOrd +Send>(v:&mut[T]){if v.len() <=1{return;}let mid =partition(v);let(lo, hi) = v.split_at_mut(mid);    rayon::join(||quick_sort(lo), ||quick_sort(hi));}fnpartition<T:PartialOrd +Send>(v:&mut[T]) ->usize{let pivot = v.len() -1;letmut i =0;for jin0..pivot{if v[j] <= v[pivot]{            v.swap(i, j);            i +=1;}}    v.swap(i, pivot);    i}

regex = "0.2.2"  📖

externcrate regex;use regex::Regex;fnmain(){// Find a datelet re =Regex::new(r"^\d{4}-\d{2}-\d{2}$").unwrap();assert!(re.is_match("2014-01-01"));// Iterating over capture groupslet re =Regex::new(r"(\d{4})-(\d{2})-(\d{2})").unwrap();let text ="2012-03-14, 2013-01-01 and 2014-07-05";for capin re.captures_iter(text){println!("Month: {} Day: {} Year: {}",&cap[2],&cap[3],&cap[1]);}}

reqwest = "0.7.1"  📖

externcrate reqwest;use std::collections::HashMap;use std::io::{BufRead,BufReader};fnmain(){// Make a GET requestlet resp = reqwest::get("https://www.rust-lang.org").unwrap();assert!(resp.status().is_success());let lines =BufReader::new(resp).lines().filter_map(|l| l.ok()).take(10);for linein lines{println!("{}", line);}// Make a POST requestlet client = reqwest::Client::new().unwrap();let res = client.post("http://httpbin.org/post").unwrap().body("the exact body that is sent").send();// Convert to/from JSON automaticallyletmut map =HashMap::new();    map.insert("lang","rust");    map.insert("body","json");// This will POST a body of `{"lang":"rust","body":"json"}`let client = reqwest::Client::new().unwrap();let res = client.post("http://httpbin.org/post").unwrap().json(&map).unwrap().send();}

semver = "0.7.0"  📖

externcrate semver;use semver::Version;fnmain(){// Construct Version objectsassert!(Version::parse("1.2.3") ==Ok(Version{        major:1,        minor:2,        patch:3,        pre: vec!(),        build: vec!(),}));// Compare Versionsassert!(Version::parse("1.2.3-alpha") !=Version::parse("1.2.3-beta"));assert!(Version::parse("1.2.3-alpha2") >Version::parse("1.2.0"));// Increment patch number of mutable Versionletmut bugfix_release =Version::parse("1.0.0").unwrap();    bugfix_release.increment_patch();assert_eq!(Ok(bugfix_release),Version::parse("1.0.1"));}

serde = "1.0.10"  📖

#[macro_use]externcrate serde_derive;externcrate serde_json;use serde_json::Value;#[derive(Serialize,Deserialize,Debug)]structContact{name:String,age:u32,}fnmain(){let contact =Contact{name:"Brian".to_string(),age:21,};// Serialize data structures to strings in JSON formatlet contact:String = serde_json::to_string(&contact).unwrap();println!("{}", contact);// Deserialize data structures from JSON stringslet contact:Contact = serde_json::from_str(&contact).unwrap();println!("{:?}", contact);// Convert to arbitrary JSON `Value` typelet contact:Value = serde_json::to_value(&contact).unwrap();println!("{:?}", contact);}

serde_json = "1.0.2"  📖

externcrate serde_json;use serde_json::Value;fnmain(){// Some JSON input data as a &str. Maybe this comes from the user.let data =r#"{                    "name": "John Doe",                    "age": 43,                    "phones": [                      "+44 1234567",                      "+44 2345678"                    ]                  }"#;// Parse the string of data into serde_json::Value.let v:Value = serde_json::from_str(data).unwrap();// Access parts of the data by indexing with square brackets.println!("Please call {} at the number {}", v["name"], v["phones"][0]);}

tar = "0.4.23"  📖

externcrate flate2;externcrate tar;use flate2::read::GzDecoder;use std::env;use std::fs::File;use std::io::{self,BufReader};use tar::Archive;fnrun() ->Result<(), io::Error>{letmut args = env::args().skip(1);let tarball = args.next().expect("incorrect argument");let outdir = args.next().expect("incorrect argument");let archive =File::open(tarball)?;let archive =BufReader::new(archive);let archive =GzDecoder::new(archive)?;letmut archive =Archive::new(archive);    archive.unpack(outdir)?;Ok(())}fnmain(){run().unwrap()}

tempdir = "0.3.5"  📖

externcrate tempdir;use std::fs::File;use std::io::Write;use tempdir::TempDir;fnmain(){// Create a directory inside of `std::env::temp_dir()`, named with// the prefix "example".let tmp_dir =TempDir::new("example").expect("create temp dir");let file_path = tmp_dir.path().join("my-temporary-note.txt");letmut tmp_file =File::create(file_path).expect("create temp file");writeln!(tmp_file,"Brian was here. Briefly.").expect("write temp file");// By closing the `TempDir` explicitly, we can check that it has// been deleted successfully. If we don't close it explicitly,// the directory will still be deleted when `tmp_dir` goes out// of scope, but we won't know whether deleting the directory// succeeded.drop(tmp_file);    tmp_dir.close().expect("delete temp dir");}

threadpool = "1.4.0"  📖

externcrate threadpool;externcrate num_cpus;use threadpool::ThreadPool;use std::sync::mpsc::channel;fnmain(){// Get the number of cpus on current machinelet n_workers = num_cpus::get();let n_jobs =8;// Create the thread pool with amount of workers equal to coreslet pool =ThreadPool::new(n_workers);// Create transmitter and receiver channellet(tx, rx) =channel();// For each job grab a free worker from the pool and executefor _in0..n_jobs{let tx = tx.clone();        pool.execute(move ||{            tx.send(1).unwrap();});}assert_eq!(rx.iter().take(n_jobs).fold(0, |a, b| a + b),8);}

toml = "0.4.2"  📖

externcrate toml;use toml::Value;fnmain(){let toml =r#"    [test]    foo = "bar""#;let value = toml.parse::<Value>().unwrap();println!("{:?}", value);}

url = "1.5.1"  📖

externcrate url;use url::{Url,Host};fnmain(){let issue_list_url =Url::parse("https://github.com/rust-lang/rust/issues?labels=E-easy&state=open").unwrap();assert!(issue_list_url.scheme() =="https");assert!(issue_list_url.username() =="");assert!(issue_list_url.password() ==None);assert!(issue_list_url.host_str() ==Some("github.com"));assert!(issue_list_url.host() ==Some(Host::Domain("github.com")));assert!(issue_list_url.port() ==None);assert!(issue_list_url.path() =="/rust-lang/rust/issues");assert!(issue_list_url.path_segments().map(|c| c.collect::<Vec<_>>()) ==Some(vec!["rust-lang","rust","issues"]));assert!(issue_list_url.query() ==Some("labels=E-easy&state=open"));assert!(issue_list_url.fragment() ==None);assert!(!issue_list_url.cannot_be_a_base());}

walkdir = "1.0.7"  📖

externcrate walkdir;use walkdir::{WalkDir,Error};fnrun() ->Result<(),Error>{let wd =WalkDir::new(".");for entryin wd{let entry = entry?;println!("{}", entry.path().display());}Ok(())}fnmain(){run().unwrap();}

Aboutstdx

How to usestdx

[dependencies]bitflags ="0.9.1"

#[macro_use]externcrate bitflags;bitflags!{structFlags:u32{constFLAG_A       =0b00000001;constFLAG_B       =0b00000010;constFLAG_C       =0b00000100;constFLAG_ABC     =FLAG_A.bits                           |FLAG_B.bits                           |FLAG_C.bits;}}fnmain(){let e1 =FLAG_A |FLAG_C;let e2 =FLAG_B |FLAG_C;assert_eq!((e1 | e2),FLAG_ABC);// unionassert_eq!((e1& e2),FLAG_C);// intersectionassert_eq!((e1 - e2),FLAG_A);// set differenceassert_eq!(!e2,FLAG_A);// set complement}

cargo run --example bitflags

Why usestdx?

Selection criteria

Contributing

License