rustbites

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