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);

pub fn shuffle<T>(vec: &mut [T]) {
    let n = vec.len();
    for i in 0..(n - 1) {
        let j = rand() % (n - i) + i;
        vec.swap(i, j);
    }
}

pub fn rand() -> usize {
    RandomState::new().build_hasher().finish() as usize
}

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 {
        depthFirstTraverse(left, f);
    }
    
    f(bt);
    
    if let Some(right) = &mut bt.right {
        depthFirstTraverse(right, f);
    }
}

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 mut iter = s.grapheme_indices(true);
let i_idx = iter.nth(i).map(|x|x.0).unwrap_or(0);
let j_idx = iter.nth(j-i).map(|x|x.0).unwrap_or(0);
let t = s[i_idx..j_idx];

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 = "a̐éö̲\r\n";
let t = s.grapheme_indices(true).rev().nth(5).map_or(s, |(i,_)|&s[i..]);

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 x = fs::metadata(path)?.st_size();

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.iter().position(|item| *item == 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();

let t = s.replace(|c: char| !c.is_ascii(), "");

let t = s.chars().filter(|c| c.is_ascii()).collect::<String>();

let mut string = String::new();
io::stdin().read_to_string(&mut string)?;
let result = string
    .lines()
    .map(i32::from_str)
    .collect::<Result<Vec<_>, _>>();

if p.ends_with('/') { p.pop(); }

let p = if ::std::path::is_separator(p.chars().last().unwrap()) {
    &p[0..p.len()-1]
} else {
    p
};

p = p.strip_suffix(std::path::is_separator).unwrap_or(p);

let s = c.to_string();

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

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

"Too long for text box, see online demo"

let r = fs::remove_file(filepath);

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

const PLANET: &str = "Earth";

let mut rng = &mut rand::thread_rng();
let y = x.choose_multiple(&mut rng, k).cloned().collect::<Vec<_>>();

struct Trie {
    val: String,
    nodes: Vec<Trie>
}

match std::mem::size_of::<&char>() {
    4 => f32(),
    8 => f64(),
    _ => {}
}

#[cfg(target_pointer_width = "64")]
f64();

#[cfg(target_pointer_width = "32")]
f32();	

let elements = elements.into_iter().map(|x| c * x).collect::<Vec<_>>();

elements.iter_mut().for_each(|x| *x *= c);

if let Some(arg) = ::std::env::args().nth(1) {
    if &arg == "f" {
        fox();
    } else if &arg = "b" {
        bat();
    } else {
	eprintln!("invalid argument: {}", arg),
    }
} else {
    eprintln!("missing argument");
}

if let Some(arg) = ::std::env::args().nth(1) {
    match arg.as_str() {
        "f" => fox(),
        "b" => box(),
        _ => eprintln!("invalid argument: {}", arg),
    };
} else {
    eprintln!("missing argument");
}

for pair in list.chunks(2) {
    println!("({}, {})", pair[0], pair[1]);
}

webbrowser::open(s).expect("failed to open URL");

let x = items[items.len()-1];

let x = items.last().unwrap();

let ab = [a, b].concat();

let t = s.trim_start_matches(p);

let t = if s.starts_with(p) { &s[p.len()..] } else { s };

let t = s.strip_prefix(p).unwrap_or(s);

let t = s.trim_end_matches(w);

let t = s.strip_suffix(w).unwrap_or(s);

let n = s.chars().count();

let n = mymap.len();

s.push(x);

m.insert(k, v);

println!("{}", 1000.separated_string());

let client = reqwest::blocking::Client::new();
let mut response = client.post(u).body("abc").send()?;

let s = a.encode_hex::<String>();

let mut s = String::with_capacity(2 * n);
for byte in a {
    write!(s, "{:02X}", byte)?;
}

let s = HEXLOWER.encode(&a);

fn byte_to_hex(byte: u8) -> (u8, u8) {
    static HEX_LUT: [u8; 16] = [b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c', b'd', b'e', b'f'];

    let upper = HEX_LUT[(byte >> 4) as usize];
    let lower = HEX_LUT[(byte & 0xF) as usize];
    (lower, upper)
}

let utf8_bytes: Vec<u8> = a.iter().copied().flat_map(|byte| {
        let (lower, upper) = byte_to_hex(byte);
        [upper, lower]
    }).collect();
let s = unsafe { String::from_utf8_unchecked(utf8_bytes) };

let a: Vec<u8> = Vec::from_hex(s).expect("Invalid Hex String");

let a: Vec<u8> = decode(s).expect("Hex string should be valid");

let a: Vec<u8> = HEXLOWER_PERMISSIVE.decode(&s.into_bytes()).unwrap();

let d = Path::new("/path/to/D");
let l: Vec<PathBuf> = d
    .read_dir()?
    .filter_map(|f| f.ok())
    .filter(|f| match f.path().extension() {
        None => false,
        Some(ex) => ex == "jpg" || ex == "jpeg" || ex == "png"
    })
    .map(|f| f.path())
    .collect();

struct Rect {
    x1: i32,
    x2: i32,
    y1: i32,
    y2: i32,
}

impl Rect {
    fn contains(&self, x: i32, y: i32) -> bool {
        return self.x1 < x && x < self.x2 && self.y1 < y && y < self.y2;
    }
}

struct Rectangle {
    x1: f64,
    y1: f64,
    x2: f64,
    y2: f64,
}

impl Rectangle {
    pub fn center(&self) -> (f64, f64) {
	    ((self.x1 + self.x2) / 2.0, (self.y1 + self.y2) / 2.0)
    }
}

let x = std::fs::read_dir(d).unwrap();

let x = std::fs::read_dir(d)?.collect::<Result<Vec<_>, _>>()?;

fn main() {
    let x = "fn main() {\n    let x = ";
    let y = "print!(\"{}{:?};\n    let y = {:?};\n    {}\", x, x, y, y)\n}\n";
    print!("{}{:?};
    let y = {:?};
    {}", x, x, y, y)
}

fn main(){print!("{},{0:?})}}","fn main(){print!(\"{},{0:?})}}\"")}

let t = chrono::Utc::now().date().succ().to_string();

sleep(Duration::new(30, 0));
f(42);

exit(0);

let c = a.dot(&b);

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

extern "C" {
    /// # Safety
    ///
    /// `a` must point to an array of at least size 10
    fn foo(a: *mut libc::c_double, n: libc::c_int);
}

let mut a = [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0];
let n = 10;
unsafe {
    foo(a.as_mut_ptr(), n);
}

if a.iter().any(|&elem| elem > x) {
    f()
}

let a = Decimal::from_str("1234567890.123456789012345").unwrap();

let a = DMatrix::<u8>::from_fn(n, m, |_, _| rand::thread_rng().gen());
let b = a.transpose();

fn foo(a: Vec<Vec<usize>>) {
    println!(
        "Length of array: {}",
        a.clone()
            .into_iter()
            .flatten()
            .collect::<Vec<usize>>()
            .len()
    );

    let mut sum = 0;
    for (i, j) in izip!(&a[0], &a[1]) {
        sum += i * j
    }

    println!("Sum of all products of indices: {}", sum);
}

fn foo(el: &mut i32) {
    *el = 42;
}
a.iter_mut().take(m).step_by(2).for_each(foo);

let lines = BufReader::new(File::open(path).unwrap())
	.lines()
	.collect::<Vec<_>>();

process::exit(x);

let pos = f.stream_position()?;
f.set_len(pos)?;

fn hypot(x:f64, y:f64)-> f64 {
    let num = x.powi(2) + y.powi(2);
    num.powf(0.5)
}

let h = x.hypot(y);

fn euclidean(data: Vec<f64>) -> f64 {
    let mut n = 0.0;
    for i in data {
        n += i*i;
    }
    return sqrt(n as f64)
}
let n = euclidean(data);

let s = data.iter().map(|x| x.powi(2)).sum::<f32>();

let sum: f64 = data.iter().sum();
let m = sum / (data.len() as f64);
let sum_of_squares: f64 = data.iter().map(|item| (item - m) * (item - m)).sum();
let s = (sum_of_squares / (list.len() as f64)).sqrt();

let sign = if a < 0.0 { a = -a; -1 } else { 1 };
let exponent = (a + f64::EPSILON).log2().ceil() as i32;
let fraction = a / 2.0f64.powi(exponent);

let foo = match env::var("FOO") {
    Ok(val) => val,
    Err(_e) => "none".to_string(),
};

let foo = env::var("FOO").unwrap_or("none".to_string());

let foo = match env::var("FOO") {
    Ok(val) => val,
    Err(_e) => "none".to_string(),
};

if let Ok(tnt_root) = env::var("TNT_ROOT") {
     //
}

match str {
    "foo" => foo(),
    "bar" => bar(),
    "baz" => baz(),
    "barfl" => barfl(),
    _ => {}
}

let a = vec![0; n];

for i in 0..a.len() {
    a[i] = e * (a[i] + b[i] * c[i] + d[i].cos());
}

struct T {
	s: String,
	n: Vec<usize>,
}

fn main() {
	let v = T {
		s: "Hello, world!".into(),
		n: vec![1,4,9,16,25]
	};
}

fs::create_dir(path)?;

fs::create_dir_all(path)?;

let b: bool = Path::new(path).is_dir();

for x in strings
    .iter()
    .combinations(2)
    .filter(|x| x[0].to_lowercase() == x[1].to_lowercase())
{
    println!("{:?} == {:?}", x[0], x[1])
}

let out = s.pad_to_width_with_char(m, c);

if let Some(columns_short) = m.checked_sub(s.width()) {
    let padding_width = c
        .width()
        .filter(|n| *n > 0)
        .expect("padding character should be visible");
    // Saturate the columns_short
    let padding_needed = columns_short + padding_width - 1 / padding_width;
    let mut t = String::with_capacity(s.len() + padding_needed);
    t.extend((0..padding_needed).map(|_| c)
    t.push_str(&s);
    s = t;
}

let n = (m + s.len())/2;
s = format!("{s:X>n$}");
s = format!("{out:X<m$}");

s = s.pad(m, c, Alignment::Middle, true);

let path = std::path::Path::new(_name);
let file = std::fs::File::create(&path).unwrap();
let mut zip = zip::ZipWriter::new(file); zip.start_file("readme.txt", FileOptions::default())?;                                                          
zip.write_all(b"Hello, World!\n")?;
zip.finish()?;

fn zip(_name: &str, _list: Vec<&str>) -> zip::result::ZipResult<()>
{
    let path = std::path::Path::new(_name);
    let file = std::fs::File::create(&path).unwrap();
    let mut zip = zip::ZipWriter::new(file);
    for i in _list.iter() {
        zip.start_file(i as &str, FileOptions::default())?;
    }
    zip.finish()?;
    Ok(())
}

let unique_a = a.iter().collect::<HashSet<_>>();
let unique_b = b.iter().collect::<HashSet<_>>();

let c = unique_a.intersection(&unique_b).collect::<Vec<_>>();

let set_a: HashSet<_> = a.into_iter().collect();
let set_b: HashSet<_> = b.into_iter().collect();
let c = set_a.intersection(&set_b);

let re = Regex::new(r"\s+").unwrap();
let t = re.replace_all(s, " ");

let t = (2.5, "hello", -1);

let t: String = s.chars().filter(|c| c.is_digit(10)).collect();

let opt_i = items.iter().position(|y| *y == x);


let i = match opt_i {
   Some(index) => index as i32,
   None => -1
};

let i = items.iter().position(|y| *y == x).map_or(-1, |n| n as i32);

let mut found = false;
for item in items {
    if item == &"baz" {
        println!("found it");
        found = true;
        break;
    }
}
if !found {
    println!("never found it");
}

if let None = items.iter().find(|&&item| item == "rockstar programmer") {
        println!("NotFound");
    };

items
    .iter()
    .find(|&&item| item == "rockstar programmer")
    .or_else(|| {
        println!("NotFound");
        Some(&"rockstar programmer")
    });

if 'search: loop {
    for i in items {
        if i == &"qux" {
            println!("found it");
            break 'search false;
        }
    }
    break 'search true
} {
    println!("not found!");
}

'label: {
	for &item in items {
		if item == "baz" {
			println!("found");
			break 'label;
		}
	}
	println!("not found");
}

items.push_front(x);

fn f(x: Option<()>) {
    match x {
        Some(x) => println!("Present {}", x),
        None => println!("Not present"),
    }
}

items.pop();

let y = x.clone();

fs::copy(src, dst).unwrap();

timeout(Duration::from_secs(5), p()).await;

let b = std::str::from_utf8(&bytes).is_ok();

let matches = App::new("My Program")
                .arg(Arg::with_name("verbose")
                    .short("v")
                    .takes_value(false))
                .get_matches();
                   
if matches.is_present("verbose") {
    println!("verbose is true")
} else {
    println!("verbose is false")
}

let s = base64::encode(data);