Hand-picked snippets across TypeScript, Python, Rust, Go, and more — each one comes with a line-by-line breakdown so you can read it like the people who wrote it.
Iterators in Rust are lazy and powerful. 'filter' and 'map' allow for functional-style data transformation without unnecessary intermediate allocations.
let numbers = vec![1, 2, 3, 4, 5];let doubled_evens: Vec<i32> = numbers.iter().filter(|&x| x % 2 == 0).map(|x| x * 2).collect();
Generic bounds allow you to restrict a generic type so that it must implement specific behaviors (traits). This ensures the function can call the required methods safely.
trait Summary {fn summarize(&self) -> String;}fn notify<T: Summary>(item: &T) {println!("Breaking news: {}", item.summarize());}
Rust enums are algebraic data types. They can store different types of data in each variant, which can be elegantly extracted using 'match'.
enum WebEvent {PageLoad,KeyPress(char),Click { x: i64, y: i64 },}fn inspect(event: WebEvent) {match event {WebEvent::PageLoad => println!("page loaded"),WebEvent::KeyPress(c) => println!("pressed '{}'", c),WebEvent::Click { x, y } => println!("clicked at {}, {}", x, y),}}
The '?' operator is a concise way to handle errors. If a Result is an Err, it returns early from the function with that error; otherwise, it unwraps the Ok value.
use std::fs::File;use std::io::{self, Read};fn read_username() -> Result<String, io::Error> {let mut f = File::open("hello.txt")?;let mut s = String::new();f.read_to_string(&mut s)?;Ok(s)}
Lifetimes ensure that references remain valid as long as they are needed. Annotating a struct with '<'a>' tells the compiler the struct cannot outlive the reference it holds.
struct Excerpt<'a> {part: &'a str,}fn main() {let text = String::from("Rust is fast.");let first_word = Excerpt { part: &text[0..4] };}
Arc (Atomic Reference Counted) allows multiple threads to own the same data, while Mutex (Mutual Exclusion) ensures that only one thread can mutate the data at a time.
use std::sync::{Arc, Mutex};use std::thread;let counter = Arc::new(Mutex::new(0));let mut handles = vec![];for _ in 0..10 {let counter = Arc::clone(&counter);let handle = thread::spawn(move || {let mut num = counter.lock().unwrap();*num += 1;});handles.push(handle);}for handle in handles { handle.join().unwrap(); }
Raw pointers (*const T and *mut T) allow you to bypass Rust's ownership and borrowing rules. Dereferencing them is considered unsafe because the compiler cannot guarantee the pointer is valid or that it doesn't violate memory safety.
let mut num = 5;let r1 = &num as *const i32;let r2 = &mut num as *mut i32;unsafe {println!("r1 is: {}", *r1);*r2 = 10;println!("num is now: {}", num);}
The Entry API allows you to check for a key's existence and perform an operation in a single step, avoiding double lookups and providing a more expressive way to handle conditional insertion.
use std::collections::HashMap;let mut scores = HashMap::new();let team = String::from("Blue");scores.entry(team).and_modify(|e| *e += 10).or_insert(50);println!("{:?}", scores);
