Contenido del curso
Construcción del lexer o tokenizador
- 3

Análisis Léxico: Construcción de un Léxer para Intérpretes
05:35 min - 4

Definición de Tokens en Lenguaje de Programación Platzi
11:53 min - 5

Desarrollo de un Lexer con Test-Driven Development
15:42 min - 6

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python
10:01 min - 7

Lexer: Identificación de Keywords y Tokens Complejos
18:57 min - 8

Reconocimiento de Funciones en Lexer de Lenguaje de Programación
07:46 min - 9

Implementación de Operadores y Condicionales en Lexer de Platzi
12:38 min - 10

Implementación de Operadores de Dos Caracteres en Lexer
12:07 min - 11

Creación de un REPL en Python para Lenguaje de Programación
12:35 min
Construcción del parser o analizador sintáctico
- 12

Construcción de un Parser para el Lenguaje Platzi
05:22 min - 13

Definición de Nodos Abstractos para Árbol de Sintaxis (AST) en Python
09:14 min - 14

Desarrollo de un AST en Python: Creación de la Clase Programa
12:48 min - 15

Parseo de Let Statements en Lenguaje Platzi
20:21 min - 16

Implementación de funciones advanced y expected tokens
08:26 min - 17

Manejo de Errores en Parsers con Test Driven Development
11:06 min - 18

Parseo de Return Statements en Lenguaje Platzi
12:42 min - 19

Técnicas de Parsing: Top-Down y Bottom-Up
01:46 min - 20

Pruebas de AST para Let y Return Statements en Parsers
12:05 min - 21

Pratt Parsing: Implementación y Registro de Funciones en Python
11:47 min - 22

Parseo de Identificadores en Lenguajes de Programación
13:29 min - 23

Parseo de Expression Statements en Platzi Parser
16:33 min - 24

Parseo de Enteros en Lenguaje Platzi
14:03 min - 25

Implementación de Operadores Prefijo en Parsers
16:43 min - 26

Operadores InFix en Expresiones: Implementación y Pruebas
10:40 min - 27

Implementación de Operadores InFix en un Parser
20:20 min - 28

Expresiones Booleanas en el Lenguaje de Programación Platzi
13:00 min - 29

Evaluación de Precedencia y Testeo de Booleanos en Parsers
08:39 min - 30

Evaluación de Expresiones Agrupadas en un Parser
10:16 min - 31

Parseo de Condicionales en Lenguaje Platzi
13:50 min - 32

Implementación de Condicionales en Parser de Lenguaje
12:05 min - 33

Parsing de Funciones en Lenguaje Platzi: Creación de Nodos AST
15:51 min - 34

Construcción de nodos de función en un parser AST
15:43 min - 35

Llamadas a Funciones en Lenguajes de Programación
13:05 min - 36

Implementación de llamadas a funciones en un parser con AST
12:21 min - 37

Parseo de Expresiones en LET y RETURN Statements
07:58 min - 38

Implementación de REPL para Árbol de Sintaxis Abstracta
08:59 min
Evaluación o análisis semántico
- 39

Evaluación Semántica en Lenguajes de Programación
03:42 min - 40

Estrategias de Evaluación en Lenguajes de Programación
09:18 min - 41

Representación de Nodos AST y Objetos en Python
14:17 min - 42

Evaluación de Expresiones en JavaScript y Python
19:39 min - 43

Implementación del Patrón Singleton para Booleanos y Nulos
11:52 min - 44

Evaluación de Prefijos en Lenguaje de Programación Platzi
14:41 min - 45

Evaluación de Expresiones Infix en Lenguaje Platzi
18:07 min - 46

Evaluación de Condicionales en Lenguaje de Programación Platzi
13:50 min - 47

Evaluación y Uso del Return Statement en Programación
Viendo ahora - 48

Manejo de Errores Semánticos en Lenguaje Platzi
21:04 min - 49

Declaración y Gestión de Variables en Lenguajes de Programación
13:55 min - 50

Manejo de Ambientes y Variables en Lenguajes de Programación
11:56 min - 51

Declaración de Funciones en Lenguaje de Programación Platzi
12:26 min - 52

Implementación de Llamadas a Funciones en PlatziLang
23:55 min
Mejora del intérprete
Siguientes pasos
Evaluación y Uso del Return Statement en Programación
Resumen
Cuando construyes tu propio lenguaje de programación, llega un punto crítico: implementar la capacidad de detener el flujo de ejecución y devolver un valor. Eso es exactamente lo que hace el return statement, y entender cómo funciona internamente te da una comprensión profunda de cómo operan los lenguajes que usas a diario.
¿Por qué el return statement detiene la ejecución del programa?
El return statement no solo devuelve un valor, sino que interrumpe por completo la evaluación de cualquier statement posterior [01:06]. Esto significa que aunque existan más líneas de código después del regresa, el evaluador las ignora por completo. Este comportamiento es fundamental para controlar el flujo de un programa y es consistente con lo que ocurre en lenguajes como Python, JavaScript o Go.
Para lograr esto en el intérprete, se necesitan tres modificaciones principales:
- Crear un nuevo objeto Return dentro del sistema de objetos.
- Transformar la función
evaluate_statementsen una más genérica llamadaevaluate_program[05:40]. - Generar una función especializada
evaluate_block_statementque detecte cuándo aparece un return y detenga la evaluación del bloque [07:22].
¿Cómo se diseñan los tests para el return statement?
Los tests cubren múltiples escenarios que validan el comportamiento esperado [02:06]:
- Literal simple:
regresa 10;debe devolver10. - Dos statements: si hay un return antes de otro statement, solo se devuelve el valor del return.
- Expresiones complejas:
regresa 3 * 6;debe devolver18, no evaluar nada posterior. - Condicionales anidados: cuando un return aparece dentro de un bloque
si, debe detener la ejecución de todo el bloque contenedor [03:30]. Si hay unregresa 1seguido de unregresa 0en bloques distintos, el resultado es1porque la ejecución se detuvo en ese punto.
¿Qué estructura tiene el objeto Return?
El objeto Return es sencillo pero esencial [04:32]. Su constructor recibe un valor de tipo objeto, aprovechando que todos los objetos del sistema implementan la interfaz con las funciones type e inspect. La función type devuelve un identificador de tipo return, mientras que inspect delega al propio valor interno, llamando su método inspect. Así se mantiene la consistencia del sistema de objetos.
python class Return(Object): def init(self, value: Object): self.value = value
def type(self) -> ObjectType: return ObjectType.RETURN def inspect(self) -> str: return self.value.inspect()
¿Cómo se modifica el evaluador para reconocer el return?
La función evaluate_program itera sobre cada statement del programa. Cuando el resultado de evaluar un statement es una instancia del objeto Return, se desempaqueta el valor y se devuelve de inmediato [06:20]. Este desempaquetado es clave: el programa no devuelve el objeto Return en sí, sino el valor que contiene.
¿Qué papel juega evaluate block statement?
A diferencia de evaluate_program, la función evaluate_block_statement no desempaqueta el objeto Return [07:50]. Cuando detecta que el tipo del resultado es return, simplemente lo propaga hacia arriba. Esto permite que los bloques anidados, como los de condicionales, pasen el return al nivel superior sin perder la señal de detención.
python def evaluate_block_statement(block: Block) -> Optional[Object]: result = None for statement in block.statements: result = evaluate(statement) if result is not None and result.type() == ObjectType.RETURN: return result return result
La detección del return statement dentro de la función principal evaluate funciona así [09:00]: se identifica el nodo AST como un ReturnStatement, se evalúa su return_value (que puede ser cualquier expresión, no solo una literal), y se envuelve el resultado en un objeto Return. Este objeto viaja por la cadena de evaluación hasta llegar a evaluate_program, donde finalmente se extrae el valor.
Un detalle importante durante la implementación fue un error al nombrar el objeto como result en lugar de return [10:05], lo que provocó que los tests fallaran hasta corregir el nombre. Este tipo de errores son comunes y refuerzan la importancia de ejecutar los tests de forma iterativa.
Con el return statement funcionando, el lenguaje ya puede detener la ejecución en cualquier punto, devolver literales, resultados de expresiones complejas y manejar correctamente bloques condicionales anidados. ¿Has implementado algún mecanismo similar en tus proyectos? Comparte tu experiencia en los comentarios.