Fix eval function call

README.md

@@ -14,6 +14,16 @@ RPython é um projeto educacional que visa:
 - Explorar conceitos fundamentais de técnicas de programação
 - Criar uma linguagem com sintaxe amigável similar ao Python
 
+## 📚 Documentação
+
+Para uma compreensão mais profunda dos componentes do projeto, consulte nossa documentação técnica:
+
+- **[Environment Module](docs/environment.md)** - Sistema de gerenciamento de escopo lexical com tabela de símbolos para variáveis e funções. Implementa uma pilha de escopos com resolução adequada da cadeia de escopo.
+
+- **[Parser Component](docs/parser.md)** - Componente de análise sintática que transforma código fonte em Árvore de Sintaxe Abstrata (AST). Usa a biblioteca `nom` e segue um design modular com funcionalidades especializadas para expressões, tipos e declarações.
+
+- **[Type Checker Module](docs/type_checker.md)** - Sistema de verificação de tipos estática que analisa expressões e declarações para garantir segurança de tipos em tempo de compilação. Implementa regras de tipagem bem definidas para todos os construtos da linguagem. *(Em desenvolvimento)*
+
 ## 🤝 Contribuindo
 
 Adoraríamos contar com sua contribuição! Por favor, leia nossos guias de contribuição:

docs/PARSER.md

@@ -0,0 +1,189 @@
+# Parser Component Documentation
+
+## Overview
+
+The parser component is responsible for transforming source code text into an Abstract Syntax Tree (AST). It is implemented using the `nom` parser combinator library and follows a modular design pattern, breaking down the parsing logic into several specialized modules.
+
+## Architecture
+
+The parser is organized into the following modules:
+
+- `parser.rs`: The main entry point that coordinates the parsing process
+- `parser_common.rs`: Common parsing utilities and shared functions
+- `parser_expr.rs`: Expression parsing functionality
+- `parser_type.rs`: Type system parsing
+- `parser_stmt.rs`: Statement and control flow parsing
+
+### Module Responsibilities and Public Interface
+
+#### 1. parser.rs
+The main parser module that provides the entry point for parsing complete programs:
+```rust
+pub fn parse(input: &str) -> IResult<&str, Vec<Statement>>
+```
+
+#### 2. parser_common.rs
+Common parsing utilities used across other modules:
+```rust
+pub fn is_string_char(c: char) -> bool
+pub fn separator<'a>(sep: &'static str) -> impl FnMut(&'a str) -> IResult<&'a str, &'a str>
+pub fn keyword<'a>(kw: &'static str) -> impl FnMut(&'a str) -> IResult<&'a str, &'a str>
+pub fn identifier(input: &str) -> IResult<&str, &str>
+```
+
+#### 3. parser_expr.rs
+Expression parsing functionality:
+```rust
+pub fn parse_expression(input: &str) -> IResult<&str, Expression>
+pub fn parse_actual_arguments(input: &str) -> IResult<&str, Vec<Expression>>
+```
+
+#### 4. parser_type.rs
+Type system parsing:
+```rust
+pub fn parse_type(input: &str) -> IResult<&str, Type>
+```
+
+#### 5. parser_stmt.rs
+Statement and control flow parsing:
+```rust
+pub fn parse_statement(input: &str) -> IResult<&str, Statement>
+```
+
+## Parser Features
+
+### Statement Parsing
+The parser supports various types of statements:
+- Variable declarations and assignments
+- Control flow (if-else, while, for)
+- Function definitions
+- Assert statements
+- ADT (Algebraic Data Type) declarations
+
+### Expression Parsing
+Handles different types of expressions:
+- Arithmetic expressions
+- Boolean expressions
+- Function calls
+- Variables
+- Literals (numbers, strings, booleans)
+- ADT constructors and pattern matching
+
+### Type System
+Supports a rich type system including:
+- Basic types (Int, Real, Boolean, String, Unit, Any)
+- Complex types (List, Tuple, Maybe)
+- ADT declarations
+- Function types
+
+## nom Parser Combinators
+
+The parser extensively uses the `nom` parser combinator library. Here are the key combinators used:
+
+### Basic Combinators
+- `tag`: Matches exact string patterns
+- `char`: Matches single characters
+- `digit1`: Matches one or more digits
+- `alpha1`: Matches one or more alphabetic characters
+- `space0/space1`: Matches zero or more/one or more whitespace characters
+
+### Sequence Combinators
+- `tuple`: Combines multiple parsers in sequence
+- `preceded`: Matches a prefix followed by a value
+- `terminated`: Matches a value followed by a suffix
+- `delimited`: Matches a value between two delimiters
+
+### Branch Combinators
+- `alt`: Tries multiple parsers in order
+- `map`: Transforms the output of a parser
+- `opt`: Makes a parser optional
+
+### Multi Combinators
+- `many0/many1`: Matches zero or more/one or more occurrences
+- `separated_list0`: Matches items separated by a delimiter
+
+## Example Usage
+
+Here's an example of how the parser handles a simple assignment statement:
+
+```python
+x = 42
+```
+
+This is parsed using the following combinators:
+```rust
+fn parse_assignment_statement(input: &str) -> IResult<&str, Statement> {
+    map(
+        tuple((
+            preceded(multispace0, identifier),
+            preceded(multispace0, tag("=")),
+            preceded(multispace0, parse_expression),
+        )),
+        |(var, _, expr)| Statement::Assignment(var.to_string(), Box::new(expr)),
+    )(input)
+}
+```
+
+## AST Structure
+
+The parser produces an Abstract Syntax Tree (AST) with the following main types:
+
+### Statements
+```rust
+pub enum Statement {
+    VarDeclaration(Name),
+    ValDeclaration(Name),
+    Assignment(Name, Box<Expression>),
+    IfThenElse(Box<Expression>, Box<Statement>, Option<Box<Statement>>),
+    While(Box<Expression>, Box<Statement>),
+    For(Name, Box<Expression>, Box<Statement>),
+    Block(Vec<Statement>),
+    Assert(Box<Expression>, Box<Expression>),
+    FuncDef(Function),
+    Return(Box<Expression>),
+    ADTDeclaration(Name, Vec<ValueConstructor>),
+    // ... other variants
+}
+```
+
+### Types
+```rust
+pub enum Type {
+    TInteger,
+    TReal,
+    TBool,
+    TString,
+    TList(Box<Type>),
+    TTuple(Vec<Type>),
+    TMaybe(Box<Type>),
+    TResult(Box<Type>, Box<Type>),
+    TFunction(Box<Option<Type>>, Vec<Type>),
+    // ... other variants
+}
+```
+
+## Error Handling
+
+The parser implements error handling through the `nom` error system:
+```rust
+pub enum ParseError {
+    IndentationError(usize),
+    UnexpectedToken(String),
+    InvalidExpression(String),
+}
+```
+
+## Testing
+
+The parser includes a comprehensive test suite in `tests/parser_tests.rs` that verifies:
+- Simple assignments
+- Complex expressions
+- Control flow structures
+- Type annotations
+- Complete programs
+- Error handling
+- Whitespace handling 
+
+
+> **Documentation Generation Note**  
+> This documentation was automatically generated by Claude (Anthropic), an AI assistant, through analysis of the codebase. While the content accurately reflects the implementation, it should be reviewed and maintained by the development team. Last generated: June 2025.

docs/environment.md

@@ -0,0 +1,135 @@
+# Environment Module Documentation
+
+The environment module provides a lexically-scoped symbol table implementation for the R-Python language. It supports both variable and function bindings, with proper scope chain resolution.
+
+## Overview
+
+The module implements two main structures:
+- `Scope<A>`: Represents a single scope with its variable and function bindings
+- `Environment<A>`: Manages a stack of scopes with a global scope at the bottom
+
+The generic parameter `A` allows the environment to be used for different purposes:
+- Type checking: `Environment<Type>`
+- Interpretation: `Environment<Expression>`
+
+## Structures
+
+### Scope<A>
+
+A single scope containing mappings for variables and functions.
+
+```rust
+pub struct Scope<A> {
+    pub variables: HashMap<Name, A>,
+    pub functions: HashMap<Name, Function>,
+}
+```
+
+#### Methods
+
+- `new() -> Scope<A>`: Creates a new empty scope
+- `map_variable(var: Name, value: A)`: Binds a variable in the current scope
+- `map_function(function: Function)`: Binds a function in the current scope
+- `lookup_var(var: &Name) -> Option<&A>`: Looks up a variable in this scope
+- `lookup_function(name: &Name) -> Option<&Function>`: Looks up a function in this scope
+
+### Environment<A>
+
+Manages a stack of scopes with lexical scoping rules.
+
+```rust
+pub struct Environment<A> {
+    pub globals: Scope<A>,
+    pub stack: LinkedList<Scope<A>>,
+}
+```
+
+#### Methods
+
+- `new() -> Environment<A>`: Creates a new environment with empty global scope
+- `map_variable(var: Name, value: A)`: Maps a variable in the current scope
+- `map_function(function: Function)`: Maps a function in the current scope
+- `lookup(var: &Name) -> Option<&A>`: Looks up a variable through the scope chain
+- `lookup_function(name: &Name) -> Option<&Function>`: Looks up a function through the scope chain
+- `push()`: Creates a new scope at the top of the stack
+- `pop()`: Removes the topmost scope
+- `scoped_function() -> bool`: Checks if we're in a function scope
+
+## Scoping Rules
+
+1. **Variable Resolution**:
+   - First checks the local scopes from innermost to outermost
+   - Falls back to global scope if not found in any local scope
+   - Returns None if the variable is not found anywhere
+
+2. **Function Resolution**:
+   - Follows the same rules as variable resolution
+   - Functions can be defined in any scope
+   - Inner functions can shadow outer functions
+
+3. **Scope Management**:
+   - New scopes are pushed when entering a function or block
+   - Scopes are popped when exiting their block
+   - Global scope always remains at the bottom
+
+## Usage Examples
+
+### Type Checking
+
+```rust
+let mut type_env: Environment<Type> = Environment::new();
+
+// In global scope
+type_env.map_variable("x".to_string(), Type::TInteger);
+
+// In function scope
+type_env.push();
+type_env.map_variable("y".to_string(), Type::TReal);
+```
+
+### Interpretation
+
+```rust
+let mut runtime_env: Environment<Expression> = Environment::new();
+
+// In global scope
+runtime_env.map_variable("x".to_string(), Expression::CInt(42));
+
+// In function scope
+runtime_env.push();
+runtime_env.map_variable("y".to_string(), Expression::CReal(3.14));
+```
+
+### Nested Scopes
+
+```rust
+let mut env: Environment<i32> = Environment::new();
+
+// Global scope
+env.map_variable("x".to_string(), 1);
+
+// Outer function scope
+env.push();
+env.map_variable("y".to_string(), 2);
+
+// Inner function scope
+env.push();
+env.map_variable("z".to_string(), 3);
+
+// Variables from all scopes are accessible
+assert!(env.lookup(&"x".to_string()).is_some()); // from global
+assert!(env.lookup(&"y".to_string()).is_some()); // from outer
+assert!(env.lookup(&"z".to_string()).is_some()); // from inner
+
+// Pop scopes to clean up
+env.pop(); // removes inner scope
+env.pop(); // removes outer scope
+```
+
+## Implementation Notes
+
+1. The environment uses a `LinkedList` for the scope stack to efficiently push/pop scopes
+2. All lookups traverse the entire scope chain for proper lexical scoping
+3. The generic parameter `A` must implement `Clone` for the environment to work
+4. Functions are treated similarly to variables but stored in a separate map
+5. The global scope is always accessible, regardless of the current scope depth