fn filter(&mut self) { if self.query.isempty() { self.filtered.clear(); self.filtered…
- User
fn filter(&mut self) { if self.query.is_empty() { self.filtered.clear(); self.filtered .extend(filtered_init(self.entries.len()).iter()); return; }
self.filtered.clear(); self.filtered.reserve(self.entries.len()); for (i, lower_name) in self.names_lower.iter().enumerate() { if let Some(score) = self.matcher.fuzzy_match(lower_name, &self.query) { self.filtered.push((i, score)); } } self.filtered.sort_unstable_by(|a, b| { b.1.cmp(&a.1) .then_with(|| self.names_lower[a.0].cmp(&self.names_lower[b.0])) }); if self.find_selected().is_none() { self.first_filtered(); } }given that only a certain number of elements will be displayed from the vector, any way to optimise this fn?
Assistant
Looking at your filtering function, here are several optimization opportunities given that only a subset of elements will be displayed:
1. Early Termination with Top-K Selection
Instead of finding and sorting all matches, you can maintain only the top K items:
fn filter(&mut self) { if self.query.is_empty() { self.filtered.clear(); self.filtered.extend(filtered_init(self.entries.len()).iter()); return; } const MAX_DISPLAY: usize = 50; // or whatever your display limit is self.filtered.clear(); self.filtered.reserve(MAX_DISPLAY.min(self.entries.len())); // Use a min-heap to keep only top K items use std::collections::BinaryHeap; use std::cmp::Reverse; let mut heap = BinaryHeap::with_capacity(MAX_DISPLAY + 1); for (i, lower_name) in self.names_lower.iter().enumerate() { if let Some(score) = self.matcher.fuzzy_match(lower_name, &self.query) { heap.push(Reverse((score, i))); if heap.len() > MAX_DISPLAY { heap.pop(); // Remove lowest scoring item } } } // Extract and sort the top items self.filtered = heap.into_sorted_vec() .into_iter() .map(|Reverse((score, i))| (i, score)) .collect(); self.filtered.reverse(); // Highest scores first if self.find_selected().is_none() { self.first_filtered(); } }2. Parallel Processing
For large datasets, you can use rayon for parallel filtering:
use rayon::prelude::*; fn filter(&mut self) { if self.query.is_empty() { self.filtered.clear(); self.filtered.extend(filtered_init(self.entries.len()).iter()); return; } const MAX_DISPLAY: usize = 50; // Parallel filtering with top-K selection let query = self.query.clone(); let matcher = &self.matcher; let mut results: Vec<(usize, i64)> = self.names_lower .par_iter() .enumerate() .filter_map(|(i, lower_name)| { matcher.fuzzy_match(lower_name, &query).map(|score| (i, score)) }) .collect(); // Partial sort to get top K let k = MAX_DISPLAY.min(results.len()); results.select_nth_unstable_by(k.saturating_sub(1), |a, b| { b.1.cmp(&a.1) .then_with(|| self.names_lower[a.0].cmp(&self.names_lower[b.0])) }); self.filtered = results.into_iter().take(k).collect(); self.filtered.sort_unstable_by(|a, b| { b.1.cmp(&a.1) .then_with(|| self.names_lower[a.0].cmp(&self.names_lower[b.0])) }); if self.find_selected().is_none() { self.first_filtered(); } }3. Score Threshold
Skip items with very low scores early:
const MIN_SCORE_THRESHOLD: i64 = 10; // Adjust based on your matcher for (i, lower_name) in self.names_lower.iter().enumerate() { if let Some(score) = self.matcher.fuzzy_match(lower_name, &self.query) { if score >= MIN_SCORE_THRESHOLD { self.filtered.push((i, score)); } } }4. Incremental Filtering
If users type character by character, you can optimize by filtering the previous results:
fn filter_incremental(&mut self, previous_query: &str) { if self.query.starts_with(previous_query) && !previous_query.is_empty() { // Filter existing results instead of all entries self.filtered.retain(|(i, _)| { self.matcher.fuzzy_match(&self.names_lower[*i], &self.query).is_some() }); // Update scores for (i, score) in &mut self.filtered { if let Some(new_score) = self.matcher.fuzzy_match(&self.names_lower[*i], &self.query) { *score = new_score; } } self.filtered.sort_unstable_by(|a, b| { b.1.cmp(&a.1) .then_with(|| self.names_lower[a.0].cmp(&self.names_lower[b.0])) }); } else { self.filter(); // Full filter for other cases } }5. Lazy Evaluation
Only compute what's needed for display:
struct LazyFilterIterator<'a> { names_lower: &'a [String], matcher: &'a Matcher, query: &'a str, current_index: usize, } impl<'a> Iterator for LazyFilterIterator<'a> { type Item = (usize, i64); fn next(&mut self) -> Option<Self::Item> { while self.current_index < self.names_lower.len() { let i = self.current_index; self.current_index += 1; if let Some(score) = self.matcher.fuzzy_match(&self.names_lower[i], self.query) { return Some((i, score)); } } None } }The most impactful optimization would likely be #1 (Top-K selection) combined with #3 (score threshold), as this reduces both the memory usage and sorting overhead significantly when you only need to display a limited number of results.
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.