Programming-Idioms.org

println!("Hello World");

for _ in 0..10 { println!("Hello"); }

print!("{}", "Hello\n".repeat(10));

fn finish(name: &str) {
    println!("My job here is done. Goodbye {}", name);
}

fn square(x : u32) -> u32 { x * x }

struct Point {
    x: f64,
    y: f64,
}

struct Point(f64, f64);

for x in items {
	do_something(x);
}

items.into_iter().for_each(|x| do_something(x));

for (i, x) in items.iter().enumerate() {
    println!("Item {} = {}", i, x);
}

items.iter().enumerate().for_each(|(i, x)| {
    println!("Item {} = {}", i, x);
})

let mut x = BTreeMap::new();
x.insert("one", 1);
x.insert("two", 2);

let x: HashMap<&str, i32> = [
    ("one", 1),
    ("two", 2),
].into_iter().collect();

struct BinTree<T> {
    value: T,
    left: Option<Box<BinTree<T>>>,
    right: Option<Box<BinTree<T>>>,
}

let mut rng = StdRng::new().unwrap();
rng.shuffle(&mut x);

let mut rng = thread_rng();
x.shuffle(&mut rng);

x[rand::thread_rng().gen_range(0..x.len())]

let mut rng = rand::thread_rng();
let choice = x.choose(&mut rng).unwrap();

list.contains(&x);

list.iter().any(|v| v == &x)

(&list).into_iter().any(|v| v == &x)

list.binary_search(&x).is_ok()

for (k, x) in &mymap {
    println!("Key={key}, Value={val}", key=k, val=x);
}

thread_rng().gen_range(a..b);

fn pick(a: i32, b: i32) -> i32 {
    let between = Range::new(a, b);
    let mut rng = rand::thread_rng();
    between.ind_sample(&mut rng)
}

Uniform::new_inclusive(a, b).sample(&mut rand::thread_rng())

fn depthFirstTraverse<T>(bt: &mut BiTree<T>, f: fn(&mut BiTree<T>)) {
    if let Some(left) = &mut bt.left {
        f(left);
    }
    
    f(bt);
    
    if let Some(right) = &mut bt.right {
        f(right);
    }
}

struct Node<T> {
  value: T,
  children: Vec<Node<T>>,
}

pub struct Tree<V> {
    children: Vec<Tree<V>>,
    value: V
}

impl<V> Tree<V> {
    pub fn dfs<F: Fn(&V)>(&self, f: F) {
        self.dfs_helper(&f);
    }
    fn dfs_helper<F: Fn(&V)>(&self, f: &F) {
        (f)(&self.value);
        for child in &self.children {
            child.dfs_helper(f)
        }
    }
    // ...
}

let y: Vec<_> = x.into_iter().rev().collect();

x.reverse();

fn search<T: Eq>(m: &Vec<Vec<T>>, x: &T) -> Option<(usize, usize)> {
    for (i, row) in m.iter().enumerate() {
        for (j, column) in row.iter().enumerate() {
            if *column == *x {
                return Some((i, j));
            }
        }
    }

    None
}

std::mem::swap(&mut a, &mut b);

let (a, b) = (b, a);

let i = s.parse::<i32>().unwrap();

let i: i32 = s.parse().unwrap_or(0);

let i = match s.parse::<i32>() {
  Ok(i) => i,
  Err(_e) => -1,
};

let s = format!("{:.2}", x);

let s = "ネコ";

let (send, recv) = channel();

thread::spawn(move || {
    loop {
        let msg = recv.recv().unwrap();
        println!("Hello, {:?}", msg);
    }  
});

send.send("Alan").unwrap();

let mut x = vec![vec![0.0f64; N]; M];

let mut x = [[0.0; N] ; M];

let x = vec![vec![vec![0.0f64; p]; n]; m];

let x = [[[0.0f64; P]; N]; M];

items.sort_by(|a,b| a.p.cmp(&b.p));

items.sort_by_key(|x| x.p);

items.remove(i)

let threads: Vec<_> = (0..1000).map(|i| {
	thread::spawn(move || f(i))
}).collect();

for thread in threads {
	thread.join();
}

(0..1000).into_par_iter().for_each(f);

fn f(n: u32) -> u32 {
    if n < 2 {
        1
    } else {
        n * f(n - 1)
    }
}

fn factorial(num: u64) -> u64 {
    match num {
        0 | 1 => 1,
        _ => factorial(num - 1) * num,
    }
}

fn exp(x: u64, n: u64) -> u64 {
    match n {
        0 => 1,
        1 => x,
        i if i % 2 == 0 => exp(x * x, n / 2),
        _ => x * exp(x * x, (n - 1) / 2),
    }     
}

fn exp(x: u64, n: u32) -> u64 {
    x.pow(n)
}

let mut x = x.lock().unwrap();
*x = f(x);

let x: HashSet<T> = HashSet::new();

fn compose<'a, A, B, C, G, F>(f: F, g: G) -> Box<Fn(A) -> C + 'a>
	where F: 'a + Fn(A) -> B, G: 'a + Fn(B) -> C
{
	Box::new(move |x| g(f(x)))
}

fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x| g(f(x))
}

fn compose<'a, A, B, C, G, F>(f: F, g: G) -> Box<Fn(A) -> C + 'a>
	where F: 'a + Fn(A) -> B, G: 'a + Fn(B) -> C
{
	Box::new(move |x| g(f(x)))
}

fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x| g(f(x))
}

fn add(a: u32, b: u32) -> u32 {
    a + b
}

let add5 = move |x| add(5, x);
 

let t = s.graphemes(true).skip(i).take(j - i).collect::<String>();

let t = s.substring(i, j);

let ok = s.contains(word);

let t = s.chars().rev().collect::<String>();

let t: String = s.chars().rev().collect();

'outer: for va in &a {
    for vb in &b {
        if va == vb {
            continue 'outer;
        }
    }
    println!("{}", va);
}

'outer: for v in m {
    'inner: for i in v {
        if i < 0 {
            println!("Found {}", i);
            break 'outer;
        }
    }
}

s.insert(i, x);

thread::sleep(time::Duration::from_secs(5));

let t = s.char_indices().nth(5).map_or(s, |(i, _)| &s[..i]);

let t = s.chars().take(5).collect::<String>();

let last5ch = s.chars().count() - 5;
let t: String = s.chars().skip(last5ch).collect();

let s = "line 1
line 2
line 3";

let s = r#"Huey
Dewey
Louie"#;

let chunks: Vec<_> = s.split_whitespace().collect();

let chunks: Vec<_> = s.split_ascii_whitespace().collect();

let chunks: Vec<_> = s.split(' ').collect();

loop {
	// Do something
}

m.contains_key(&k)

let does_contain = m.values().any(|&val| *val == v);

let y = x.join(", ");

x.iter().sum()

let s = x.iter().sum::<i32>();

let s = i.to_string();

let s = format!("{}", i);

let threads: Vec<_> = (0..1000).map(|i| thread::spawn(move || f(i))).collect();

for t in threads {
	t.join();
}

let y: Vec<_> = x.iter().filter(p).collect();

let mut file = File::open(f)?;
let mut lines = String::new();
file.read_to_string(&mut lines)?;

let lines = fs::read_to_string(f).expect("Can't read file.");

eprintln!("{} is negative", x);

let first_arg = env::args().skip(1).next();

let fallback = "".to_owned();
let x = first_arg.unwrap_or(fallback);

let x = env::args().nth(1).unwrap_or("".to_string());

let d = time::now();

let d = SystemTime::now();

let i = x.find(y);

let x2 = x.replace(&y, &z);

let a = 3.to_bigint().unwrap();
let x = num::pow(a, 247);

let s = format!("{:.1}%", 100.0 * x);

let z = num::pow(x, n);

fn binom(n: u64, k: u64) -> BigInt {
    let mut res = BigInt::one();
    for i in 0..k {
        res = (res * (n - i).to_bigint().unwrap()) /
              (i + 1).to_bigint().unwrap();
    }
    res
}

let mut x = vec![false; n];

let s = 32;
let mut rng = StdRng::seed_from_u64(s);

let d = SystemTime::now()
    .duration_since(SystemTime::UNIX_EPOCH)
    .expect("Duration since UNIX_EPOCH failed");
let mut rng = StdRng::seed_from_u64(d.as_secs());

println!("{}", env::args().skip(1).collect::<Vec<_>>().join(" "));

println!("{}", std::env::args().skip(1).format(" "));

fn fact<Parent: std::str::FromStr>(str: String, _: Parent) -> Parent where <Parent as FromStr>::Err: Debug 
{
    return str.parse::<Parent>().unwrap();
}

let x = a.gcd(&b);

let x = a.lcm(&b);

let s = format!("{:b}", x);

let s = format!("{x:b}");

let mut x = Complex::new(-2, 3);
x *= Complex::i();

loop {
    doStuff();
    if !c { break; }
}

while {
   doStuff();
   c
} { /* EMPTY */ }

let y = x as f64;

let y = x as i32;

let y = x.round() as i64;

let c = s.matches(t).count();

let r = Regex::new(r"htt+p").unwrap();

let c = i.count_ones();

fn adding_will_overflow(x: usize, y: usize) -> bool {
    x.checked_add(y).is_none()
}

fn multiply_will_overflow(x: i64, y: i64) -> bool {
    x.checked_mul(y).is_none()
}

std::process::exit(0);

let buf: Vec<u8> = Vec::with_capacity(1000000);

enum CustomError { InvalidAnswer }

fn do_stuff(x: i32) -> Result<i32, CustomError> {
    if x != 42 {
        Err(CustomError::InvalidAnswer)
    } else {
        Ok(x)
    }
}

struct Foo {
    x: usize
}

impl Foo {
    pub fn new(x: usize) -> Self {
        Foo { x }
    }

    pub fn x<'a>(&'a self) -> &'a usize {
        &self.x
    }

    pub fn bar(&mut self) {
        self.x += 1;
    }
}

let x = ::serde_json::from_reader(File::open("data.json")?)?;

::serde_json::to_writer(&File::create("data.json")?, &x)?

fn control(f: impl Fn()) {
    f();
}

fn type_of<T>(_: &T) -> &'static str {
    std::intrinsics::type_name::<T>()
}

println!("{}", type_of(&x));

let x = fs::metadata(path)?.len();

let x = path.metadata()?.len();

let b = s.starts_with(prefix);

let b = s.ends_with(suffix);

let d = NaiveDateTime::from_timestamp(ts, 0);

Utc::today().format("%Y-%m-%d")

let format = format_description!("[year]-[month]-[day]");
let x = d.format(&format).expect("Failed to format the date");

items.sort_by(c);

let client = Client::new();
let s = client.get(u).send().and_then(|res| res.text())?;

let s = ureq::get(u).call().into_string()?;

let mut response = reqwest::blocking::get(u)?;
let mut s = String::new();
response.read_to_string(&mut s)?;

let client = Client::new();
match client.get(&u).send() {
    Ok(res) => {
        let file = File::create("result.txt")?;
        ::std::io::copy(res, file)?;
    },
    Err(e) => eprintln!("failed to send request: {}", e),
};

fn get_exec_name() -> Option<String> {
    std::env::current_exe()
        .ok()
        .and_then(|pb| pb.file_name().map(|s| s.to_os_string()))
        .and_then(|s| s.into_string().ok())
}

fn main() -> () {
    let s = get_exec_name().unwrap();
    println!("{}", s);
}

let s = std::env::current_exe()
    .expect("Can't get the exec path")
    .file_name()
    .expect("Can't get the exec name")
    .to_string_lossy()
    .into_owned();

let dir = env::current_dir().unwrap();

let dir = std::env::current_exe()?
    .canonicalize()
    .expect("the current exe should exist")
    .parent()
    .expect("the current exe should be a file")
    .to_string_lossy()
    .to_owned();

let n = ::std::mem::size_of::<T>();

let blank = s.trim().is_empty();

let blank = s.chars().all(|c| c.is_whitespace());

let output = Command::new("x")
    .args(&["a", "b"])
    .spawn()
    .expect("failed to execute process");

let output = Command::new("x")
        .args(&["a", "b"])
        .output()
        .expect("failed to execute process");

let output = Command::new("x")
        .args(&["a", "b"])
        .status()
        .expect("failed to execute process");

for (k, x) in mymap {
    println!("({}, {})", k, x);
}

for (k, x) in mymap.iter().sorted_by_key(|x| x.1) {
	println!("[{},{}]", k, x);
}

let mut items: Vec<_> = mymap.iter().collect();
items.sort_by_key(|item| item.1);
for (k, x) in items {
    println!("[{},{}]", k, x);
}

let b = x == y;

let b = d1 < d2;

s2 = s1.replace(w, "");

let s2 = str::replace(s1, w, "");

let n = x.len();

let y: HashSet<_> = x.into_iter().collect();

x.sort();
x.dedup();

let dedup: Vec<_> = x.iter().unique().collect();

fn get_input() -> String {
    let mut buffer = String::new();
    std::io::stdin().read_line(&mut buffer).expect("Failed");
    buffer
}

let n = get_input().trim().parse::<i64>().unwrap();

let mut input = String::new();
io::stdin().read_line(&mut input).unwrap();
let n: i32 = input.trim().parse().unwrap();

let n: i32 = std::io::stdin()
    .lock()
    .lines()
    .next()
    .expect("stdin should be available")
    .expect("couldn't read from stdin")
    .trim()
    .parse()
    .expect("input was not an integer");

let n: i32 = read!();

let mut b = [0 as u8; 1024];
let sock = UdpSocket::bind(("localhost", p)).unwrap();
sock.recv_from(&mut b).unwrap();

enum Suit {
    Spades,
    Hearts,
    Diamonds,
    Clubs,
}

assert!(is_consistent);

a.binary_search(&x).unwrap_or(-1);

let start = Instant::now();
foo();
let duration = start.elapsed();
println!("{}", duration);

fn foo() -> (String, bool) {
    (String::from("bar"), true)
}

fn main() {
    include!("foobody.txt");
}

struct Tree<V> {
    children: Vec<Tree<V>>,
    value: V
}

impl<V> Tree<V> {
    fn bfs(&self, f: impl Fn(&V)) {
        let mut q = VecDeque::new();
        q.push_back(self);

        while let Some(t) = q.pop_front() {
            (f)(&t.value);
            for child in &t.children {
                q.push_back(child);
            }
        }
    }
}

struct Vertex<V> {
	value: V,
	neighbours: Vec<Weak<RefCell<Vertex<V>>>>,
}

// ...

fn bft(start: Rc<RefCell<Vertex<V>>>, f: impl Fn(&V)) {
	let mut q = vec![start];
	let mut i = 0;
	while i < q.len() {
	    let v = Rc::clone(&q[i]);
	    i += 1;
	    (f)(&v.borrow().value);
	    for n in &v.borrow().neighbours {
	        let n = n.upgrade().expect("Invalid neighbour");
	        if q.iter().all(|v| v.as_ptr() != n.as_ptr()) {
	            q.push(n);
	        }
	    }
	}
}

struct Vertex<V> {
	value: V,
	neighbours: Vec<Weak<RefCell<Vertex<V>>>>,
}

// ...

fn dft_helper(start: Rc<RefCell<Vertex<V>>>, f: &impl Fn(&V), s: &mut Vec<*const Vertex<V>>) {
	s.push(start.as_ptr());
	(f)(&start.borrow().value);
	for n in &start.borrow().neighbours {
		let n = n.upgrade().expect("Invalid neighbor");
		if s.iter().all(|&p| p != n.as_ptr()) {
			Self::dft_helper(n, f, s);
		}
	}
}

if c1 { f1() } else if c2 { f2() } else if c3 { f3() }

match true {
    _ if c1 => f1(),
    _ if c2 => f2(),
    _ if c3 => f3(),
    _ => (),
}

let start = Instant::now();
f();
let duration = start.elapsed();

let re = Regex::new(&format!("(?i){}", regex::escape(word))).unwrap();
let ok = re.is_match(&s);

let re =
    RegexBuilder::new(&regex::escape(word))
    .case_insensitive(true)
    .build().unwrap();

let ok = re.is_match(s);

let ok = s.to_ascii_lowercase().contains(&word.to_ascii_lowercase());

let items = vec![a, b, c];

if let Some(i) = items.first(&x) {
    items.remove(i);
}

items = items.into_iter().filter(|&item| item != x).collect();

items.retain(|&item| item != x);

let chars_are_numeric: Vec<bool> = s.chars()
				.map(|c|c.is_numeric())
				.collect();
let b = !chars_are_numeric.contains(&false);

let b = s.chars().all(char::is_numeric);

let b = s.bytes().all(|c| c.is_ascii_digit());

let temp_dir = TempDir::new("prefix")?;
let temp_file = File::open(temp_dir.path().join("file_name"))?;

let tmp = TempDir::new("prefix")?;

m.remove(&k);

for i in item1.iter().chain(item2.iter()) {
    print!("{} ", i);
}

let s = format!("{:X}", x);

for pair in izip!(&items1, &items2) {
    println!("{}", pair.0);
    println!("{}", pair.1);
}

let b = std::path::Path::new(fp).exists();

eprintln!("[{}] {}", humantime::format_rfc3339_seconds(std::time::SystemTime::now()), msg);

let f = s.parse::<f32>().unwrap();

let f: f32 = s.parse().unwrap();