diff --git a/include/evaluator.h b/include/evaluator.h
index 78c5730..7b34e2b 100644
--- a/include/evaluator.h
+++ b/include/evaluator.h
@@ -2,8 +2,10 @@
 #define EVALUATOR_H
 
 #include "lexer.h"
+#include "parser.h"
 #include <stdint.h>
 
-int64_t evaluate(ASTNode *tree);
+int64_t evaluate(ParseResult context);
+int64_t evaluate_tree(ASTNode *tree);
 
 #endif // !EVALUATOR_H
diff --git a/include/parser.h b/include/parser.h
index edae5fb..7c2fa4f 100644
--- a/include/parser.h
+++ b/include/parser.h
@@ -15,8 +15,8 @@ typedef struct {
 } ASTNodeSlice;
 
 typedef struct {
-    Arena *arena;
-    AST tree;
+    Arena arena;
+    ASTNode *tree;
 } ParseResult;
 
 ASTNode ASTNodeSlice_peek(ASTNodeSlice *slice);
diff --git a/src/evaluator.c b/src/evaluator.c
index 754fefd..36d9fb1 100644
--- a/src/evaluator.c
+++ b/src/evaluator.c
@@ -1,9 +1,11 @@
 #include "evaluator.h"
+#include "arena.h"
 #include "lexer.h"
+#include "parser.h"
 #include <stdint.h>
 
 
-int64_t evaluate(ASTNode *tree) {
+int64_t evaluate_tree(ASTNode *tree) {
     if (tree->type == NODE_BINARY_OP) {
         Operator op = tree->data.binary.op;
         ASTNode *left = tree->data.binary.left;
@@ -11,18 +13,24 @@ int64_t evaluate(ASTNode *tree) {
         
         switch (op) {
             case OP_ADD:
-                return evaluate(left) + evaluate(right);
+                return evaluate_tree(left) + evaluate_tree(right);
             case OP_SUB:
-                return evaluate(left) - evaluate(right);
+                return evaluate_tree(left) - evaluate_tree(right);
             case OP_MUL:
-                return evaluate(left) * evaluate(right);
+                return evaluate_tree(left) * evaluate_tree(right);
             case OP_DIV:
-                return evaluate(left) / evaluate(right);
+                return evaluate_tree(left) / evaluate_tree(right);
 
         }
-    } else {
-        int64_t return_val = tree->data.integer;
-        return return_val;
     }
+
+    int64_t return_val = tree->data.integer;
+    return return_val;
 }
 
+int64_t evaluate(ParseResult context) {
+    int64_t result = evaluate_tree(context.tree);
+    arena_destroy(&context.arena);
+
+    return result;
+}
diff --git a/src/main.c b/src/main.c
index b85197e..9cc1240 100644
--- a/src/main.c
+++ b/src/main.c
@@ -23,9 +23,7 @@ int main(void) {
     tokenize(buf, &context);
 
     ParseResult par = parse(&context);
-    AST tree = par.tree;
-    int64_t result = evaluate(tree.head);
-    arena_destroy(par.arena);
+    int64_t result = evaluate(par);
 
 
     printf("El resultado es: %" PRIi64 "\n", result);
diff --git a/src/parser.c b/src/parser.c
index 4d42001..2e417c5 100644
--- a/src/parser.c
+++ b/src/parser.c
@@ -63,15 +63,15 @@ bool ASTNodeSlice_is_valid(ASTNodeSlice *slice) {
 }
 
 ParseResult parse(ASTNodeArray *arr) {
-    AST tree;
     ASTNodeSlice context = {
         .arr = arr,
         .pos = 0,
     };
     Arena arena = arena_init(sizeof(ASTNode) * arr->len).arena;
 
-    tree.head = parse_expr(&context, &arena, 0);
-    return (ParseResult) {.arena = &arena, .tree = tree};
+    return (ParseResult) {
+        .arena = arena,
+        .tree = parse_expr(&context, &arena, 0)};
 }
 
 ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) {
@@ -107,7 +107,17 @@ ASTNode *parse_expr(ASTNodeSlice *slice, Arena *arena, uint8_t min_bp) {
         ASTNodeSlice_next(slice);
         ASTNode *right_side = parse_expr(slice, arena, rbp);
 
-        ASTNode *new_node = malloc(sizeof(ASTNode));
+        arena_ensure_capacity(
+            arena,
+            sizeof(ASTNode),
+            alignof(ASTNode));
+        ASTNode *new_node = arena_unwrap_pointer(
+            arena_alloc(
+                arena, 
+                sizeof(ASTNode), 
+                alignof(ASTNode)
+            )
+        );
         *new_node = operator;
 
         new_node->data.binary.left = left_side;
diff --git a/test/test_evaluator.c b/test/test_evaluator.c
index 5fe4114..a8f5bd1 100644
--- a/test/test_evaluator.c
+++ b/test/test_evaluator.c
@@ -17,8 +17,7 @@ static void test_basic_evaluation(void** state) {
 
     tokenize(expr, &context);
     ParseResult result = parse(&context);
-    AST tree = result.tree;
-    uint64_t value = evaluate(tree.head);
+    int64_t value = evaluate(result);
 
     assert_int_equal(value, 82);
 }
diff --git a/test/test_parser.c b/test/test_parser.c
index 7b1f36c..0fe3c20 100644
--- a/test/test_parser.c
+++ b/test/test_parser.c
@@ -19,58 +19,57 @@ static void test_parsing_basic_expression(void **state) {
     assert_int_equal(tokens.len, 7);
 
     ParseResult result = parse(&tokens);
-    AST tree = result.tree;
     // Assert head is +
-    assert_int_equal(tree.head->type, NODE_BINARY_OP);
-    assert_int_equal(tree.head->data.binary.op, OP_ADD);
+    assert_int_equal(result.tree->type, NODE_BINARY_OP);
+    assert_int_equal(result.tree->data.binary.op, OP_ADD);
 
-    assert_int_equal(tree.head->data.binary.left->type, NODE_INTEGER);
-    assert_int_equal(tree.head->data.binary.left->data.integer, 2);
+    assert_int_equal(result.tree->data.binary.left->type, NODE_INTEGER);
+    assert_int_equal(result.tree->data.binary.left->data.integer, 2);
 
 
     assert_int_equal(
-            tree.head->data.binary.right->type,
+            result.tree->data.binary.right->type,
             NODE_BINARY_OP
             );
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.op, 
+            result.tree->data.binary.right->data.binary.op, 
             OP_MUL
             );
 
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.right->type,
+            result.tree->data.binary.right->data.binary.right->type,
             NODE_INTEGER);
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.right->data.integer,
+            result.tree->data.binary.right->data.binary.right->data.integer,
             789);
 
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.left->type, 
+            result.tree->data.binary.right->data.binary.left->type, 
             NODE_BINARY_OP
             );
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.left->data.binary.op, 
+            result.tree->data.binary.right->data.binary.left->data.binary.op, 
             OP_DIV
             );
 
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.left->data.binary.right->type, 
+            result.tree->data.binary.right->data.binary.left->data.binary.right->type, 
             NODE_INTEGER
             );
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.left->data.binary.right->data.integer, 
+            result.tree->data.binary.right->data.binary.left->data.binary.right->data.integer, 
             66
             );
 
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.left->data.binary.left->type, 
+            result.tree->data.binary.right->data.binary.left->data.binary.left->type, 
             NODE_INTEGER
             );
     assert_int_equal(
-            tree.head->data.binary.right->data.binary.left->data.binary.left->data.integer, 
+            result.tree->data.binary.right->data.binary.left->data.binary.left->data.integer, 
             3
             );
-    arena_destroy(result.arena);
+    arena_destroy(&result.arena);
 }
 
 int main(void) {