Creación de un REPL en Python para Lenguaje de Programación
Clase 11 de 58 • Curso de Creación de Lenguajes de Programación: Intérpretes
Contenido del curso
- 3

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

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

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

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

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

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

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

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

Creación de un REPL en Python para Lenguaje de Programación
12:35
- 12

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

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

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

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

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

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

Parseo de Return Statements en Lenguaje Platzi
12:42 - 19
Técnicas de Parsing: Top-Down y Bottom-Up
01:46 - 20

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

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

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

Parseo de Expression Statements en Platzi Parser
16:34 - 24

Parseo de Enteros en Lenguaje Platzi
14:03 - 25

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

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

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

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

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

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

Parseo de Condicionales en Lenguaje Platzi
13:50 - 32

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

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

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

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

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

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

Implementación de REPL para Árbol de Sintaxis Abstracta
08:59
- 39

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

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

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

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

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

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

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

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

Evaluación y Uso del Return Statement en Programación
14:42 - 48

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

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

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

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

Implementación de Llamadas a Funciones en PlatziLang
23:55
¿Cómo interactuar directamente con un Lexer utilizando un REPL?
El funcionamiento de un Lexer es fascinante, pero, llegó el momento de avanzar y poder trabajar con él de manera directa a través de los comandos. Imagina generar o inventar cualquier tipo de expresión y ver cómo el Lexer las procesa correctamente. Para esto, contamos con los REPL (Read, Evaluate, Print, Loop). Aunque aún no evaluaremos expresiones, podemos generar una versión inicial para interactuar con nuestro lenguaje de programación Platzi. Exploremos cómo construir este entorno de ejecución interactiva.
¿Cómo configuramos un REPL en Python?
Para crear un REPL en Python, comenzamos con algunos pasos esenciales:
-
Crear Archivos Principales:
- REPL.py: Contendrá la lógica para recibir strings, convertirlos en tokens y eventualmente en un AST para evaluación futura.
- main.py: Actuará como el punto de entrada para ejecutar el REPL.
-
Importar Componentes Necesarios:
- Importar el lexer de nuestro lenguaje y otros componentes esenciales como definiciones de token.
-
Implementar Funcionalidades del REPL:
- Crear constantes como
endoffile_tokenpara definir los límites de procesamiento. - Utilizar el operador 🦭 (walrus operator en Python 3.8) para asignar y validar variables dentro del bucle, permitiendo una interacción fluida al ingresar comandos.
- Crear constantes como
# Implementación básica del REPL
def start_repl():
while (source := input('>> ')) != 'salir':
lexer = Lexer(source)
while (next_token := lexer.next_token()) != endoffile_token:
print(next_token)
¿Cómo integrar REPL en el archivo principal y ejecutarlo?
En este paso culminaremos enlazando nuestra implementación inicial del REPL con el archivo principal (main.py).
- Punto de Entrada: Usar
if __name__ == '__main__'para establecermain.pycomo el punto de inicio. - Función principal: Definir una función principal (
main) que dará la bienvenida e instrucciones al usuario, y luego iniciará el REPL.
# Archivo main.py
import repl
def main():
print("Bienvenido al lenguaje de programación Platzi.")
print("Escribe una oración para comenzar")
repl.start_repl()
if __name__ == '__main__':
main()
¿Qué más puedes explorar y cómo resolver desafíos?
Hasta aquí, tu REPL debería estar funcionando para recibir comandos y lexeando correctamente las expresiones. Sin embargo, podemos enfrentarnos a bugs, como con los identificadores que contienen guiones bajos, lo cual es un reto común.
- Resolver Errores: Encontrar y solucionar esos errores mejora tus habilidades técnicas. Considera probar diferentes tipos de entradas y ajustar el Lexer según se requiera.
- Comparar Soluciones: Consulta soluciones en GitHub para ampliar tu perspectiva y ver cómo otros han resuelto problemas similares.
El camino hacia el aprendizaje de los lenguajes de programación está lleno de logros y retos, pero cada paso que das te acerca más a entender y desarrollar plataformas complejas. Desde aquí, anima a continuar con el parser y transformar tokens en AST, profundizando en la mecánica de los intérpretes. ¡Sigue avanzando en este emocionante aprendizaje!