Format let-else ❤️ 🎉

index-scheduler/src/index_mapper/index_map.rs

@@ -223,7 +223,9 @@ impl IndexMap {
         enable_mdb_writemap: bool,
         map_size_growth: usize,
     ) {
-        let Some(index) = self.available.remove(uuid) else { return; };
+        let Some(index) = self.available.remove(uuid) else {
+            return;
+        };
         self.close(*uuid, index, enable_mdb_writemap, map_size_growth);
     }
 

meilisearch-types/src/keys.rs

@@ -147,9 +147,7 @@ impl Key {
 fn parse_expiration_date(
     string: Option<String>,
 ) -> std::result::Result<Option<OffsetDateTime>, ParseOffsetDateTimeError> {
-    let Some(string) = string else {
+    let Some(string) = string else { return Ok(None) };
-        return Ok(None)
-    };
     let datetime = if let Ok(datetime) = OffsetDateTime::parse(&string, &Rfc3339) {
         datetime
     } else if let Ok(primitive_datetime) = PrimitiveDateTime::parse(

milli/src/score_details.rs

@@ -97,8 +97,7 @@ impl ScoreDetails {
                     let attribute_details = attribute_details
                         .as_object_mut()
                         .expect("attribute details was not an object");
-                    let Some(fid_details) = fid_details
+                    let Some(fid_details) = fid_details else {
-                    else {
                         unimplemented!("position not preceded by attribute");
                     };
 

milli/src/search/new/bucket_sort.rs

@@ -153,7 +153,12 @@ pub fn bucket_sort<'ctx, Q: RankingRuleQueryTrait>(
             continue;
         }
 
-        let Some(next_bucket) = ranking_rules[cur_ranking_rule_index].next_bucket(ctx, logger, &ranking_rule_universes[cur_ranking_rule_index])? else {
+        let Some(next_bucket) = ranking_rules[cur_ranking_rule_index].next_bucket(
+            ctx,
+            logger,
+            &ranking_rule_universes[cur_ranking_rule_index],
+        )?
+        else {
             back!();
             continue;
         };

milli/src/search/new/graph_based_ranking_rule.rs

@@ -206,9 +206,7 @@ impl<'ctx, G: RankingRuleGraphTrait> RankingRule<'ctx, QueryGraph> for GraphBase
 
         let all_costs = state.all_costs.get(state.graph.query_graph.root_node);
         // Retrieve the cost of the paths to compute
-        let Some(&cost) = all_costs
+        let Some(&cost) = all_costs.iter().find(|c| **c >= state.cur_cost) else {
-            .iter()
-            .find(|c| **c >= state.cur_cost) else {
             self.state = None;
             return Ok(None);
         };

milli/src/search/new/matches/matching_words.rs

@@ -80,7 +80,9 @@ impl MatchingWords {
                 let word = self.word_interner.get(*word);
                 // if the word is a prefix we match using starts_with.
                 if located_words.is_prefix && token.lemma().starts_with(word) {
-                    let Some((char_index, c)) = word.char_indices().take(located_words.original_char_count).last() else {
+                    let Some((char_index, c)) =
+                        word.char_indices().take(located_words.original_char_count).last()
+                    else {
                         continue;
                     };
                     let prefix_length = char_index + c.len_utf8();

milli/src/search/new/query_graph.rs

@@ -349,10 +349,7 @@ impl QueryGraph {
         for (_, node) in self.nodes.iter() {
             match &node.data {
                 QueryNodeData::Term(term) => {
-                    let Some(phrase) = term.term_subset.original_phrase(ctx)
+                    let Some(phrase) = term.term_subset.original_phrase(ctx) else { continue };
-                    else {
-                        continue
-                    };
                     let phrase = ctx.phrase_interner.get(phrase);
                     word_count += phrase.words.iter().copied().filter(|a| a.is_some()).count()
                 }

milli/src/search/new/query_term/mod.rs

@@ -175,9 +175,7 @@ impl QueryTermSubset {
 
     pub fn use_prefix_db(&self, ctx: &SearchContext) -> Option<Word> {
         let original = ctx.term_interner.get(self.original);
-        let Some(use_prefix_db) = original.zero_typo.use_prefix_db else {
+        let Some(use_prefix_db) = original.zero_typo.use_prefix_db else { return None };
-            return None
-        };
         let word = match &self.zero_typo_subset {
             NTypoTermSubset::All => Some(use_prefix_db),
             NTypoTermSubset::Subset { words, phrases: _ } => {
@@ -261,13 +259,15 @@ impl QueryTermSubset {
 
         match &self.one_typo_subset {
             NTypoTermSubset::All => {
-                let Lazy::Init(OneTypoTerm { split_words: _, one_typo }) = &original.one_typo else {
+                let Lazy::Init(OneTypoTerm { split_words: _, one_typo }) = &original.one_typo
+                else {
                     panic!()
                 };
                 result.extend(one_typo.iter().copied().map(Word::Derived))
             }
             NTypoTermSubset::Subset { words, phrases: _ } => {
-                let Lazy::Init(OneTypoTerm { split_words: _, one_typo }) = &original.one_typo else {
+                let Lazy::Init(OneTypoTerm { split_words: _, one_typo }) = &original.one_typo
+                else {
                     panic!()
                 };
                 result.extend(one_typo.intersection(words).copied().map(Word::Derived));
@@ -277,15 +277,11 @@ impl QueryTermSubset {
 
         match &self.two_typo_subset {
             NTypoTermSubset::All => {
-                let Lazy::Init(TwoTypoTerm { two_typos }) = &original.two_typo else {
+                let Lazy::Init(TwoTypoTerm { two_typos }) = &original.two_typo else { panic!() };
-                    panic!()
-                };
                 result.extend(two_typos.iter().copied().map(Word::Derived));
             }
             NTypoTermSubset::Subset { words, phrases: _ } => {
-                let Lazy::Init(TwoTypoTerm { two_typos }) = &original.two_typo else {
+                let Lazy::Init(TwoTypoTerm { two_typos }) = &original.two_typo else { panic!() };
-                    panic!()
-                };
                 result.extend(two_typos.intersection(words).copied().map(Word::Derived));
             }
             NTypoTermSubset::Nothing => {}
@@ -308,13 +304,15 @@ impl QueryTermSubset {
 
         match &self.one_typo_subset {
             NTypoTermSubset::All => {
-                let Lazy::Init(OneTypoTerm { split_words, one_typo: _ }) = &original.one_typo else {
+                let Lazy::Init(OneTypoTerm { split_words, one_typo: _ }) = &original.one_typo
+                else {
                     panic!();
                 };
                 result.extend(split_words.iter().copied());
             }
             NTypoTermSubset::Subset { phrases, .. } => {
-                let Lazy::Init(OneTypoTerm { split_words, one_typo: _ }) = &original.one_typo else {
+                let Lazy::Init(OneTypoTerm { split_words, one_typo: _ }) = &original.one_typo
+                else {
                     panic!();
                 };
                 if let Some(split_words) = split_words {

milli/src/search/new/ranking_rule_graph/proximity/build.rs

@@ -18,7 +18,7 @@ pub fn build_edges(
         return Ok(vec![(
             right_ngram_max as u32,
             conditions_interner.insert(ProximityCondition::Term { term: right_term.clone() }),
-        )])
+        )]);
     };
 
     if left_term.positions.end() + 1 != *right_term.positions.start() {

milli/src/search/new/sort.rs

@@ -75,8 +75,9 @@ impl<'ctx, Query> Sort<'ctx, Query> {
     }
 
     fn must_redact(index: &Index, rtxn: &'ctx heed::RoTxn, field_name: &str) -> Result<bool> {
-        let Some(displayed_fields) = index.displayed_fields(rtxn)?
+        let Some(displayed_fields) = index.displayed_fields(rtxn)? else {
-        else { return Ok(false); };
+            return Ok(false);
+        };
 
         Ok(!displayed_fields.iter().any(|&field| field == field_name))
     }

milli/src/update/index_documents/mod.rs

@@ -2048,10 +2048,11 @@ mod tests {
             "branch_id_number": 0
         }]};
 
-        let Err(Error::UserError(UserError::MultiplePrimaryKeyCandidatesFound {
+        let Err(Error::UserError(UserError::MultiplePrimaryKeyCandidatesFound { candidates })) =
-            candidates
+            index.add_documents(doc_multiple_ids)
-        })) =
+        else {
-            index.add_documents(doc_multiple_ids) else { panic!("Expected Error::UserError(MultiplePrimaryKeyCandidatesFound)") };
+            panic!("Expected Error::UserError(MultiplePrimaryKeyCandidatesFound)")
+        };
 
         assert_eq!(candidates, vec![S("id"), S("project_id"), S("public_uid"),]);