القائمة
Leverage iterator chains for efficient, lazy data processing without intermediate allocations. Use when processing collections.
يُحدَّد Prompt الذي يراجع المصدر أولًا بشكل افتراضي. يمكنك التبديل إلى أمر مباشر أو تنزيل نسخة محلية.
اقرأ SKILL.md وأي ملفات مرافقة يعرضها SkillsMP قبل أن تقرر التثبيت.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/gar-ai/mallorn --skill rust-iteratorsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
استنادا إلى تصنيف SOC المهني
عرض SKILL.md
| name | rust-iterators |
| description | Leverage iterator chains for efficient, lazy data processing without intermediate allocations. Use when processing collections. |
Efficient data processing with lazy iterator chains.
// Single pass, lazy evaluation, no intermediate allocations
let result: Vec<_> = data
.iter()
.filter(|&&x| x > 2)
.map(|&x| x * 2)
.collect();
// Sum without collecting
let sum: i32 = data.iter().filter(|&&x| x > 0).sum();
// Count matches
let count = data.iter().filter(|x| x.is_valid()).count();
// Transform each element
.map(|x| transform(x))
.(|x| (x))
.(|x| x.())
.(|x| x.())
.()
.()
.(|x| x < &)
.(|x| x < &)
.(|x| (x))
.(|x| (x))
.(|x| (x))
.(|x| (x))
.(, |acc, x| acc + x)
.(|a, b| a + b)
.sum::<>()
.product::<>()
.collect::<<_>>()
.collect::<HashSet<_>>()
.collect::<>()
.collect::<<<_>, _>>()
use rayon::prelude::*;
// Parallel iteration (automatic work stealing)
let sum: i32 = data.par_iter().map(|x| expensive(x)).sum();
// Parallel sort
let mut data = data;
data.par_sort();
// Parallel filter + map
let results: Vec<_> = data
.par_iter()
.filter(|x| predicate(x))
.map(|x| transform(x))
.collect();
// Get index with element
for (index, item) in items.iter().enumerate() {
println!("{}: {}", index, item);
}
// Pair two iterators
let pairs: Vec<_> = keys.iter().zip(values.iter()).collect();
// Unzip pairs
let (keys, values): (Vec<_>, Vec<_>) = pairs.into_iter().unzip();
// Concatenate iterators
let combined: Vec<_> = first.iter()
.chain(second.iter())
.chain(third.iter())
.collect();
// Flatten nested iterables
let flat: Vec<_> = nested_vecs.iter().flatten().collect();
// Flatten with transformation
let all_items: Vec<_> = containers
.iter()
.flat_map(|c| c.items())
.collect();
let mut iter = data.iter().peekable();
while let Some(¤t) = iter.next() {
// Look ahead without consuming
if let Some(&&next) = iter.peek() {
if next > current {
// Do something
}
}
}
// Overlapping windows of size 3
for window in data.windows(3) {
let [a, b, c] = window else { continue };
// Process window
}
// Non-overlapping chunks
for chunk in data.chunks(100) {
process_batch(chunk);
}
// Exact chunks (panic if not divisible)
for chunk in data.chunks_exact(100) {
process_batch(chunk);
}
struct Counter {
current: usize,
max: usize,
}
impl Iterator for Counter {
type Item = usize;
fn next(&mut self) -> Option<Self::Item> {
if self.current < self.max {
let result = self.current;
self.current += 1;
Some(result)
} else {
None
}
}
// Optional: Provide size hint for better allocation
fn size_hint(&self) -> (usize, Option<usize>) {
let remaining = self.max - self.current;
(remaining, Some(remaining))
}
}
// ExactSizeIterator if size is known
impl ExactSizeIterator for Counter {}
// Collect Vec<Result<T, E>> into Result<Vec<T>, E>
let results: Result<Vec<_>, _> = items
.iter()
.map(|item| fallible_operation(item))
.collect();
// Short-circuits on first error
match results {
Ok(values) => process(values),
Err(e) => handle_error(e),
}
// Avoid: Collecting intermediate results
let temp: Vec<_> = data.iter().filter(|x| x > &0).collect();
let result: i32 = temp.iter().sum();
// Better: Chain without collecting
let result: i32 = data.iter().filter(|&&x| x > 0).sum();
// Use iterator methods over manual loops
// Avoid:
let mut sum = 0;
for x in &data {
if *x > 0 {
sum += x;
}
}
// Prefer:
let sum: i32 = data.iter().filter(|&&x| x > 0).sum();
filter_map to combine filter + map for Optionsflat_map to flatten nested structuressize_hint for custom iteratorschunks for batch processingSee hercules-local-algo/src/pipeline/ for iterator patterns.