loop for implementation

Author: jm-236

src/interpreter/statement_execute.rs

@@ -75,6 +75,60 @@ pub fn execute(
             }
         }
 
+        Statement::For(var, expr, stmt) => {
+            let coll = eval(*expr, &new_env)?;
+            
+            match coll {
+                // Lista de valores
+                Expression::ListValue(items) => {
+                    new_env.push();
+                    for item in items {
+                        new_env.map_variable(var.clone(), true, item);
+                        new_env = execute(*stmt.clone(), &new_env)?;
+                    }
+                    new_env.pop();
+                    Ok(new_env)
+                }
+                
+                // String - itera sobre caracteres
+                Expression::CString(s) => {
+                    new_env.push();
+                    for ch in s.chars() {
+                        let char_value = Expression::CString(ch.to_string());
+                        new_env.map_variable(var.clone(), true, char_value);
+                        new_env = execute(*stmt.clone(), &new_env)?;
+                    }
+                    new_env.pop();
+                    Ok(new_env)
+                }
+                
+                // Tupla (assumindo que você tem Expression::Tuple)
+                Expression::Tuple(items) => {
+                    new_env.push();
+                    for item in items {
+                        new_env.map_variable(var.clone(), true, item);
+                        new_env = execute(*stmt.clone(), &new_env)?;
+                    }
+                    new_env.pop();
+                    Ok(new_env)
+                }
+                
+                // Constructor (já existia)
+                Expression::Constructor(_, items) => {
+                    new_env.push();
+                    for item_expr in items {
+                        let item_value = *item_expr.clone();
+                        new_env.map_variable(var.clone(), true, item_value);
+                        new_env = execute(*stmt.clone(), &new_env)?;
+                    }
+                    new_env.pop();
+                    Ok(new_env)
+                }
+                
+                _ => Err((format!("Cannot iterate over {:?}", coll), None)),
+            }
+        }
+
         Statement::Sequence(s1, s2) => {
             new_env = execute(*s1, &new_env)?;
             execute(*s2, &new_env)

src/ir/ast.rs

@@ -134,4 +134,5 @@ pub enum Statement {
     FuncDef(Function),
     Return(Box<Expression>),
     TypeDeclaration(Name, Vec<ValueConstructor>),
+    Tuple(Vec<Expression>)
 }

src/type_checker/statement_type_checker.rs

@@ -141,40 +141,55 @@ fn check_while_stmt(
     Ok(new_env)
 }
 
+// Função auxiliar para determinar o tipo do elemento iterável
+fn get_iterable_element_type(expr_type: &Type) -> Result<Type, ErrorMessage> {
+    match expr_type {
+        Type::TList(base_type) => Ok((**base_type).clone()),
+        Type::TString => Ok(Type::TString), // Caracteres como strings
+        Type::TTuple(types) => {
+            if types.is_empty() {
+                return Err("[Type Error] Cannot iterate over empty tuple type".to_string());
+            }
+            
+            // Verificar se todos os tipos são iguais (tupla homogênea)
+            let first_type = &types[0];
+            if types.iter().all(|t| t == first_type) {
+                Ok(first_type.clone())
+            } else {
+                Err("[Type Error] Can only iterate over homogeneous tuples (all elements same type)".to_string())
+            }
+        }
+        _ => Err(format!("[Type Error] Type {:?} is not iterable", expr_type))
+    }
+}
+
 fn check_for_stmt(
     var: Name,
     expr: Box<Expression>,
     stmt: Box<Statement>,
     env: &Environment<Type>,
 ) -> Result<Environment<Type>, ErrorMessage> {
     let mut new_env = env.clone();
-    let _var_type = env.lookup(&var);
+    
+    // Avaliar o tipo da expressão iterável
     let expr_type = check_expr(*expr, &new_env)?;
-    match expr_type {
-        Type::TList(base_type) => {
-            if let Some((_, t)) = env.lookup(&var) {
-                if t == *base_type || *base_type == Type::TAny {
-                    new_env = check_stmt(*stmt, &new_env)?;
-                    return Ok(new_env);
-                } else {
-                    return Err(format!(
-                        "[TypeError] Type mismatch between {:?} and {:?}",
-                        t, base_type
-                    ));
-                }
-            } else {
-                new_env.map_variable(var.clone(), false, *base_type);
-                new_env = check_stmt(*stmt, &new_env)?;
-                return Ok(new_env);
-            }
-        }
-        _ => {
-            return Err(format!(
-                "[TypeError] Expecting a List type, but found a {:?}",
-                expr_type
-            ))
-        }
-    }
+    
+    // Determinar o tipo do elemento
+    let element_type = get_iterable_element_type(&expr_type)?;
+    
+    // Criar novo escopo para o loop
+    new_env.push();
+    
+    // Mapear a variável iteradora no novo escopo
+    new_env.map_variable(var.clone(), false, element_type);
+    
+    // Verificar o corpo do loop no novo escopo
+    new_env = check_stmt(*stmt, &new_env)?;
+    
+    // Remover o escopo do loop
+    new_env.pop();
+    
+    Ok(new_env)
 }
 
 fn check_func_def_stmt(