2.2: 完成let 变量绑定的实现

Author: Natural-selection1

src/eager_evaluation.rs

@@ -16,25 +16,26 @@ pub use linked_list::LinkedListComprehension;
 pub use vec_deque::VecDequeComprehension;
 pub use vector::VecComprehension;
 
-use crate::iter_clause::{BareIfClause, ForInClause, IterClause};
+use crate::iter_clause::{BareIfClause, ForInClause, IterClause, LetClause};
 
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::Expr;
 
-pub(crate) fn handle_nested_loops<'a>(
-    iter_clauses: &'a [IterClause],
+pub(crate) fn handle_nested_loops(
+    iter_clauses: &[IterClause],
     mut nested_code: TokenStream,
 ) -> TokenStream {
-    let mut need_to_shadow: Vec<&'a Expr> = vec![];
+    let mut need_to_shadow: Vec<&Expr> = vec![];
 
     // 遍历iter_clauses(因为越向后层次越深, 所以直接pop就行了)
-    let mut iter_clauses: Vec<&'a IterClause> = iter_clauses.iter().collect();
+    let mut iter_clauses: Vec<&IterClause> = iter_clauses.iter().collect();
 
     while let Some(iter_clause) = iter_clauses.pop() {
         let IterClause {
             for_in_clause: ForInClause { pat, iterable },
             if_clause,
+            let_clauses,
         } = iter_clause;
 
         let iterable_code = match iterable {
@@ -57,6 +58,14 @@ pub(crate) fn handle_nested_loops<'a>(
             _ => panic!("type is not supported: \n{:#?}", iterable),
         };
 
+        let mut let_clauses: Vec<&LetClause> = let_clauses.iter().collect();
+        while let Some(LetClause { let_expr }) = let_clauses.pop() {
+            nested_code = quote! {
+                #let_expr;
+                #nested_code
+            };
+        }
+
         // 根据是否有if条件生成循环代码
         nested_code = match if_clause {
             Some(BareIfClause { conditions }) => {

src/iter_clause.rs

@@ -7,19 +7,25 @@ use syn::parse::ParseStream;
 pub struct IterClause {
     pub for_in_clause: ForInClause,
     pub if_clause: Option<BareIfClause>,
+    pub let_clauses: Vec<LetClause>,
 }
 
 impl syn::parse::Parse for IterClause {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let mut iter_clause = Self {
             for_in_clause: input.parse::<ForInClause>()?,
             if_clause: None,
+            let_clauses: vec![],
         };
 
         if input.peek(syn::Token![if]) {
             iter_clause.if_clause = Some(input.parse::<BareIfClause>()?);
         }
 
+        while input.peek(syn::Token![let]) {
+            iter_clause.let_clauses.push(input.parse::<LetClause>()?);
+        }
+
         Ok(iter_clause)
     }
 }
@@ -59,7 +65,19 @@ impl syn::parse::Parse for BareIfClause {
     }
 }
 
-/* ------------------------------------ */
+/* ----------------LetClause-------------------- */
+#[derive(Debug)]
+pub struct LetClause {
+    pub let_expr: Expr,
+}
+
+impl syn::parse::Parse for LetClause {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        Ok(Self {
+            let_expr: input.parse::<Expr>()?,
+        })
+    }
+}
 
 #[cfg(test)]
 mod tests {

src/lazy_evaluation.rs

@@ -1,4 +1,4 @@
-use crate::iter_clause::{BareIfClause, ForInClause, IterClause};
+use crate::iter_clause::{BareIfClause, ForInClause, IterClause, LetClause};
 use crate::mapping::{Mapping, MappingElse};
 
 use quote::quote;
@@ -68,6 +68,7 @@ impl quote::ToTokens for IteratorRef {
             let IterClause {
                 for_in_clause: ForInClause { pat, iterable },
                 if_clause,
+                let_clauses,
             } = iter_clause;
             info_container.depth += 1;
 
@@ -89,6 +90,14 @@ impl quote::ToTokens for IteratorRef {
                     None => quote! { true },
                 };
 
+                let mut let_clauses: Vec<&LetClause> = let_clauses.iter().collect();
+                while let Some(LetClause { let_expr }) = let_clauses.pop() {
+                    nested_code = quote! {
+                        #let_expr;
+                        #nested_code
+                    };
+                }
+
                 nested_code = quote! {
                     (#iterable)
                     .into_iter()

src/main.rs

@@ -510,25 +510,66 @@ fn some_real_example_2() {
 
 #[test]
 fn some() {
-use better_comprehension::iterator_ref;
-let vec_1 = ["123".to_string(),
-             "456".to_string(),
-             "789".to_string()];
-let vec_2 = ["ABC".to_string(),
-             "DEF".to_string(),
-             "GHI".to_string()];
-
-let mut result3 = iterator_ref![
-    (x.clone(), y.clone()) if x.contains("1") else (y.clone(), x.clone())
-    for x in vec_1 if x.contains("1") || x.contains("7")
-    for i in 1..=2
-    for y in vec_2 if y.contains("D") || x.contains("3")];
-
-// still alive
-println!("{:?}", vec_1);
-println!("{:?}", vec_2);
-
-for _ in 0..=9 {
-    println!("{:?}", result3.next());
-}
+    #[derive(Debug, PartialEq, Eq)]
+    struct Score {
+        subject: &'static str,
+        score: u8,
+    }
+    #[derive(Debug, PartialEq, Eq)]
+    struct Student {
+        name: String,
+        age: u8,
+        scores: Vec<Score>,
+    }
+
+    let students_data = [
+        Student {
+            name: "Alice".to_string(),
+            age: 20,
+            scores: vec![
+                Score {
+                    subject: "Math",
+                    score: 95,
+                },
+                Score {
+                    subject: "English",
+                    score: 88,
+                },
+            ],
+        },
+        Student {
+            name: "Bob".to_string(),
+            age: 21,
+            scores: vec![
+                Score {
+                    subject: "Math",
+                    score: 78,
+                },
+                Score {
+                    subject: "English",
+                    score: 85,
+                },
+            ],
+        },
+    ];
+
+    let high_scores = b_tree_map![
+        &student.name => high_scores
+        for student in &students_data
+            let high_scores = vector![
+                score.subject
+                for score in &student.scores if score.score >= 85
+            ]
+            let _ = {
+                println!("{}", high_scores.len());
+            }
+    ];
+
+    assert_eq!(
+        high_scores,
+        BTreeMap::from([
+            (&"Alice".to_string(), vec!["Math", "English"]),
+            (&"Bob".to_string(), vec!["English"])
+        ])
+    );
 }