rustbites

316. checked_duration_since — Your Deadline Passed, and Instant Subtraction Said Zero

Thu, 13 Aug 2026 17:00:00 +0100

This morning’s bite 315 said Instant has no Result to handle. True — but its subtraction hides a different trap: past a deadline, deadline - now is silently 0, and your retry loop spins forever with a zero timeout.

315. SystemTime::duration_since — NTP Set the Clock Back, and elapsed().unwrap() Panicked

Thu, 13 Aug 2026 09:00:00 +0100

You timed a job with SystemTime and it ran fine for weeks — until NTP stepped the clock backwards and that innocent .elapsed().unwrap() took the service down.

314. Duration::mul_f64 — timeout * 1.5 Doesn't Compile, So You Round-Tripped Through Floats

Wed, 12 Aug 2026 17:00:00 +0100

Duration * 2 compiles, Duration * 1.5 doesn’t — and the usual workaround tears the duration apart into an f64 just to build it back up again.

313. div_duration_f64 — Your Progress Bar Sat at 0% Because as_secs() Truncated First

Wed, 12 Aug 2026 09:00:00 +0100

Dividing two Durations with as_secs() is integer division — 1.5s of 60s truncates to 0, and your progress bar never moves.

312. Duration::saturating_sub — Your Timeout Budget Ran Out, and the Subtraction Panicked

Tue, 11 Aug 2026 17:00:00 +0100

Duration - Duration panics on underflow — and budget - elapsed underflows the moment a slow operation blows the budget.

311. Duration::try_from_secs_f64 — Your Backoff Math Went Negative, and from_secs_f64 Panicked

Tue, 11 Aug 2026 09:00:00 +0100

Duration::from_secs_f64 panics on negative, NaN, or overflowing input — exactly the values float math produces when a jittered backoff dips below zero.

310. f64::max — The Fold That Quietly Swallows NaN

Mon, 10 Aug 2026 17:00:00 +0100

f64::NAN.max(3.0) is 3.0. A running max over data with a NaN in it returns a perfectly clean-looking number — and the is_nan check downstream swears nothing went wrong.

309. classify — x > 0.0 Passed, Then 1.0 / x Returned inf

Mon, 10 Aug 2026 09:00:00 +0100

Between zero and the smallest “real” float lives a twilight zone of subnormals — values that pass your > 0.0 guard but blow up the moment you divide by them.

308. sin_cos — One Angle, Both Halves, No Swap Bug

Sun, 09 Aug 2026 17:00:00 +0100

Every rotation, polar conversion, and circle you draw needs sin and cos of the same angle — and every codebase has one spot where x got the sin and y got the cos.

307. to_degrees / to_radians — Stop Hand-Typing 180.0 / PI

Sun, 09 Aug 2026 09:00:00 +0100

sin wants radians, your users want degrees, and somewhere in your codebase a hand-typed * 180.0 / PI is waiting to be fat-fingered. The conversion has been a method on floats since Rust 1.0.

306. powi — Integer Powers Without the powf Detour

Sat, 08 Aug 2026 17:00:00 +0100

x * x * x doesn’t scale, and powf(3.0) routes an integer exponent through the full floating-point pow machinery. powi is the method built for exactly this case.

305. to_bits — Hash and Dedup Floats Without a Wrapper Crate

Sat, 08 Aug 2026 09:00:00 +0100

HashSet<f64> doesn’t compile — floats aren’t Hash or Eq. f64::to_bits turns each float into its exact u64 bit pattern, which is both.

304. trunc & fract — Split a Float Without the Cast Round-Trip

Fri, 07 Aug 2026 17:00:00 +0100

Need the whole and fractional parts of a float? The (x as i64) as f64 round-trip works — until the value doesn’t fit in an i64. trunc and fract split the float directly.

303. round_ties_even — round() Pushes Every Half Up, and Your Totals Drift

Fri, 07 Aug 2026 09:00:00 +0100

round() sends every .5 away from zero — so summing rounded values drifts upward. round_ties_even rounds ties to the even neighbor and the bias cancels out.

302. cbrt — powf(1.0/3.0) Says the Cube Root of -27 Is NaN

Thu, 06 Aug 2026 17:00:00 +0100

Every negative number has a real cube root — -27 is just -3. But (-27.0).powf(1.0 / 3.0) returns NaN. cbrt is the method that actually knows what a cube root is.

301. ln_1p / exp_m1 — Adding 1.0 Destroys Your Tiny Float Before ln Ever Runs

Thu, 06 Aug 2026 09:00:00 +0100

(1.0 + x).ln() looks innocent, but for tiny x the 1.0 + step rounds away most of x’s digits before ln even sees them. ln_1p and exp_m1 do the + 1 internally, where nothing is lost.

300. atan2 — The Angle Formula That Knows Its Quadrant

Wed, 05 Aug 2026 17:00:00 +0100

(dy / dx).atan() happily returns an angle — in the wrong quadrant half the time, and NaN at the origin. atan2 takes both components and gets every case right.

299. hypot — The Distance Formula That Doesn't Overflow

Wed, 05 Aug 2026 09:00:00 +0100

(dx*dx + dy*dy).sqrt() looks harmless — until the squares overflow to infinity even though the answer would fit in an f64 just fine. hypot computes the same distance without ever squaring your inputs.

298. copysign — Stamp One Number's Sign Onto Another, Sign Bit and All

Tue, 04 Aug 2026 17:00:00 +0100

Bite 297 showed signum reading the sign bit. copysign is the other half: it writes one — take this magnitude, give it that number’s sign, one call.

297. signum — The -1 / 0 / +1 You Keep Building With an If-Else Ladder

Tue, 04 Aug 2026 09:00:00 +0100

Every “which direction?” check ends up as the same three-branch ladder: greater, less, equal. signum is that ladder as one method call — with a float twist you need to know about.

296. [T; N]::each_ref — Map Over an Array Without Giving It Away

Mon, 03 Aug 2026 09:00:00 +0100

arr.map(f) consumes the array — one call and your data is gone. each_ref() turns [T; N] into [&T; N], so you can map over borrows and keep the original.

295. String::leak — A &'static str From Runtime Data, Without the Box Detour

Sat, 01 Aug 2026 17:00:00 +0100

An API demands &'static str, but your string is built at runtime. The old trick was Box::leak(s.into_boxed_str()) — since 1.72, String::leak says what you mean.

294. AssertUnwindSafe — catch_unwind Won't Touch Your &mut Until You Sign the Waiver

Sat, 01 Aug 2026 09:00:00 +0100

You wrapped the job loop in catch_unwind (bite 291), added a completed-counter — and the build broke: the type `&mut i32` may not be safely transferred across an unwind boundary. AssertUnwindSafe is how you tell the compiler you’ve thought it through.

293. thread::panicking — A Second Panic in Drop Doesn't Unwind, It Aborts

Fri, 31 Jul 2026 17:00:00 +0100

Your Drop impl asserts a cleanup invariant. A test fails, unwinding starts, your destructor runs — and its assert fails too. Two panics at once: the process aborts and the original error message is gone.

292. panic::set_hook — You Caught the Panic, but It Still Screamed to stderr

Fri, 31 Jul 2026 09:00:00 +0100

catch_unwind gave you a tidy Err — yet the full “thread panicked at …” message hit stderr anyway. std::panic::set_hook owns that output.

291. catch_unwind — One Panicking Job Shouldn't Kill the Whole Worker

Thu, 30 Jul 2026 17:00:00 +0100

Job 2 panics and your worker thread dies with it — jobs 3 through 400 never run. std::panic::catch_unwind stops the panic at a boundary you choose.

290. Mutex::clear_poison — One Panicked Thread Shouldn't Poison the Lock Forever

Thu, 30 Jul 2026 09:00:00 +0100

A worker panics while holding the lock, and from then on every lock() in your program returns Err. If the data is still consistent, you can undo the poisoning instead of apologizing at every call site.

289. JoinHandle::is_finished — Check on a Worker Without Blocking on join()

Wed, 29 Jul 2026 17:00:00 +0100

join() tells you when a thread is done — by blocking until it is. Sometimes you just want to peek: still running, or can I collect the result now?

288. std::sync::Barrier — Make All Threads Start Phase 2 Together

Wed, 29 Jul 2026 09:00:00 +0100

Your workers finish phase 1 at different speeds, and the fast ones charge into phase 2 while the slow ones are still writing. The hand-rolled fix is an atomic counter and a spin loop — std already ships the real thing.

287. thread::Builder — Name Your Workers So Panics Tell You Who Died

Tue, 28 Jul 2026 17:00:00 +0100

thread '<unnamed>' panicked — great, which of the eight workers was that? thread::spawn has a configurable sibling, and the two minutes it costs pay off the first time something crashes.

286. available_parallelism — Stop Hardcoding Your Worker Count

Tue, 28 Jul 2026 09:00:00 +0100

That let workers = 8; in your thread pool is wrong on almost every machine but yours. std can tell you how many threads the program can actually run at once — no crate needed.

285. try_iter — The Drain Loop You Wrote This Morning, as One Line

Mon, 27 Jul 2026 17:00:00 +0100

That match-on-try_recv drain loop from bite 284? The standard library already wrote it for you: try_iter yields every pending message and stops the moment the channel is empty.

284. try_recv — Poll the Channel Without Stalling the Loop

Mon, 27 Jul 2026 09:00:00 +0100

Your render loop can’t afford to block on recv() — but it still needs to pick up messages. try_recv checks the channel and returns immediately, message or not.

283. recv_timeout — Wait for a Message, But Not Forever

Sun, 26 Jul 2026 17:00:00 +0100

rx.recv() blocks until a message arrives — and if the producer hangs, so do you. recv_timeout puts a deadline on the wait and tells you why it ended.

282. mpsc::sync_channel — A Channel That Pushes Back When the Consumer Falls Behind

Sun, 26 Jul 2026 09:00:00 +0100

mpsc::channel() never says no: a fast producer and a slow consumer means the queue — and your memory — grows without bound. sync_channel(n) caps the queue and makes the producer wait.

281. mpsc::channel — Send Results Back Instead of Fighting Over a Mutex

Sat, 25 Jul 2026 17:00:00 +0100

Threads that only produce values don’t need shared state. A channel turns “everyone locks the accumulator” into “everyone mails in their answer.”

280. Mutex::get_mut — You Have &mut, Stop Paying for lock()

Sat, 25 Jul 2026 09:00:00 +0100

A Mutex guards against other threads — but during setup and teardown there are no other threads. If you hold &mut Mutex<T> or own it outright, the borrow checker already proves exclusive access, and you can skip the lock entirely.

279. thread::park — Block a Thread Without Dragging In a Mutex

Fri, 24 Jul 2026 17:00:00 +0100

This morning’s bite (278) needed a Mutex + Condvar pair just to make one thread wait for another. When exactly one thread sleeps and you hold its handle, thread::park does it with no lock at all.

278. Condvar::wait_while — The Wait Loop You Keep Writing (and Getting Backwards)

Fri, 24 Jul 2026 09:00:00 +0100

A Condvar can wake up for no reason at all — so every correct wait is a loop. wait_while writes that loop for you.

277. Release/Acquire — Publish Data Through a Flag, Not Just the Flag

Thu, 23 Jul 2026 17:00:00 +0100

This morning’s swap bite ended with a warning: once the winning thread writes data that other threads read, Relaxed stops being enough. Here’s the two-line fix.

276. AtomicBool::swap — Let Exactly One Thread Claim the Job

Thu, 23 Jul 2026 09:00:00 +0100

“Check the flag, then set it” has a gap where two threads both see false — and your run-once code runs twice. swap sets and reads the flag in one atomic step.

275. fetch_max — Track a High-Water Mark Without the Race

Wed, 22 Jul 2026 17:00:00 +0100

“Check if it’s bigger, then store it” is two operations — and another thread can sneak between them. fetch_max is the whole thing in one atomic call.

274. fetch_update — The CAS Loop You Keep Writing by Hand

Wed, 22 Jul 2026 09:00:00 +0100

There’s no fetch_add variant that stops at a cap, so you write a compare_exchange_weak loop by hand. fetch_update is that loop, done right, in one call.

273. remove_file — Deleting Something That Might Already Be Gone

Tue, 21 Jul 2026 17:00:00 +0100

create_dir_all (bite 272) is idempotent by design. Its deletion twins are not: remove_file and remove_dir_all fail with NotFound — and the exists() guard is the same race all over again.

272. fs::create_dir_all — mkdir -p Without the exists() Check

Tue, 21 Jul 2026 09:00:00 +0100

fs::create_dir fails if the parent is missing and fails if the directory already exists. create_dir_all handles both — recursive and idempotent in one call.

271. fs::rename — Replace a File Atomically, Never Expose a Half-Write

Mon, 20 Jul 2026 17:00:00 +0100

fs::write truncates the file before writing. Crash halfway — or get read halfway — and the world sees a torn file. fs::rename is the atomic swap that fixes it.

270. Path::try_exists — exists() Can't Tell "Missing" From "Couldn't Check"

Mon, 20 Jul 2026 09:00:00 +0100

path.exists() returns false for a file that’s missing — and for a file that’s right there behind a directory you can’t read. try_exists() finally separates the two.

269. DirEntry::file_type — Stop Paying a stat() Per Entry

Sun, 19 Jul 2026 17:00:00 +0100

Filtering read_dir entries with path.is_file() costs a full metadata lookup per entry — and quietly reports false when the check fails. DirEntry::file_type() is free on most platforms and tells you when it couldn’t answer.

268. fs::read_dir — The Filesystem Doesn't Sort for You

Sun, 19 Jul 2026 09:00:00 +0100

fs::read_dir looks like ls, but ls sorts its output and read_dir doesn’t. You get entries in whatever order the filesystem feels like — and that order changes between machines.

267. Path::file_name — rsplit('/') Hands You Empty Strings and '..'

Sat, 18 Jul 2026 17:00:00 +0100

Grabbing the last path segment with rsplit('/') returns "" for logs/ and ".." for logs/.. — two values that were never file names. Path::file_name reasons in components and returns None instead.

266. Path::extension — Splitting on '.' Breaks on .gitignore

Sat, 18 Jul 2026 09:00:00 +0100

Grabbing a file extension with split('.') works right up until it meets .gitignore — which suddenly has the “extension” gitignore. Path::extension knows the actual rules.

265. Path::strip_prefix — Compare Paths by Component, Not by Character

Fri, 17 Jul 2026 17:00:00 +0100

Checking path_str.starts_with("/srv/uploads") says yes to /srv/uploads-old too. Paths need component-wise comparison — and Path has it built in.

264. Path::join — One Absolute Path and Your Base Directory Is Gone

Fri, 17 Jul 2026 09:00:00 +0100

base.join(user_input) looks like it appends. But if the input starts with /, join silently throws your base away and returns the input alone.

263. String::replace_range — Swap a Span In Place, No Rebuild

Thu, 16 Jul 2026 17:00:00 +0100

Swapping one piece of a String by slicing and re-format!-ing rebuilds the whole thing. replace_range splices the new text straight into the buffer you already own.

262. String::insert_str — Prepend or Splice Text Without Rebuilding the String

Thu, 16 Jul 2026 09:00:00 +0100

Adding a prefix with format!("{prefix}{s}") builds a brand-new String and throws the old one away. insert_str splices the text into the buffer you already have.

261. String::retain — Delete Characters In Place, No New Allocation

Wed, 15 Jul 2026 17:00:00 +0100

Stripping characters with replace("-", "") builds a brand-new String just to throw characters away. retain deletes them in the buffer you already own.

260. str::replacen — Replace the First N Matches, Not Every Single One

Wed, 15 Jul 2026 09:00:00 +0100

replace is all-or-nothing: it rewrites every occurrence, whether you wanted that or not. replacen lets you say how many.

259. str::lines — Split Into Lines Without Dragging \r Along

Tue, 14 Jul 2026 17:00:00 +0100

split('\n') works fine — until a Windows-saved file hands you lines that all end in an invisible \r. lines() was built for exactly this.

258. split_whitespace — Split on Runs, Not on Every Single Space

Tue, 14 Jul 2026 09:00:00 +0100

split(' ') hands you empty strings for every doubled space — and silently ignores tabs. split_whitespace is what you actually meant.

257. VecDeque::rotate_left — Where the Ring Buffer Finally Pays Rent

Mon, 13 Jul 2026 17:00:00 +0100

slice::rotate_left touches every element, every time. The same call on a VecDeque moves at most half of them — often far fewer.

256. VecDeque::make_contiguous — Turn a Wrapped Ring Buffer Into One Sortable Slice

Mon, 13 Jul 2026 09:00:00 +0100

VecDeque has no .sort(), and any API that wants &[T] rejects it. The catch is the ring buffer underneath — and one call flattens it.

255. rotate_left / rotate_right — Bit Rotation Without the Shift-Overflow Trap

Sun, 12 Jul 2026 17:00:00 +0100

Shifting throws bits away. The manual “wrap them around” idiom panics on n == 0. Rotation has been one method call the whole time.

254. isolate_lowest_one — The x & x.wrapping_neg() Hack Finally Has a Name

Sun, 12 Jul 2026 09:00:00 +0100

Every bitmask codebase has an unexplained x & x.wrapping_neg() in it somewhere. Rust 1.97 gives the trick a name — and a sibling for the other end.

253. overflowing_add — Wrap, But Know It Happened

Sat, 11 Jul 2026 17:00:00 +0100

This morning’s Wrapping<T> (bite 252) wraps silently — but multiword arithmetic needs the carry bit too. overflowing_add returns both: the wrapped result and whether it wrapped.

252. Wrapping — Modular Arithmetic Without the .wrapping_add() Noise

Sat, 11 Jul 2026 09:00:00 +0100

Hash functions, checksums, and PRNGs want arithmetic mod 2^n — but writing .wrapping_mul() on every single operation buries the math. std::num::Wrapping<T> puts the semantics in the type so you can use plain operators again.

251. include_str! — Ship the File Inside the Binary, Skip the Runtime Read

Fri, 10 Jul 2026 17:00:00 +0100

A missing template or SQL file in the deploy takes your app down at startup. include_str! bakes the file into the binary at compile time — a missing file becomes a compile error, not a production incident.

250. lowest_one / highest_one — Set-Bit Positions as an Option, Not a Sentinel

Thu, 09 Jul 2026 17:00:00 +0100

trailing_zeros() on 0 returns the type’s width — a sentinel you must remember to special-case. Rust 1.97 adds lowest_one and highest_one, which return an Option and make “no bits set” impossible to forget.

249. bit_width — How Many Bits Does This Number Need? (New in Rust 1.97)

Thu, 09 Jul 2026 09:00:00 +0100

“How many bits do I need for this value?” used to mean 32 - n.leading_zeros() — a formula you rewrite every time the integer type changes. Rust 1.97 — hitting stable today — ships bit_width and friends.

248. is_multiple_of — Divisibility That Won't Panic on Zero

Wed, 08 Jul 2026 17:00:00 +0100

x % y == 0 is the divisibility check everyone writes — and it panics the moment y is zero. is_multiple_of says what you mean and returns false instead of blowing up.

247. sort_unstable — Skip the Allocation When Ties Don't Matter

Wed, 08 Jul 2026 09:00:00 +0100

.sort() pays for a guarantee you usually don’t need: it allocates a scratch buffer to keep equal elements in their original order. .sort_unstable() sorts in place — no allocation, and typically faster.

246. Iterator::peekable — Look at the Next Item Without Consuming It

Tue, 07 Jul 2026 17:00:00 +0100

Sometimes you need to see the next element to decide what to do — but calling .next() eats it. .peekable() gives you a .peek() that shows the next item while leaving it in place.

245. rem_euclid — The Modulo That Never Goes Negative

Tue, 07 Jul 2026 09:00:00 +0100

-1 % 5 is -1 in Rust, not 4 — % keeps the sign of the dividend. When you want a true wrap-around index or clock value, (-1i32).rem_euclid(5) gives you the 4 you actually meant.

244. clone_from — Reuse the Buffer You Already Have Instead of Reallocating

Mon, 06 Jul 2026 17:00:00 +0100

*dst = src.clone() throws away dst’s heap buffer and allocates a brand-new one every time. dst.clone_from(&src) copies into the storage dst already owns — reusing its capacity instead of freeing and re-grabbing it.

243. slice::as_flattened — Treat a Slice of Arrays as One Flat Slice, No Copy

Mon, 06 Jul 2026 09:00:00 +0100

You’ve got a Vec<[f32; 3]> of RGB pixels and an API that wants &[f32]. The manual flatten allocates a whole second buffer. as_flattened hands you the same bytes as a flat &[f32] — zero copies, zero allocation.

242. slice::binary_search_by_key — Find a Record by One Field, No Hand-Written Comparator

Sun, 05 Jul 2026 17:00:00 +0100

Binary searching a slice of structs by one field? Don’t hand-roll a .cmp() closure and risk flipping the comparison — project the key and let the stdlib do the rest.

241. slice::split_first — Peel the Head Off a Slice, Keep the Tail, No Indexing

Sun, 05 Jul 2026 09:00:00 +0100

slice[0] panics on an empty slice, and &slice[1..] is a second chance to get the bounds wrong. split_first hands you the head and the tail together — or None if there’s nothing there — so the empty case is a pattern, not a panic.

240. to_le_bytes / from_le_bytes — Serialize Integers Without unsafe or Bit-Shifting

Sat, 04 Jul 2026 17:00:00 +0100

Packing a u32 into four bytes by hand means a stack of >> and as u8 casts — and one wrong shift silently corrupts your data. Every integer type already knows how to lay itself out, in the exact endianness you ask for.

239. Vec::drain — Remove a Range and Keep What You Pulled Out

Sat, 04 Jul 2026 09:00:00 +0100

truncate throws elements away. split_off allocates a second Vec. When you want to remove a range from a Vec and actually use those elements — and keep the rest — drain hands them to you as an iterator and shifts everything else down for you.

238. slice::chunks_exact_mut — Edit a Slice in Fixed-Size Blocks Without Index Math

Fri, 03 Jul 2026 17:00:00 +0100

Processing a buffer N elements at a time usually means a while i + N <= len loop and a pile of buf[i..i+N] slicing. chunks_exact_mut hands you each fixed-size block as a &mut [T] — no index bookkeeping, no off-by-one.

237. Iterator::eq — Compare Two Sequences Without Collecting Them First

Fri, 03 Jul 2026 09:00:00 +0100

Comparing a Vec to an array, or a filtered iterator to an expected result? You don’t need to collect() both sides into the same type first.

236. Result::flatten — Collapse a Result, E> in One Call

Thu, 02 Jul 2026 17:00:00 +0100

Ended up with a Result<Result<T, E>, E> and reached for a nested match to peel it? When both layers share the same error type, Result::flatten (stable since 1.89) does it in one call.

235. Iterator::rposition — Find the Last Match Without Reversing-and-Subtracting

Thu, 02 Jul 2026 09:00:00 +0100

Need the index of the last element that matches? The reflex is iter().rev().position(...) then len - 1 - i — and that arithmetic is a classic off-by-one. rposition searches from the back and hands you the real forward index.

234. core::range::Range — A Range That's Copy, So You Can Store and Reuse It

Wed, 01 Jul 2026 17:00:00 +0100

The classic 0..3 isn’t Copy — it is the iterator, so it gets consumed and can’t live in a Copy struct. Rust 1.96 stabilises core::range::Range, which is Copy and iterates through IntoIterator instead.

233. str::split_terminator — Split Without the Trailing Empty String

Wed, 01 Jul 2026 09:00:00 +0100

"a.b.c.".split('.') hands you a phantom empty string at the end. split_terminator reads the separator as ending each piece, not delimiting it — so the trailing one just vanishes.

232. Iterator::partition — Split Into Two Collections in One Pass

Tue, 30 Jun 2026 17:00:00 +0100

Splitting items into “matches” and “the rest” with two .filter() calls walks the list twice. partition does it in a single pass.

231. slice::chunk_by — Group Consecutive Elements Without the Index Bookkeeping

Tue, 30 Jun 2026 09:00:00 +0100

Splitting a slice into runs of equal (or related) elements usually means a manual loop with a start index and an off-by-one waiting to happen. slice::chunk_by does it in one call.

230. slice::split_at_mut — Two Mutable Halves, No unsafe, No Borrow Fight

Mon, 29 Jun 2026 17:00:00 +0100

Need a &mut to two different elements of the same slice at once? Indexing twice won’t compile — the borrow checker sees the whole slice borrowed twice. split_at_mut hands you two non-overlapping mutable halves instead.

229. char::to_digit — Turn a Digit Character Into Its Value, Not Its Byte

Mon, 29 Jun 2026 09:00:00 +0100

Reached for c as u8 - b'0' to turn '7' into 7? It works until the input isn’t a digit — then you get silent garbage. char::to_digit does it safely and handles hex too.

228. Vec::push_mut — Push and Get a &mut Back, Skip the last_mut().unwrap()

Sun, 28 Jun 2026 17:00:00 +0100

Pushed an element and immediately needed to tweak it? The old way was push then last_mut().unwrap(). Rust 1.95 added push_mut, which hands you the &mut right back.

227. trim_matches — Strip the Same Char Off Both Ends, However Many There Are

Sun, 28 Jun 2026 09:00:00 +0100

trim() only knows about whitespace, and strip_prefix peels off one occurrence. When you need to shave every leading and trailing . (or 0, or quote) off a string, reach for trim_matches.

226. unwrap_or_default — Stop Spelling Out the Empty Value

Sat, 27 Jun 2026 17:00:00 +0100

Writing .unwrap_or(0) or .unwrap_or_else(String::new) to fall back to an empty value? If the type already has a Default, unwrap_or_default says it for you.

225. Option::map_or — Transform-or-Default in One Call, Skip the match

Sat, 27 Jun 2026 09:00:00 +0100

Reaching for a four-line match just to turn an Option into a plain value? map_or does the transform and the fallback in a single call.

224. String::from_utf8_lossy — Returns a Cow, So Valid Bytes Cost Zero

Fri, 26 Jun 2026 17:00:00 +0100

from_utf8_lossy doesn’t always allocate. It hands back a Cow<str> that borrows your bytes when they’re already valid UTF-8 — you only pay for a String when there’s an invalid byte to replace.

223. count_ones — Count Set Bits Without a Loop

Fri, 26 Jun 2026 09:00:00 +0100

Need to count how many bits are set in an integer — flags in a bitmask, a population count, a Hamming weight? Don’t write a shift-and-mask loop. Every integer type has .count_ones(), and it usually lowers to a single CPU instruction.

222. HashSet::intersection / union / difference — Set Math Without the Manual Loops

Thu, 25 Jun 2026 17:00:00 +0100

Need the items two collections have in common, or the ones only in one of them? Don’t write a for loop with .contains() inside. HashSet has set algebra built in.

221. from_str_radix — Parse Hex, Binary, or Octal Without Hand-Rolling a Loop

Thu, 25 Jun 2026 09:00:00 +0100

Got a "ff" or a "1010" and need the number behind it? Don’t loop over the characters multiplying by 16. Every integer type has from_str_radix, which parses a string in any base from 2 to 36 in one call.

220. ilog10 — Count an Integer's Digits Without Formatting It to a String

Wed, 24 Jun 2026 17:00:00 +0100

Need to know how many digits a number has? Reaching for n.to_string().len() allocates a whole String just to measure it. ilog10 answers the same question with one instruction and zero allocation.

219. checked_add_signed — Move an Unsigned Index by a Signed Delta, No Cast

Wed, 24 Jun 2026 09:00:00 +0100

You have a usize index and a delta: isize that might be negative. idx + delta won’t even compile, and casting your way around it wraps silently on underflow.

218. str::match_indices — Find Every Match and Its Position in One Pass

Mon, 22 Jun 2026 17:00:00 +0100

Hand-rolling a find loop to locate every occurrence of a substring means juggling a running offset and remembering to skip past each match. match_indices hands you each hit and its byte position as an iterator — no bookkeeping.

217. eq_ignore_ascii_case — Case-Insensitive Compare Without the Allocation

Mon, 22 Jun 2026 09:00:00 +0100

a.to_lowercase() == b.to_lowercase() allocates two fresh Strings just to throw them away after the comparison. For ASCII text — headers, extensions, keywords — eq_ignore_ascii_case does it byte-by-byte with zero allocations.

216. unsigned_abs — i32::MIN Has No Positive Twin, So .abs() Overflows

Sun, 21 Jun 2026 17:00:00 +0100

(-5i32).abs() is fine, but i32::MIN.abs() panics — the magnitude 2147483648 doesn’t fit back into an i32. unsigned_abs returns the magnitude in the unsigned type, where it always fits.

215. next_multiple_of — Round Up to a Multiple Without the +m-1 Dance

Sun, 21 Jun 2026 09:00:00 +0100

Padding a length up to the next multiple of 8? The classic (n + 7) / 8 * 8 works right up until it overflows or you fat-finger the constant. next_multiple_of says exactly what you mean.

214. slice::windows — Compare Consecutive Elements Without the Index Math

Sat, 20 Jun 2026 17:00:00 +0100

The classic “look at each element and the next one” loop is a panic waiting to happen: 0..v.len() - 1 underflows the moment the slice is empty. windows hands you every consecutive pair safely, no arithmetic required.

213. abs_diff — The Gap Between Two Numbers, No Underflow, No Overflow

Sat, 20 Jun 2026 09:00:00 +0100

Subtracting two unsigned integers to get their distance is a panic waiting to happen — and the signed (a - b).abs() workaround overflows just as quietly. abs_diff gives you the gap correctly, every time.

212. slice::fill / fill_with — Reset Every Element Without the Loop

Fri, 19 Jun 2026 17:00:00 +0100

Clearing a buffer with a hand-rolled for loop is noise. slice::fill overwrites every element in one call — and fill_with builds a fresh value per slot.

211. Iterator::inspect — Debug a Lazy Chain Without Tearing It Apart

Fri, 19 Jun 2026 09:00:00 +0100

When a map/filter chain gives the wrong answer, the reflex is to rip it into a for loop just to drop in a println!. You don’t have to — inspect lets you peek at every value as it flows past.

210. next_power_of_two — Round Up to a Power of Two Without the Bit-Twiddling

Thu, 18 Jun 2026 17:00:00 +0100

Sizing a buffer or hash table to the next power of two is a classic — and people keep reinventing it with shifts and leading_zeros. The standard library already has it.

209. ..Default::default() — set the fields you care about, default the rest

Thu, 18 Jun 2026 09:00:00 +0100

Building a struct with a dozen fields when you only want to change one is tedious. Struct update syntax lets you fill in the rest from a default — or from any other value.

208. f64::mul_add — One Rounding, One Instruction, Better Accuracy

Wed, 17 Jun 2026 17:00:00 +0100

a * b + c rounds twice and may compile to two separate operations. a.mul_add(b, c) computes the whole thing at full precision, rounds once, and on a CPU with FMA folds into a single instruction.

207. if let Guards — Match a Pattern Inside a Guard, and Still Fall Through

Wed, 17 Jun 2026 09:00:00 +0100

A match arm whose extra check is itself a fallible if let used to force you to nest a second match — and duplicate the fallback. Rust 1.95 lets the guard do the binding.

206. trim_ascii — Trim Whitespace From &[u8] Without Going Through str

Tue, 16 Jun 2026 17:00:00 +0100

Got a &[u8] with leading or trailing whitespace? You don’t need to validate it as UTF-8 just to trim it.

205. strip_prefix / strip_suffix — Remove a Prefix Once, Not Every Repeat

Tue, 16 Jun 2026 09:00:00 +0100

Reaching for trim_start_matches to peel off a "--" or a leading slash? It strips every repeated match and silently does nothing when there’s no match. strip_prefix removes exactly one and tells you whether it hit.

204. take_while / skip_while — Act on the Leading Run, Not Every Match

Mon, 15 Jun 2026 17:00:00 +0100

Reaching for .filter() to drop leading blank lines? It’ll drop the blank lines in the middle too. take_while and skip_while work on the leading run and stop the moment the predicate flips.

203. Peekable::next_if_map — Consume a Token Only If It Parses, Transform in One Step

Mon, 15 Jun 2026 09:00:00 +0100

next_if only answers yes/no, so when you also need the converted value you end up peeking, computing, and calling next() by hand. Rust 1.94 stabilized Peekable::next_if_map — conditionally consume the next item and transform it in a single call, putting the item back if it doesn’t match.

202. Arc::clone Is a Refcount Bump, Not a Deep Copy — Share Big Data, Don't Duplicate It

Sun, 14 Jun 2026 17:00:00 +0100

big.clone() on a 50MB lookup table allocates 50MB every time a worker needs a copy. Wrap it in an Arc once and Arc::clone is just an atomic +1 on a counter — every owner reads the same bytes.

201. or_insert vs or_insert_with — Don't Build a Default You'll Throw Away

Sun, 14 Jun 2026 09:00:00 +0100

map.entry(k).or_insert(expensive()) builds expensive() on every call — even when the key is already there and the value gets dropped on the floor. Reach for or_insert_with and the default is computed only when it’s actually needed.

200. #[derive(Copy)] and #[inline] — Make Small Types Free to Pass Around

Sat, 13 Jun 2026 17:00:00 +0100

A two-field struct that you .clone() everywhere, behind a function the optimizer won’t inline across crates — that’s two small taxes you can stop paying. Copy deletes the move/drop bookkeeping, #[inline] lets the body fold into the caller.

199. Static Dispatch — Generics Beat Box When You Can Afford the Code

Sat, 13 Jun 2026 09:00:00 +0100

Box<dyn Trait> is the reflex when a function “takes something that implements a trait.” But every call through it pays for a vtable hop the compiler can’t see past. Swap it for a generic and the optimizer inlines the whole thing.

198. into_iter() to Transform — Move Owned Items Instead of cloned()

Fri, 12 Jun 2026 17:00:00 +0100

You have a Vec you’re about to throw away, and you want a transformed one. Reaching for iter().cloned() (or iter().map(|x| x.clone())) duplicates every element on the way out — but you owned them already. into_iter() moves them straight through.

197. Advance a State Machine with mem::replace — Move the Enum Out, No Clone

Fri, 12 Jun 2026 09:00:00 +0100

Transitioning an enum state behind &mut self looks impossible: you can’t move the old variant’s owned data into the new one without the borrow checker stopping you — so people reach for .clone(). mem::replace lets you move the whole state out, leaving a cheap placeholder behind.

196. Return impl Iterator, Not Vec — Let the Caller Decide What to Do

Thu, 11 Jun 2026 17:00:00 +0100

Returning a Vec from a helper allocates eagerly, every time — even when the caller only wants the first match or a running sum. Return impl Iterator instead and the allocation simply never happens unless the caller asks for it.

195. Chain Iterator Adapters — Don't collect() Between Every Step

Thu, 11 Jun 2026 09:00:00 +0100

Every collect::<Vec<_>>() in the middle of a pipeline is a heap allocation and a full pass over your data. Adapters like map and filter are lazy and fuse together — chain them and the whole transformation runs in one pass with zero temporary Vecs.

194. Reuse One Buffer with .clear() — Allocate Once, Loop Many Times

Wed, 10 Jun 2026 17:00:00 +0100

with_capacity (bite 193) buys a buffer once instead of growing it repeatedly. But if you allocate a fresh String or Vec inside a loop, you throw that buffer away every iteration. .clear() resets the length to zero while keeping the capacity — so one allocation serves the whole loop.

193. Vec::with_capacity — Size Up Front, Skip the Realloc Churn

Wed, 10 Jun 2026 09:00:00 +0100

A Vec you push into one element at a time doesn’t grow one element at a time — it doubles, copying every existing item to a fresh allocation each time it outgrows its buffer. If you already know how many items are coming, Vec::with_capacity buys the whole buffer once.

192. impl Into — Take Owned or Borrowed Without an Extra Allocation

Tue, 09 Jun 2026 17:00:00 +0100

Bite 191 said: if you only read the argument, take &str. But what if you need to store it? Taking &str and calling .to_owned() always allocates — even when the caller handed you a String it was about to throw away. impl Into<String> fixes that.

191. Accept &str, Not String — Take the Most General Borrow

Tue, 09 Jun 2026 09:00:00 +0100

A function that takes String forces every caller holding a &str to allocate just to call you. Take &str instead — and &[T] over &Vec<T> — and deref coercion lets everyone in for free.

190. Return Cow — Allocate Only When You Actually Change Something

Mon, 08 Jun 2026 17:00:00 +0100

An escaping or normalizing function usually has nothing to do — the input is already clean. Returning String forces an allocation anyway. Return Cow<str> and the common path stays a borrow.

189. str::char_indices — Slice a String Without Panicking on Non-ASCII

Mon, 08 Jun 2026 09:00:00 +0100

chars().enumerate() hands you a character count, but &s[..] wants a byte offset. Mix them up and one accented letter blows your program apart.

188. LazyLock::from — Skip the Closure When You Already Have the Value

Sun, 07 Jun 2026 17:00:00 +0100

Sometimes your “lazy” value isn’t lazy at all — a test or a CLI flag hands it to you up front. Rust 1.96 stabilized From<T> for LazyLock<T>, so you can build an already-initialized lock straight from the value.

187. fmt::Write — Stop Allocating a Temp String Just to Append It

Sun, 07 Jun 2026 09:00:00 +0100

out.push_str(&format!("{name}: {score}")) builds a brand-new String, copies it into out, then throws it away — every single iteration. One use std::fmt::Write; and write! formats straight into your buffer instead.

186. str::split_inclusive — Split a String and Keep the Separator With Each Chunk

Sat, 06 Jun 2026 17:00:00 +0100

"a\nb\n".split('\n') swallows every newline and hands you a phantom "" at the end. split_inclusive keeps each separator glued to the chunk it belongs to — no ghost element, and you can .concat() straight back to the original.

185. Range — Iterate NonZero Integers Without Re-Wrapping Every Step

Sat, 06 Jun 2026 09:00:00 +0100

NonZeroU32 keeps Option<Id> at 4 bytes — but until Rust 1.96 you couldn’t iterate lo..hi over them. You’d drop back to u32 and re-wrap every step.

184. Option::take — The Ergonomic Sibling of mem::take, Just for Option

Fri, 05 Jun 2026 17:00:00 +0100

You’ve got an Option<T> behind &mut self and you need the T out. mem::take works, but the field is already an Option — .take() reads better and does the same job.

183. std::mem::take — Move Out of &mut self Without the Clone

Fri, 05 Jun 2026 09:00:00 +0100

You need the Vec out of &mut self, the borrow checker says no, so you .clone() it. Don’t. mem::take swaps in the default and hands you the original — zero allocation.

182. Path::with_extension — Swap a File Extension Without Slicing Strings

Thu, 04 Jun 2026 17:00:00 +0100

You have report.txt and want report.md. Reaching for replace(".txt", ".md") or a rfind('.')? Stop — Path::with_extension returns a fresh PathBuf with the extension swapped, and it gets every edge case right.

181. Option::get_or_insert_with — Lazy Default That Returns &mut

Thu, 04 Jun 2026 09:00:00 +0100

You have an Option<Vec<T>> field and want to push to it. If it’s None, allocate first; if it’s Some, just push. get_or_insert_with does both in one call — and hands you back a &mut so you can use it on the same line.

180. Option::unzip — Split an Optional Pair Into a Pair of Options

Wed, 03 Jun 2026 17:00:00 +0100

When you have an Option<(A, B)> but the rest of your code wants (Option<A>, Option<B>), the obvious move is two map calls. Option::unzip does both halves in a single call.

179. Iterator::max_by_key — Find the Best Element Without a Manual Fold

Wed, 03 Jun 2026 09:00:00 +0100

Finding the “best” item in a collection — longest string, heaviest order, latest timestamp — is one of those tasks where a hand-rolled fold keeps showing up. Iterator::max_by_key does the same job in one call, and min_by_key is right there next to it.

178. Ord::clamp — Stop Writing min(max, max(min, x))

Tue, 02 Jun 2026 17:00:00 +0100

Bounding a value between two limits is one of those tiny operations where everyone hand-rolls a confusing nest of min/max calls. Ord::clamp is the single-call version, and it works on anything that’s Ord or PartialOrd — not just numbers.

177. BTreeMap::range — Iterate a Sorted Map by Key Range

Tue, 02 Jun 2026 09:00:00 +0100

You have a sorted map keyed by time, port number, or version, and you want every entry between two keys. Filtering on iter() walks the whole map — BTreeMap::range walks just the slice you asked for.

176. Option::as_deref — Stop Writing .as_ref().map(|s| s.as_str())

Mon, 01 Jun 2026 17:00:00 +0100

You have an Option<String>. The function next door takes Option<&str>. The chain you keep typing — .as_ref().map(|s| s.as_str()) — has a one-method replacement.

175. PathBuf::push — When an Absolute Argument Wipes Your Base Path

Mon, 01 Jun 2026 09:00:00 +0100

base.push(user_input) looks like string concatenation for paths. It isn’t — if user_input is absolute, the original base is gone.

174. iter::repeat_with — Build N Fresh Things When vec![] Won't Clone

Sun, 31 May 2026 17:00:00 +0100

vec![Mutex::new(0); 10] — won’t compile. Mutex isn’t Clone. iter::repeat_with(|| Mutex::new(0)).take(10).collect() builds ten fresh ones instead.

173. NonZeroU32 and Friends — Encode an Invariant and Shrink Option for Free

Sun, 31 May 2026 09:00:00 +0100

Option<u32> is 8 bytes. Option<NonZeroU32> is 4 bytes. Same information, half the size — and the compiler enforces “this can’t be zero” for you.

172. #[track_caller] — Point the Panic at the Caller, Not Your Helper

Sat, 30 May 2026 17:00:00 +0100

You wrap an assert in a helper to clean up your tests. Now every failure points at the helper’s source line instead of the test that called it. #[track_caller] fixes that with a single line of code.

171. assert_matches! — A Test Failure That Actually Tells You What Went Wrong

Sat, 30 May 2026 09:00:00 +0100

assert!(matches!(x, Foo::Bar)) panics with assertion failed: matches!(x, Foo::Bar) and zero hint about what x actually was. Rust 1.96 stabilises assert_matches!, which prints the offending value for you.

170. Ordering::then_with — Chain Comparators for Multi-Key Sorts

Fri, 29 May 2026 17:00:00 +0100

Sorting by name, then by age, then by id ends in a nested if a == b { ... } ladder. Ordering::then_with flattens the whole thing into one expression.

169. File::create_new — Atomic 'Create Only If It Doesn't Exist'

Fri, 29 May 2026 09:00:00 +0100

You want to write a config file, a lockfile, or a “did we run yet” sentinel — but only if it isn’t already there. The if path.exists() { … } else { File::create(path) } pattern looks fine until two processes hit it at the same time. There’s a one-line fix sitting in std::fs.

168. collect::, _>>() — Bail an Iterator on the First Error

Thu, 28 May 2026 17:00:00 +0100

You have a Vec<&str> of numbers to parse and you want to bail the moment one of them is malformed. The hand-rolled loop with ? works, but collect() does the same thing in one line — and most people never realize the trick is in the turbofish.

167. Saturating — Stop Calling .saturating_add() Everywhere

Thu, 28 May 2026 09:00:00 +0100

When every step in a loop or formula could overflow, calling .saturating_add() and .saturating_sub() on each one turns one line of math into a paragraph.

166. Entry::and_modify — Update If Present, Insert If Not, in One Chain

Wed, 27 May 2026 17:00:00 +0100

*map.entry(k).or_insert(0) += 1 is the classic Rust counter. The moment the “first time” branch needs to look different from the “next time” branch, that pattern stops fitting — and and_modify slots in.

165. PhantomData — The Zero-Sized Marker That Pretends to Own a T

Wed, 27 May 2026 09:00:00 +0100

You write a generic struct, never actually store a T in any field, and the compiler stops you with “parameter T is never used”. PhantomData<T> is the zero-cost lie that fixes it — a marker that occupies no bytes but tells the compiler “act as if I own a T.”

162. Pin
— The Pointer Type That Says 'This Won't Move'

Tue, 26 May 2026 17:00:00 +0100

Self-referential structs are the obvious “this should work but doesn’t” pattern in Rust: a struct that holds a buffer plus a reference into that buffer falls apart the moment it moves and the reference dangles. Pin<P> is the type that says “the pointee is fixed in memory” — and is the reason every async fn future you’ve ever .awaited can keep a pointer to its own local variables.

164. Pin projection — How to actually use the fields behind Pin<&mut Self>

Tue, 26 May 2026 17:00:00 +0100

The moment you hand-roll Future::poll, you have a Pin<&mut Self> and a question Rust won’t answer for you: how do I touch my fields? self.inner doesn’t compile, &mut self.inner is what Pin exists to prevent, and the answer — pin projection — is one of those idioms everyone reinvents until they reach for pin-project-lite.

163. Cow::to_mut — Lazy In-Place Mutation Through Cow

Tue, 26 May 2026 09:00:00 +0100

Cow<str> is the type everyone reaches for when a function might need to modify its input. Cow::Borrowed and Cow::Owned are the constructors that get the spotlight; to_mut is the third piece, and it’s the one that actually pays off the laziness.

161. Weak — The Non-Owning Pointer That Breaks Rc Cycles

Mon, 25 May 2026 09:00:00 +0100

Rc<T> is a counter, not a tracing GC: two Rcs pointing at each other will sit in memory forever, each propping the other’s strong-count above zero. Weak<T> is the cure — a pointer that observes an Rc’s allocation without keeping it alive.

160. Arc — Atomic Reference Counting for Threads, Plus Mutex and RwLock

Sun, 24 May 2026 17:00:00 +0100

Rc<T> gave us shared ownership inside one thread. The moment you thread::spawn it, the compiler refuses. Arc<T> is the same shape with an atomic counter: same clone-the-pointer ergonomics, but Send + Sync and safe to share between threads — and the building block under almost every concurrent pattern in Rust.

159. Rc — Single-Threaded Shared Ownership

Sun, 24 May 2026 09:00:00 +0100

The borrow checker’s one-owner rule is a feature until you’re modeling a graph, a cache, or any structure where “who owns this?” honestly has more than one answer. Rc<T> is the escape hatch: a reference-counted pointer that lets multiple owners share the same heap allocation, single-threaded, no locking, no overhead beyond a counter increment.

158. OnceLock and LazyLock — The std Replacements for lazy_static!

Sat, 23 May 2026 17:00:00 +0100

This morning’s Atomic* handled “many threads, one scalar.” For “many threads, one value — computed once, then read forever” the std answer is two types: LazyLock<T, F> when you can name the initializer up front, OnceLock<T> when you only learn the value at runtime. Both make the old lazy_static! macro and the once_cell crate redundant.

157. Atomic* — The Thread-Safe Cell for Scalars

Sat, 23 May 2026 09:00:00 +0100

A Cell<T> lets a single thread mutate through &self — get/set instead of &mut. The atomic types in std::sync::atomic are the same shape, just Sync: a counter, flag, or pointer many threads can poke at without a Mutex, no lock acquisition, no guard, no panic on contention.

156. RwLock — Many Readers OR One Writer, When Reads Dominate

Fri, 22 May 2026 17:00:00 +0100

This morning’s Mutex<T> treats every caller the same: one at a time, no matter what they’re doing. If ninety-nine of them only want to read, that’s ninety-nine threads serialized behind a lock they didn’t need. RwLock<T> splits the door in two — many readers OR one writer — so read-heavy workloads actually fan out.

155. Mutex — Cross-Thread Exclusive Access, With a Guard Instead of a Panic

Fri, 22 May 2026 09:00:00 +0100

Yesterday’s RefCell<T> gives you &mut through &self on a single thread — and panics the moment a second borrow shows up. Mutex<T> is the same idea wearing a hard hat: it’s Sync, so it works across threads, and instead of panicking on contention it just blocks until the other holder is done.

154. UnsafeCell — The Primitive Every Interior-Mutability Type Is Built On

Thu, 21 May 2026 17:00:00 +0100

This morning’s OnceCell / LazyCell bite — and Cell, RefCell, Mutex, RwLock, OnceLock, every atomic — all bottom out at the same type: UnsafeCell<T>. It is the one and only legal way in Rust to mutate through a shared reference. You’ll almost never type its name, but knowing what it does explains why all the rest exist.

153. OnceCell — Memoize Through &self Without Wrapping in RefCell

Thu, 21 May 2026 09:00:00 +0100

You have a parse(&self) -> &Heavy accessor that needs to compute once and cache. &self rules out a plain field assignment. Cell needs Copy. RefCell won’t lend the inside out past .borrow(). OnceCell<T> is the missing piece — write-once, &self API, hands back a real &T that lives as long as the cell.

152. RefCell — When You Need to Actually Borrow the Inside

Wed, 20 May 2026 17:00:00 +0100

This morning’s Cell<T> only lets you swap whole values in and out. The moment you want to call .push() on the Vec inside, or hand out a &str slice of the String inside, you need a real &mut — and that’s exactly what RefCell<T> gives you, just with the aliasing rules checked at runtime instead of compile time.

151. Cell — Interior Mutability Without the Borrow Checker Drama

Wed, 20 May 2026 09:00:00 +0100

You hand the same struct to two closures and both want to bump a counter. &mut fights you, RefCell introduces runtime borrow checks you don’t need — Cell<T> quietly mutates through a shared & reference, with zero overhead, as long as you only ever swap whole values in and out.

150. Vec::spare_capacity_mut — Fill a Vec From a Callback Without Zeroing It First

Tue, 19 May 2026 17:00:00 +0100

You reserve 4 KiB to read from a socket, and to hand the buffer over you first… write 4096 zeros. Vec::spare_capacity_mut exposes the reserved-but-uninitialized tail as &mut [MaybeUninit<u8>] so the callback writes straight into the allocation.

149. OnceLock::wait — Block a Thread Until Another One Initializes the Value

Tue, 19 May 2026 08:00:00 +0100

You have one thread loading a config and a handful of workers that can’t start until it’s ready. OnceLock::wait blocks until the value lands — no Condvar, no Mutex, no spin loop.

148. Result::is_ok_and — Test the Variant and the Value in One Call

Mon, 18 May 2026 17:00:00 +0100

Checking “is this Ok, and is the inner value positive?” usually means a match or an if let. Result::is_ok_and collapses both questions into one line.

146. char::MAX_LEN_UTF8 — Size UTF-8 Buffers Without Magic Numbers

Mon, 18 May 2026 09:00:00 +0100

Every time you’ve called char::encode_utf8, you’ve written [0u8; 4] from memory. Rust 1.93 stabilises char::MAX_LEN_UTF8 so you don’t have to keep that magic number in your head.

147. Cell::as_array_of_cells — Mutate One Slot of a Cell-Wrapped Array

Mon, 18 May 2026 09:00:00 +0100

You have a Cell<[i32; 4]> and you want to bump element [2]. cell.get(), mutate the copy, cell.set(...) the whole thing back — for one slot? Cell::as_array_of_cells hands you &[Cell<i32>; 4] so each slot is its own little Cell.

143. Vec::dedup_by_key — Collapse Consecutive Duplicates by a Derived Key

Sun, 17 May 2026 17:00:00 +0100

Vec::dedup() only collapses runs that are exactly equal. When you care about a derived attribute — the minute on a timestamp, the domain in an email, the first letter of a word — reach for dedup_by_key.

145. Duration::from_nanos_u128 — Round-Trip Nanoseconds Without the u64 Cast

Sun, 17 May 2026 17:00:00 +0100

Duration::as_nanos() hands you a u128. Duration::from_nanos() takes a u64. You feed one into the other and the compiler yells at you — or worse, you cast and quietly truncate at 584 years. Rust 1.93 closed the loop with from_nanos_u128.

144. Vec::into_raw_parts — Hand a Vec to C Without the ManuallyDrop Dance

Sun, 17 May 2026 09:00:00 +0100

You want to give a Rust-allocated buffer to C and re-take it later. That means handing over (ptr, len, capacity) — and historically, prying those three out of a Vec without freeing the allocation meant wrapping the vector in ManuallyDrop first. Rust 1.93 stabilises Vec::into_raw_parts, a single safe call that returns the triple and consumes the Vec for you.

142. Path::absolute — Make a Path Absolute Without Touching the Filesystem

Sat, 16 May 2026 09:00:00 +0100

Need an absolute path for a log line, an error message, or a “files will land here” preview — but the file might not exist yet? fs::canonicalize will refuse. std::path::absolute (stable since Rust 1.79) gives you the absolute form without ever opening the disk.

141. BinaryHeap::into_sorted_vec — Heapsort in One Call

Fri, 15 May 2026 17:00:00 +0100

You stuffed everything into a BinaryHeap to keep “biggest first” cheap, but at the end of the day you want a sorted Vec to hand to the next stage. The pop-loop you almost wrote is built into the type — into_sorted_vec consumes the heap and gives you the ascending-order Vec for free.

140. slice::as_array — Lock a Slice Into a Fixed-Size Array Reference

Fri, 15 May 2026 09:00:00 +0100

A function hands you &[u8] but the next step wants &[u8; 32]. The old answer was <&[u8; 32]>::try_from(slice) — a turbofish-and-trait dance for what is really just a length check. Rust 1.93 stabilises slice::as_array, the method-call version that does exactly that.

139. HashMap::extract_if — Drain Matching Entries Without Losing Them

Thu, 14 May 2026 17:00:00 +0100

HashMap::retain discards what it removes. When you actually want those values — to log them, ship them, or move them elsewhere — you used to clone the keys and double-walk the map. extract_if, stable since Rust 1.88, hands them back as an iterator.

138. iter::zip — Parallel Iteration Without the Method-Chain Dance

Thu, 14 May 2026 09:00:00 +0100

a.iter().zip(b.iter()) makes one collection the star and the other an awkward sidekick. std::iter::zip puts them on equal footing — two arguments, same indent, no method-chain twist.

137. Vec::retain_mut — Filter and Edit In Place, In One Pass

Wed, 13 May 2026 17:00:00 +0100

retain decides who stays, but its closure only sees &T — so when you also want to tweak the survivors, you end up making two passes. retain_mut collapses that into one.

136. LazyLock::force_mut — Mutate a Lazy Value Without Wrapping It in a Mutex

Wed, 13 May 2026 09:00:00 +0100

Got a LazyLock you own outright? With force_mut (stable in Rust 1.94), you can initialize and mutate it through &mut LazyLock — no Mutex, no RwLock, no locking dance.

135. str::strip_prefix — Trim a Prefix Without Slicing by Hand

Tue, 12 May 2026 17:00:00 +0100

Reaching for if s.starts_with("foo") { &s[3..] } to drop a prefix? That’s an off-by-one waiting to happen — and a panic the first time someone passes in an emoji. str::strip_prefix returns Option<&str> and gets it right by construction.

134. Iterator::find_map — Find and Transform in One Pass

Tue, 12 May 2026 09:00:00 +0100

Looking for the first element that matches and needs to come back as something else? Skip the filter_map(...).next() two-step — find_map says it in one call.

133. slice::rotate_left — Cycle Elements Through a Slice Without a Second Buffer

Mon, 11 May 2026 17:00:00 +0100

Need the first few elements to wrap around to the back? slice.rotate_left(n) cycles them through in place — no scratch Vec, no clever indexing, no borrow checker drama.

132. abs_diff — Subtract Without Caring Which Side Is Bigger

Mon, 11 May 2026 08:00:00 +0100

Subtracting two unsigned integers and the smaller one comes first? Instant panic. a.abs_diff(b) returns the gap as a u* regardless of which side is bigger — no branching, no overflow.

131. mem::offset_of! — Byte Offsets Without the memoffset Crate

Sun, 10 May 2026 17:00:00 +0100

You need the byte offset of a field — for FFI, custom serialization, or talking to a C struct. The old answer was unsafe pointer arithmetic on a MaybeUninit, or pulling in the memoffset crate. std::mem::offset_of! is the safe, one-liner replacement.

129. BTreeMap::extract_if — Range-Scoped Filter-and-Remove in One Pass

Sun, 10 May 2026 09:00:00 +0100

Vec::extract_if was great. The BTreeMap version, stable since Rust 1.91, adds a trick the slice variant can’t pull off — a range bound that scopes the scan to part of the keyspace.

130. mem::discriminant — Compare Enum Variants, Ignore the Payload

Sun, 10 May 2026 09:00:00 +0100

You want to know “is this another Click?” — not whether the coordinates match. Hand-rolling a match for every variant gets old fast. std::mem::discriminant answers that question in one call.

128. slice::copy_within — Shift Bytes In-Place Without Fighting the Borrow Checker

Sat, 09 May 2026 17:00:00 +0100

You want to copy buf[2..5] over buf[0..3] — same buffer, no allocation. Reach for copy_from_slice and the borrow checker says no. copy_within is the one-call answer.

127. std::mem::swap — Trade Two Values Through Their &mut

Fri, 08 May 2026 17:00:00 +0100

The textbook let tmp = a; a = b; b = tmp; falls over the moment a and b are &mut T — you can’t move out of a reference. mem::swap is the generic, safe, two-line answer.

126. Vec::split_off — Cut a Vec in Two and Keep Both Halves

Fri, 08 May 2026 09:00:00 +0100

You want the tail of a Vec as its own owned collection — the head stays put, the tail walks away. Cloning a slice works for Clone types, but breaks the moment your elements aren’t cloneable. Vec::split_off doesn’t care.

125. RwLockWriteGuard::downgrade — Hand a Write Lock Off as a Read, Atomically

Thu, 07 May 2026 17:00:00 +0100

You took a write lock, updated the data, and now you only want to read. Dropping the write guard and re-acquiring as a reader leaves a window where another writer can slip in. downgrade closes that window.

124. Iterator::cycle — Round-Robin Without the Modulo Math

Thu, 07 May 2026 09:00:00 +0100

Round-robin assignment usually shows up as things[i % workers.len()] — fine until the index gets clever, the slice gets reordered, or the source isn’t even indexable. Iterator::cycle turns any Clone iterator into an infinite one, and the modulo dance disappears.

123. BTreeMap::pop_first — A Sorted Map That Doubles as a Priority Queue

Wed, 06 May 2026 17:00:00 +0100

BinaryHeap only goes one way — biggest first. When you want to pull the smallest or the largest from the same collection, reach for BTreeMap and let pop_first / pop_last do the work.

122. Option::filter — Keep Some Only When the Value Passes

Wed, 06 May 2026 09:00:00 +0100

You’ve got an Option<T>, but you only want to keep the Some if the value passes a test. The match-with-guard version works — Option::filter says the same thing in one call.

121. rem_euclid — The Modulo That Doesn't Go Negative

Tue, 05 May 2026 17:00:00 +0100

-1 % 7 in Rust is -1, not 6. That’s a math gotcha lurking in every wraparound index, every clock arithmetic, every “what day of the week” calculation. rem_euclid is the modulo you actually wanted.

120. OnceLock — Lazy Statics That Initialize on Your Schedule

Tue, 05 May 2026 09:00:00 +0100

LazyLock runs its initializer the first time anyone touches the value — fine when the inputs are baked in at compile time, useless when you only learn them at runtime. OnceLock is the same idea, but you decide when (and with what data) initialization happens.

119. iter::from_fn — Build a Custom Iterator Without the Struct

Mon, 04 May 2026 17:00:00 +0100

Need a custom iterator that carries a bit of state? Skip the struct plus impl Iterator boilerplate. iter::from_fn turns any closure that returns Option<T> into a real iterator.

118. [T; N]::map — Transform an Array Without Allocating a Vec

Mon, 04 May 2026 09:00:00 +0100

[1, 2, 3].iter().map(|n| n * 2).collect::<Vec<_>>() works, but you’ve thrown the length away in the type and paid for a heap allocation. Arrays have their own map — same shape in, same shape out, no Vec in sight.

117. Iterator::step_by — Every Nth Element Without filter + enumerate

Sun, 03 May 2026 17:00:00 +0100

Want every 3rd value from a series? The reflex is enumerate().filter(|(i, _)| i % 3 == 0) — three combinators, one modulo, and you’ve thrown away the indices anyway. step_by(3) does the same thing in one call.

116. Path::file_prefix — Get the Real Stem of archive.tar.gz

Sun, 03 May 2026 08:00:00 +0100

Path::file_stem strips the last extension, so archive.tar.gz comes back as archive.tar. That’s almost never what you want for double-extension files. file_prefix strips from the first dot instead — archive, finally.

115. Vec::resize_with — Grow a Vec With a Closure, Not a Clone

Sat, 02 May 2026 17:00:00 +0100

Vec::resize makes every new slot a clone of the same value. When you need fresh values per slot — counters, allocations, defaults — resize_with calls a closure for each new element instead.

114. Option::transpose — Use ? on an Optional Result

Sat, 02 May 2026 09:00:00 +0100

Got an Option<Result<T, E>> and want to ? the error out? You can’t — ? doesn’t reach inside the Option. transpose flips it to Result<Option<T>, E>, and the rest takes care of itself.

113. Arc::make_mut — Mutate Inside an Arc Without the Dance

Fri, 01 May 2026 17:00:00 +0100

You have an Arc<T>, you want a &mut T. Arc only hands out &T, so the usual workaround is clone-the-inner, mutate, rewrap. Arc::make_mut does that for you — and skips the clone when no one else is watching.

112. Iterator::scan — Fold That Yields Every Step

Fri, 01 May 2026 08:00:00 +0100

fold keeps the running state but only hands you the final answer. So you reach for a mut variable plus map, or you give up and collect first. scan is the missing middle: a fold that yields each intermediate step.

111. Vec::insert_mut — Splice In and Edit Without Reindexing

Thu, 30 Apr 2026 17:00:00 +0100

You insert a placeholder, then index back to fix it up. Two lookups, two bounds checks, one wobble. Vec::insert_mut — stable in 1.95 — hands you the &mut T directly.

110. slice::split_at_checked — Split Without the Panic

Thu, 30 Apr 2026 09:00:00 +0100

slice.split_at(i) panics the second i > len. The usual fix is a length check wrapped around the call so you don’t blow up on a bad index. split_at_checked does the same job in one call and hands you an Option.

109. BinaryHeap::peek_mut — Edit the Top Without Pop-and-Push

Wed, 29 Apr 2026 17:00:00 +0100

Updating the largest element in a BinaryHeap shouldn’t take two heap operations. peek_mut lets you mutate it in place and re-heapifies on drop — one sift instead of two.

108. Iterator::max_by_key — Find the Biggest Without Sorting the Whole Thing

Wed, 29 Apr 2026 09:00:00 +0100

Need the longest string in a Vec? Don’t sort the whole list to grab the last element — max_by_key walks once, allocates nothing, and returns it directly.

107. Vec::splice — Replace a Range and Keep the Old Values

Tue, 28 Apr 2026 17:00:00 +0100

Need to swap a chunk of a Vec for a different number of items? Most people reach for drain plus extend and a bunch of bookkeeping. Vec::splice does the whole thing in one call — and even hands back what it removed.

106. Iterator::by_ref — Take Part of an Iterator and Keep the Rest

Tue, 28 Apr 2026 08:00:00 +0100

Called iter.take(n).collect() and watched the borrow checker swallow the whole iterator? by_ref lets you consume a chunk and keep iterating from where you stopped.

105. Vec::extend_from_within — Duplicate a Range Without Fighting the Borrow Checker

Mon, 27 Apr 2026 17:00:00 +0100

Trying to copy a slice of a Vec back onto the end of itself? v.extend_from_slice(&v[..k]) won’t compile — &v and &mut v collide. extend_from_within is the one-call answer.

103. bool::then_some — Turn a Condition Into an Option Without an if

Mon, 27 Apr 2026 08:00:00 +0100

Writing if condition { Some(value) } else { None } for the hundredth time? bool::then_some collapses that whole pattern into a single chainable call.

104. Vec::swap_remove — O(1) Removal When Order Doesn't Matter

Sun, 26 Apr 2026 17:00:00 +0100

Calling Vec::remove(i) shifts every element after i left by one — that’s O(n) per call. If you don’t care about order, swap_remove does the same job in O(1).

102. slice::partition_point — Binary Search That Just Returns the Index

Sat, 25 Apr 2026 09:00:00 +0100

Reaching for binary_search on a sorted Vec and unwrapping Ok(i) | Err(i) because you only ever wanted the index? slice::partition_point skips the Result ceremony and hands you the position directly.

101. f64::total_cmp — Sort Floats Without the NaN Panic

Fri, 24 Apr 2026 17:00:00 +0100

Tried v.sort() on a Vec<f64> and hit the trait Ord is not implemented for f64? Then reached for .sort_by(|a, b| a.partial_cmp(b).unwrap()) and now a stray NaN is about to panic your service at 3am? f64::total_cmp is the one-liner that makes both problems disappear.

100. std::cmp::Reverse — Sort Descending Without Writing a Closure

Fri, 24 Apr 2026 09:00:00 +0100

Want to sort a Vec in descending order? The old trick is v.sort_by(|a, b| b.cmp(a)), and every time you write it you flip a and b and pray you got it right. std::cmp::Reverse is a one-word replacement.

99. std::mem::replace — Swap a Value and Keep the Old One

Thu, 23 Apr 2026 17:00:00 +0100

mem::take is great until your type doesn’t have a sensible Default. That’s where mem::replace steps in — you pick what gets left behind, and you still get the old value out of a &mut.

98. sort_by_cached_key — Stop Recomputing Expensive Sort Keys

Thu, 23 Apr 2026 08:00:00 +0100

sort_by_key sounds like it computes the key once per element. It doesn’t — it calls your closure at every comparison, so an n-element sort can pay for that key O(n log n) times. If the key is expensive, sort_by_cached_key is the fix you’ve been looking for.

97. Option::take_if — Take the Value Out Only When You Want To

Wed, 22 Apr 2026 17:00:00 +0100

You want to pull a value out of an Option — but only if it meets some condition. Before take_if, that little sentence turned into a five-line dance with as_ref, is_some_and, and a separate take(). Now it’s one call.

96. Result::inspect_err — Log Errors Without Breaking the ? Chain

Wed, 22 Apr 2026 08:00:00 +0100

You want to log an error but still bubble it up with ?. The usual trick is .map_err with a closure that sneaks in a eprintln! and returns the error unchanged. Result::inspect_err does that for you — and reads like what you meant.

95. LazyLock::get — Peek at a Lazy Value Without Initializing It

Tue, 21 Apr 2026 17:00:00 +0100

Wanted to know whether a LazyLock has been initialized yet — without causing the initialization by touching it? Rust 1.94 stabilises LazyLock::get and LazyCell::get, which return Option<&T> and leave the closure untouched if it hasn’t fired.

94. ControlFlow::is_break and is_continue — Ask the Flow Which Way It Went

Tue, 21 Apr 2026 09:00:00 +0100

Got a ControlFlow back from try_fold or a visitor and just want to know which variant you’re holding? Before 1.95 you either pattern-matched or reached for matches!. Rust 1.95 adds straightforward .is_break() and .is_continue() methods.

93. MaybeUninit Array Conversions — Build Fixed Arrays Without transmute

Mon, 20 Apr 2026 17:00:00 +0100

Ever tried to build a [T; N] element-by-element and ended up reaching for mem::transmute because [MaybeUninit<T>; N] refused to convert? Rust 1.95 stabilises safe conversions between [MaybeUninit<T>; N] and MaybeUninit<[T; N]> — no transmute, no tricks.

92. core::range — Range Types You Can Actually Copy

Mon, 20 Apr 2026 09:00:00 +0100

Ever tried to reuse a 0..=10 range and hit “use of moved value”? Rust 1.95 stabilises core::range, a new module of range types that implement Copy.

91. bool::try_from — Convert Integers to Booleans Safely

Sun, 19 Apr 2026 17:00:00 +0100

Need to turn a 0 or 1 from a database, config file, or FFI boundary into a bool? bool::try_from does it safely — rejecting anything that isn’t 0 or 1. Stabilized in Rust 1.95.

90. black_box — Stop the Compiler From Erasing Your Benchmarks

Sun, 19 Apr 2026 09:00:00 +0100

Your benchmark ran in 0 nanoseconds? Congratulations — the compiler optimised away the code you were trying to measure. std::hint::black_box prevents that by hiding values from the optimiser.

89. cold_path — Tell the Compiler Which Branch Won't Happen

Sat, 18 Apr 2026 17:00:00 +0100

Your error-handling branch fires once in a million calls, but the compiler doesn’t know that. core::hint::cold_path lets you mark unlikely branches so the optimiser can focus on the hot path.

88. Vec::push_mut — Push and Modify in One Step

Sat, 18 Apr 2026 08:00:00 +0100

Tired of pushing a default into a Vec and then grabbing a mutable reference to fill it in? Rust 1.95 stabilises push_mut, which returns &mut T to the element it just inserted.

87. Atomic update — Kill the Compare-and-Swap Loop

Fri, 17 Apr 2026 17:00:00 +0100

Every Rust developer who’s written lock-free code has written the same compare_exchange loop. Rust 1.95 finally gives atomics an update method that does it for you.

86. cfg_select! — Compile-Time Match on Platform and Features

Fri, 17 Apr 2026 09:00:00 +0100

Stop stacking #[cfg] blocks that contradict each other — cfg_select! gives you a match-like syntax for conditional compilation, right in the standard library.

85. cast_signed & cast_unsigned — Explicit Sign Casting for Integers

Thu, 16 Apr 2026 17:00:00 +0100

Stop using as to flip between signed and unsigned integers — cast_signed() and cast_unsigned() say exactly what you mean.

84. Result::flatten — Unwrap Nested Results in One Call

Thu, 16 Apr 2026 08:00:00 +0100

You have a Result<Result<T, E>, E> and just want the inner Result<T, E>. Before Rust 1.89, that meant a clunky and_then(|r| r). Now there’s Result::flatten.

83. Arc::unwrap_or_clone — Take Ownership Without the Dance

Wed, 15 Apr 2026 17:00:00 +0100

You need to own a T but all you have is an Arc<T>. The old pattern is a six-line fumble with try_unwrap. Arc::unwrap_or_clone collapses it into one call — and skips the clone entirely when it can.

82. isqrt — Integer Square Root Without Floating Point

Wed, 15 Apr 2026 09:00:00 +0100

(n as f64).sqrt() as u64 is the classic hack — and it silently gives the wrong answer for large values. Rust 1.84 stabilized isqrt on every integer type: exact, float-free, no precision traps.

81. checked_sub_signed — Subtract a Signed Delta From an Unsigned Without Casts

Tue, 14 Apr 2026 17:00:00 +0100

checked_add_signed has been around for years. Its missing sibling finally landed: as of Rust 1.91, u64::checked_sub_signed (and the whole {checked, overflowing, saturating, wrapping}_sub_signed family) lets you subtract an i64 from a u64 without casting, unsafe, or hand-rolled overflow checks.

80. VecDeque::pop_front_if and pop_back_if — Conditional Pops on Both Ends

Tue, 14 Apr 2026 08:00:00 +0100

Vec::pop_if got a deque-shaped sibling. As of Rust 1.93, VecDeque has pop_front_if and pop_back_if — conditional pops on either end without the peek-then-pop dance.

79. #[diagnostic::on_unimplemented] — Custom Error Messages for Your Traits

Mon, 13 Apr 2026 17:00:00 +0100

Trait errors are notoriously cryptic. #[diagnostic::on_unimplemented] lets you replace the compiler’s default “trait bound not satisfied” with a message that actually tells the user what went wrong.

78. div_ceil — Divide and Round Up Without the Overflow Bug

Mon, 13 Apr 2026 09:00:00 +0100

Need to split items into fixed-size pages or chunks? The classic (n + size - 1) / size trick silently overflows. div_ceil does it correctly.

77. repeat_n — Repeat a Value Exactly N Times

Sun, 12 Apr 2026 17:00:00 +0100

Stop writing repeat(x).take(n) — there’s a dedicated function that’s both cleaner and more efficient.

76. slice::as_chunks — Split Slices into Fixed-Size Arrays

Sun, 12 Apr 2026 08:00:00 +0100

You’re calling .chunks(4) and immediately doing chunk.try_into().unwrap() to get an array. as_chunks gives you &[[T; N]] directly — a slice of properly typed arrays, plus the remainder.

75. select_nth_unstable — Find the Kth Element Without Sorting

Sat, 11 Apr 2026 17:00:00 +0100

You’re sorting an entire Vec just to grab the median or the top 3 elements. select_nth_unstable does it in O(n) — no full sort required.

74. slice::is_sorted — Ask the Slice if It's Already Sorted

Sat, 11 Apr 2026 09:00:00 +0100

You’ve written windows(2).all(|w| w[0] <= w[1]) one too many times. The is_sorted family of methods says what you actually mean — in one call.

73. u64::midpoint — Average Two Numbers Without Overflow

Fri, 10 Apr 2026 17:00:00 +0100

Computing the average of two integers sounds trivial — until it overflows. The midpoint method gives you a correct result every time, no wider types required.

72. if let Guards — Pattern Match Inside Match Guards

Fri, 10 Apr 2026 09:00:00 +0100

Match guards are great for adding conditions to arms, but until now you couldn’t destructure inside them. Rust 1.95 stabilizes if let guards, letting you pattern-match right in the guard position.

71. Inline const Blocks — Compile-Time Evaluation Anywhere

Thu, 09 Apr 2026 17:00:00 +0100

Need a compile-time value in the middle of runtime code? Wrap it in const { } and the compiler evaluates it on the spot — no separate const item needed.

70. Iterator::intersperse — Join Elements Without Collecting First

Thu, 09 Apr 2026 09:00:00 +0100

Tired of collecting into a Vec just to call .join(",")? intersperse inserts a separator between every pair of elements — lazily, right inside the iterator chain.

69. Iterator::try_fold — Fold That Knows When to Stop

Wed, 08 Apr 2026 17:00:00 +0100

Need to accumulate values from an iterator but bail on the first error? try_fold gives you the power of fold with the early-exit behavior of ?.

68. f64::next_up — Walk the Floating Point Number Line

Wed, 08 Apr 2026 09:00:00 +0100

Ever wondered what the next representable floating point number after 1.0 is? Since Rust 1.86, f64::next_up and f64::next_down let you step through the number line one float at a time.

67. Box::leak — Turn Owned Data Into a Static Reference

Tue, 07 Apr 2026 17:00:00 +0100

Sometimes you need a &'static str but all you have is a String. Meet Box::leak — it deliberately leaks heap memory so you get a reference that lives forever.

66. Inferred Const Generics — Let the Compiler Count For You

Tue, 07 Apr 2026 08:00:00 +0100

Tired of manually counting array lengths and const generic arguments? Since Rust 1.89, you can write _ in const generic positions and let the compiler figure it out.

65. Precise Capturing — Stop impl Trait From Borrowing Too Much

Mon, 06 Apr 2026 17:00:00 +0100

Ever had the compiler refuse to let you use a value after calling a function — even though the return type shouldn’t borrow it? use<> bounds give you precise control over what impl Trait actually captures.

64. Iterator::unzip — Split Pairs into Separate Collections

Mon, 06 Apr 2026 09:00:00 +0100

Got an iterator of tuples and need two separate collections? Stop looping and pushing manually — unzip splits pairs into two collections in a single pass.

63. fmt::from_fn — Display Anything With a Closure

Sun, 05 Apr 2026 17:00:00 +0100

Need a quick Display impl without defining a whole new type? std::fmt::from_fn turns any closure into a formattable value — ad-hoc Display in one line.

62. Iterator::flat_map — Map and Flatten in One Step

Sun, 05 Apr 2026 09:00:00 +0100

Need to transform each element into multiple items and collect them all into a flat sequence? flat_map combines map and flatten into a single, expressive call.

61. Iterator::reduce — Fold Without an Initial Value

Sat, 04 Apr 2026 17:00:00 +0100

Using fold but your accumulator starts as the first element anyway? Iterator::reduce cuts out the boilerplate and handles empty iterators gracefully.

60. Iterator::partition — Split a Collection in Two

Sat, 04 Apr 2026 09:00:00 +0100

Need to split a collection into two groups based on a condition? Skip the manual loop — Iterator::partition does it in one call.

59. split_first_chunk — Destructure Slices into Arrays

Fri, 03 Apr 2026 17:00:00 +0100

Parsing a header from a byte buffer? Extracting the first N elements of a slice? split_first_chunk hands you a fixed-size array and the remainder in one call — no manual indexing, no panics.

58. Option::is_none_or — The Guard Clause You Were Missing

Fri, 03 Apr 2026 09:00:00 +0100

You know is_some_and — it checks if the Option holds a value matching a predicate. But what about “it’s fine if it’s missing, just validate it when it’s there”? That’s is_none_or.

57. New Math Constants — GOLDEN_RATIO and EULER_GAMMA in std

Thu, 02 Apr 2026 17:00:00 +0100

Tired of defining your own golden ratio or Euler-Mascheroni constant? As of Rust 1.94, std ships them out of the box — no more copy-pasting magic numbers.

56. Iterator::map_while — Take While Transforming

Thu, 02 Apr 2026 09:00:00 +0100

Need to take elements from an iterator while a condition holds and transform them at the same time? map_while does both in one step — no awkward take_while + map chains needed.

55. floor_char_boundary — Truncate Strings Without Breaking UTF-8

Wed, 01 Apr 2026 16:00:00 +0100

Ever tried to truncate a string to a byte limit and got a panic because you sliced in the middle of a multi-byte character? floor_char_boundary fixes that.

54. Cell::update — Modify Interior Values Without the Gymnastics

Wed, 01 Apr 2026 08:00:00 +0100

Tired of writing cell.set(cell.get() + 1) every time you want to tweak a Cell value? Rust 1.88 added Cell::update — one call to read, transform, and write back.

53. element_offset — Find an Element's Index by Reference

Tue, 31 Mar 2026 17:00:00 +0100

Ever had a reference to an element inside a slice but needed its index? Before Rust 1.94, you’d reach for .position() with value equality or resort to pointer math. Now there’s a cleaner way.

52. Peekable::next_if_map — Peek, Match, and Transform in One Step

Tue, 31 Mar 2026 09:00:00 +0100

Tired of peeking at the next element, checking if it matches, and then consuming and transforming it? next_if_map collapses that entire dance into a single call.

51. File::lock — File Locking in the Standard Library

Mon, 30 Mar 2026 17:00:00 +0100

Multiple processes writing to the same file? That’s a recipe for corruption. Since Rust 1.89, File::lock gives you OS-backed file locking without external crates.

50. slice::chunk_by — Group Consecutive Elements

Mon, 30 Mar 2026 09:00:00 +0100

Need to split a slice into groups of consecutive elements that share a property? chunk_by does exactly that — no allocations, no manual index tracking.

49. std::io::pipe — Anonymous Pipes in the Standard Library

Sun, 29 Mar 2026 17:00:00 +0100

Need to wire up stdout and stderr from a child process, or stream data between threads? Since Rust 1.87, std::io::pipe() gives you OS-backed anonymous pipes without reaching for external crates.

48. #[expect] — Lint Suppression That Cleans Up After Itself

Sun, 29 Mar 2026 09:00:00 +0100

Silencing a lint with #[allow] is easy — but forgetting to remove it when the code changes is even easier. #[expect] suppresses a lint and warns you when it’s no longer needed.

47. Vec::pop_if — Conditionally Pop the Last Element

Sat, 28 Mar 2026 17:00:00 +0100

Need to remove the last element of a Vec only when it meets a condition? Vec::pop_if does exactly that — no index juggling, no separate check-then-pop.

46. Let Chains — Flatten Nested if-let with &&

Sat, 28 Mar 2026 09:00:00 +0100

Deeply nested if let blocks are one of Rust’s most familiar awkward moments. Rust 1.88 (2024 edition) finally fixes it: let chains let you &&-chain multiple let bindings and boolean guards in one if or while.

45. get_disjoint_mut — Multiple Mutable References at Once

Fri, 27 Mar 2026 17:00:00 +0100

The borrow checker won’t let you hold two &mut refs into the same collection — even when you know they don’t overlap. get_disjoint_mut fixes that without unsafe.

44. split_once — Split a String Exactly Once

Fri, 27 Mar 2026 09:00:00 +0100

When you need to split a string on the first occurrence of a delimiter, split_once is cleaner than anything you’d write by hand. Stable since Rust 1.52.

43. Vec::extract_if — Remove Elements and Keep Them

Wed, 25 Mar 2026 17:00:00 +0100

Ever needed to split a Vec into two groups — the ones you keep and the ones you remove? retain discards the removed items. Now there’s a better way.

42. array::from_fn — Build Arrays from a Function

Wed, 25 Mar 2026 09:00:00 +0100

Need a fixed-size array where each element depends on its index? Skip the vec![..].try_into().unwrap() dance — std::array::from_fn builds it in place with zero allocation.

40. Scoped Threads — Borrow Across Threads Without Arc

Tue, 24 Mar 2026 09:00:00 +0100

Need to share stack data with spawned threads? std::thread::scope lets you borrow local variables across threads — no Arc, no .clone().

41. Async Closures — Pass Async Code Like Any Other Closure

Tue, 24 Mar 2026 09:00:00 +0100

Accepting an async callback used to mean a tangle of Fn(T) -> Fut where Fut: Future. Rust 1.85 stabilizes async closures — write async |x| { ... } and accept them with impl async Fn(T) -> U.

39. Trait Upcasting — Cast dyn Trait to dyn Supertrait

Mon, 23 Mar 2026 17:00:00 +0100

Since Rust 1.86, you can upcast a trait object to its supertrait — no workarounds needed.

38. #[must_use] — Never Ignore What Matters

Mon, 23 Mar 2026 09:00:00 +0100

Rust’s #[must_use] attribute turns silent bugs into compile-time warnings — making sure important return values never get accidentally ignored.

36. Cow — Clone on Write

Sun, 22 Mar 2026 09:00:00 +0100

Stop cloning strings “just in case” — Cow<str> lets you borrow when you can and clone only when you must.

37. Option::zip

Sun, 22 Mar 2026 09:00:00 +0100

Need to combine two Option values into a pair? Option::zip merges them into a single Option<(A, B)> — if either is None, you get None back.

35. LazyLock

Sat, 21 Mar 2026 17:00:00 +0100

Still pulling in lazy_static or once_cell just for a lazy global? std::sync::LazyLock does the same thing — zero dependencies.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


use std::sync::LazyLock;

static CONFIG: LazyLock<Vec<String>> = LazyLock::new(|| {
 // Imagine this reads from a file or env
 vec!["debug".to_string(), "verbose".to_string()]
});

fn main() {
 // CONFIG is initialized on first access
 println!("flags: {:?}", *CONFIG);
 assert_eq!(CONFIG.len(), 2);
}

33. std::mem::take

Sat, 21 Mar 2026 09:00:00 +0100

Ever tried to move a value out of a &mut reference? The borrow checker won’t let you — but std::mem::take will. It swaps the value out and leaves Default::default() in its place.

1
2
3
4
5
6
7


use std::mem;

let mut name = String::from("Ferris");
let taken = mem::take(&mut name);

assert_eq!(taken, "Ferris");
assert_eq!(name, ""); // left with String::default()

34. array_windows

Sat, 21 Mar 2026 09:00:00 +0100

Need to look at consecutive pairs (or triples) in a slice? Stop manually indexing — array_windows gives you fixed-size windows as arrays, not slices.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


let temps = [18.0, 21.5, 19.0, 23.0, 22.5];

// Before: manual indexing 😬
for i in 0..temps.len() - 1 {
 let diff = temps[i + 1] - temps[i];
 println!("Δ {diff:+.1}");
}

// After: array_windows ✨
for [prev, next] in temps.array_windows() {
 let diff = next - prev;
 println!("Δ {diff:+.1}");
}

32. iter::successors

Fri, 20 Mar 2026 10:00:00 +0100

Need to generate a sequence where each element depends on the previous one? std::iter::successors turns any “next from previous” logic into a lazy iterator.

1
2
3
4
5
6
7
8


use std::iter::successors;

// Powers of 10 that fit in a u32
let powers: Vec<u32> = successors(Some(1u32), |&n| n.checked_mul(10))
 .collect();

// [1, 10, 100, 1_000, 10_000, 100_000, 1_000_000, 10_000_000, 100_000_000, 1_000_000_000]
assert_eq!(powers.len(), 10);

31. HashMap's entry API

Fri, 20 Mar 2026 00:00:00 +0100

Want to insert a value into a HashMap only if the key doesn’t exist yet? Skip the double lookup — use the entry API.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


use std::collections::HashMap;

let mut scores: HashMap<&str, Vec<u32>> = HashMap::new();

// Instead of checking .contains_key() then inserting:
scores.entry("alice")
 .or_insert_with(Vec::new)
 .push(100);

scores.entry("alice")
 .or_insert_with(Vec::new)
 .push(200);

assert_eq!(scores["alice"], vec![100, 200]);

30. dbg! macro

Thu, 19 Mar 2026 17:00:00 +0100

Still using println! for quick debugging? Try dbg! instead — it prints the expression, its value, and the file/line number to stderr. And it returns the value, so you can wrap it around anything.

1
2
3
4
5
6


let a = 2;
let b = dbg!(a * 2) + 1; // prints: [src/main.rs:3] a * 2 = 4
assert_eq!(b, 5);

// works with multiple values too
dbg!(a, b, a + b); // prints each as a tuple

29. Let chains

Thu, 19 Mar 2026 10:00:00 +0100

Tired of deeply nested if let blocks? Rust 2024 edition brings let chains — chain multiple let patterns with && in a single if expression.

1
2
3
4
5
6
7
8


// Before: nested and hard to read
if let Some(a) = opt_a {
 if let Some(b) = opt_b {
 if a > 0 {
 println!("{a} + {b} = {}", a + b);
 }
 }
}

With let chains, flatten the whole thing:

1
2
3
4
5
6


if let Some(a) = opt_a
 && let Some(b) = opt_b
 && a > 0
{
 println!("{a} + {b} = {}", a + b);
}

28. Raw string

Wed, 01 Feb 2023 12:13:00 +0100

Curious to know how you can add a double quote in raw strings?

No escape sequences are recognized in raw strings, so adding a backslash does not work.

Use ### to mark the start and the end of a raw string.

1
2
3
4
5
6
7
8


println!("This is a double quote \" ");

// println!(r"This is a double quote " "); // Nope!
// println!(r"This is a double quote \" "); // Nope!

// And this works
println!(r#"This is a double quote " "#);
println!(r###"This is a double quote " "###);

Closures

Mon, 02 Jan 2023 11:33:00 +0100

Coming soon…

26. Collecting into Option

Sun, 01 Jan 2023 12:13:00 +0100

Rust’s option implements FromIterator too!

Use it when you want to get None if there is a None element and values otherwise.

1
2
3


let cars = [Some("Porsche"), Some("Ferrari"), None];
let maybe_cars: Option<Vec<_>> = cars.into_iter().collect();
assert_eq!(maybe_cars, None);

or values …

27. Option's sum/product

Sun, 01 Jan 2023 12:13:00 +0100

Rust’s option implements Sum and Product traits too!

Use it when you want to get None if there is a None element and sum of values otherwise.

1
2
3


let nums: [Option<u32>;3] = [Some(1), Some(10), None];
let maybe_nums: Option<u32> = nums.into_iter().sum();
assert_eq!(maybe_nums, None);

or sum of the values …

Implementing custom iterators

Sun, 01 Jan 2023 11:33:00 +0100

Iterators are a powerful feature in Rust that allow you to define how a collection of items should be processed. They are flexible, efficient, and easy to use. In this blog post, we will look at how to create custom iterators in Rust.

24. ..=X

Sat, 24 Dec 2022 12:13:00 +0100

As of 1.66, it is possible to use ..=X in patterns

1
2
3
4
5
6


let result = 20u32;

match result {
 0..=20 => println!("Included"),
 21.. => println!("Sorry"),
}

25. Option's iterator

Sat, 24 Dec 2022 12:13:00 +0100

Rust’s option implements an iterator!

1
2
3
4


let o: Option<u32> = Some(200u32);
let mut iter = o.into_iter();
let v = iter.next();
assert_eq!(v, Some(200u32));

Why is this useful? see example.

23. Enum's default value

Tue, 06 Dec 2022 12:13:00 +0100

Instead of manually implementing Default trait for an enum, you can derive it and explicitly tell which variant should be the default one.

1
2
3
4
5
6
7
8
9


#[derive(Default)]
enum Car{
 #[default]
 Porsche,
 Ferrari,
 Skoda
}

let car = Car::default();

22. Enum's Debug

Fri, 11 Nov 2022 12:13:00 +0100

Use Debug trait to print enum values if needed.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#[derive(Default,Debug)]
enum Car{
 #[default]
 Porsche,
 Ferrari,
 Skoda
}

let car = Car::default();
println!("{:?}", car);

21. Zip longest

Sat, 22 Oct 2022 12:13:00 +0100

Sometimes there is a need to zip two iterables of various lengths.

If it is known which one is longer, then use the following approach:

First one must be longer.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


let nums1 = [1, 2, 3, 4];
let nums2 = [10, 20];

for (n1, n2) in nums1
 .into_iter()
 .zip(nums2.into_iter().chain(std::iter::repeat(0i32)))
{
 println!("{n1} - {n2}");
}
// Output:
// 1 - 10
// 2 - 20
// 3 - 0
// 4 - 0

20. let-else statements

Sun, 11 Sep 2022 12:13:00 +0100

As of 1.65, it is possible to use let statement with a refutable pattern.

1
2
3
4
5
6
7


let result: Result<i32, ()> = Ok(20);

let Ok(value) = result else {
 panic!("Heeeelp!!!");
};

assert_eq!(value, 20);

19. breaking from labeled blocks

Thu, 18 Aug 2022 12:13:00 +0100

As of 1.65, it is possible to label plain block expression and terminate that block early.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


let result = 'block: {
 let result = 20i32;
 if result < 10 {
 break 'block 1;
 }
 if result > 10 {
 break 'block 2;
 }
 3
};
assert_eq!(result, 2);

18. flatten options

Wed, 13 Jul 2022 12:13:00 +0100

Use flatten to iterate over only Some values if you have a collection of Options.

1
2
3
4
5
6


let nums = vec![None, Some(2), None, Some(3), None];

let mut iter = nums.into_iter().flatten();

assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));

16. Option/Result match?!

Fri, 10 Jun 2022 12:13:00 +0100

Try to avoid matching Option or Result.

Use if let instead.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


let result = Some(111);

// Not nice
match result {
 Some(x) => println!("{x}"),
 None => {}
};

// Better
if let Some(x) = result {
 println!("{x}");
}

14. Find index of item

Wed, 20 Apr 2022 12:13:00 +0100

Use position to find position of an element in iterator. Returns None if the element does not exist.

1
2
3
4
5
6


let nums = [1, 2, 3];

let pos = nums.iter().position(|value| *value == 3);
assert_eq!(pos, Some(2));
let pos = nums.iter().position(|value| *value == 10);
assert_eq!(pos, None);

15. Scan

Wed, 20 Apr 2022 12:13:00 +0100

Iterator adapter similar to fold (see previous bite) - holds some internal state and produces new iterator.

Note that Option is yielded from the closure.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


let nums = [1, 2, 3];

let mut iter = nums.iter().scan(0, |acc, &x| {
 *acc = *acc + x;
 Some((*acc, x))
});

assert_eq!(iter.next(), Some((1, 1)));
assert_eq!(iter.next(), Some((3, 2)));
assert_eq!(iter.next(), Some((6, 3)));

12. Enumerate

Sun, 20 Mar 2022 12:13:00 +0100

Use enumerate to convert iterator over (usize,item) pairs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


let cars = vec!["Skoda", "Ferrari", "Ford"];

for (idx, car) in cars.iter().enumerate() {
 println!("{idx} - {car}");
}

// Output
// 0 - Skoda
// 1 - Ferrari
// 2 - Ford

Useful when index of item is needed.

13. Fold

Sun, 20 Mar 2022 12:13:00 +0100

Iterator consumer. Allows the accumulated value to be arbitrary type. Note the different types.

1
2
3


let nums: Vec<u8> = vec![1, 2, 3, 4];
let sum = nums.iter().fold(0u32, |acc, x| acc + *x as u32);
assert_eq!(sum, 10);

17. filter_map

Sun, 20 Mar 2022 12:13:00 +0100

Similar to map but if allows to drop an item.

1
2
3
4
5
6
7
8


let text_nums = ["1", "two", "three", "4"];

let nums: Vec<_> = text_nums
 .iter()
 .filter_map(|x| x.parse::<u32>().ok())
 .collect();

assert_eq!(nums, vec![1, 4]);

11. Fuse

Sat, 19 Mar 2022 12:13:00 +0100

Fuse is an iterator that yields None forever after the underlying iterator yields None once. USage:

1
2


let values = [1,2,3,4];
let iter = values.iter().fuse();

Why is it useful? see example in this bite.

10. cloned vs copied

Fri, 25 Feb 2022 12:13:00 +0100

Rust provides built-in methods to copy or clone elements when using an iterator.

Eg.

1

let nums: Vec<u32> = nums1.iter().chain(&nums2).copied().collect();

What’s the difference? and when is it useful?

9. Inspecting iterator

Tue, 15 Feb 2022 12:13:00 +0100

Ever wondered how to print while iterating?

Use inspect.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


let cars = vec!["Skoda", "Ferrari", "Ford"];

let car_lenghts: Vec<u32> = cars
 .iter()
 .enumerate()
 .inspect(|(idx, s)| println!("{idx} - {s}"))
 .map(|(_, name)| name.len() as u32)
 .collect();

assert!( car_lenghts == vec![5,7,4

8. Drain

Thu, 10 Feb 2022 12:13:00 +0100

Use drain to remove specified range from a vector.

1
2
3
4
5


let mut a = vec![1,2,3,4,5];

let _ = a.drain(0..3);

assert!(a == vec![4,5]);

7. iter() vs into_iter()

Sat, 05 Feb 2022 12:13:00 +0100

What is the difference between .iter() and .into_iter()?

iter yields &T

into_iter may yield any of T, &T or &mut T based on context.

1
2
3
4
5
6
7
8
9


let cars = vec!["Skoda", "Ferrari", "Ford"];

for car in cars.iter() {
 println!("{car}");
}

for car in cars.into_iter() {
 println!("{car}");
}

this works but …

6. non-exhaustive enums

Sun, 30 Jan 2022 12:13:00 +0100

Use non-exhaustive attribute to indicate that enum may have more variants in future.

1
2
3
4
5


#[non_exhaustive]
enum Event{
 Error,
 Completed(String)
}

5. Loop breaks and labels

Tue, 25 Jan 2022 12:13:00 +0100

Breaks and labels in loops?

IT is possible to use a label to specify which enclosing loop is affected.

1
2
3
4
5
6
7
8


let s = 'outer: loop {
 for idx in 0..10 {
 if idx == 4 {
 break 'outer idx;
 }
 }
 };
assert!(s == 4);

4. Option -> Result

Thu, 20 Jan 2022 12:13:00 +0100

Convert Option to Result easily.

1
2
3


let o: Option<u32> = Some(200u32);
let r: Result<u32,()> = o.ok_or(());
assert_eq!(r, Ok(200u32));

3. Result -> Option

Sat, 15 Jan 2022 12:13:00 +0100

Convert Result to Option easily.

1
2
3


let r: Result<u32,()> = Ok(200u32);
let o: Option<u32> = r.ok();
assert_eq!(o, Some(200u32));

2. mysterious @

Mon, 10 Jan 2022 16:13:00 +0100

Use @ to bind a pattern to a name.

1
2
3
4
5
6


let foo = 4;

match foo {
 x @ 0..=5 => assert_eq!(x,4),
 y @ _ => panic!("{}-too many!", y)
}

1. matches!

Wed, 05 Jan 2022 16:13:00 +0100

Need to check if an expression matches certain pattern?

1
2


let foo = vec!['1','2'];
assert!(matches!(foo.len(), 0..=1));

0. Hello, rustbites!

Sat, 01 Jan 2022 11:33:00 +0100

Hello and welcome to rustbites.com

1
2


let hello = "Hello, rustbites!";
println!("{}", hello);

About

Mon, 01 Jan 0001 00:00:00 +0000

Welcome to rustbites.com!

rustbites is a collection of notes of one curious developer on his journey to learn Rust.

The goal is to provide valuable and informative content that will help Rust developers of all skill levels improve their skills and stay up-to-date with the language.

Mon, 01 Jan 0001 00:00:00 +0000