Creación de un REPL en Python para Lenguaje de Programación

Curso de Creación de Lenguajes de Programación: Intérpretes

Contenido del curso

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción del lexer o tokenizador

Construcción del parser o analizador sintáctico

Evaluación o análisis semántico

Mejora del intérprete

Siguientes pasos

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0012:35

Creación de un REPL en Python para Lenguaje de Programación

Curso de Creación de Lenguajes de Programación: Intérpretes

Clase 11 de 58

Clase 11 / 58

Recursos

¿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_token para 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.

# 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 establecer main.py como 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!

Comentarios (9)9 comentarios

Fabián Vega Alcota

Hace 6 años

Aquí les dejo la mi solución al bug

Y como pueden ver con esto ya puede reconocer números como parte de una variable

Aquí el link al repositorio: https://github.com/FabianVegaA/sigmaF/tree/dev :)

Carlos Nexans

Hace 2 años

Me inspiró bastante la idea de dejarle un arte ASCII al Repl. Esta genial tu lenguaje por cierto!

Carlos Eduardo Gomez García

Vale, yo solucioné el problema de los números en los nombres de variables de esta forma:

Simplemente a la función _read_identifier le puse una validación para que el primer caracter sea una letra y ya depués puede leer letras y números, y funciona :D

def _read_identifier(self) -> str:

    initial_position = self._position
    
    if self._is_letter(self._character):

        while self._is_letter(self._character) or self._is_number(self._character):
            self._read_character()

    return self._source[initial_position:self._position]

Cosa graciosa, puse var creyendo que estaba en JavaScript xDDD Pero funciona jajaja

Carlos Pavajeau

Creo que el if para comprobar si el letra sobra ya que anteriormente llamas a la función is_letter para llamar read_identifier. Bueno, al menos si tienes esa comporbación como el profesor

Kenny Emmanuel Lajara Aquino

En los lenguajes de programación, las variables normalmente pueden contener números pero no pueden iniciar con ellos. Es esto se basa el bug. . Las soluciones propuestas por Fabián Vega Alcota y por RitaxMaster (ambas) validan bien. Aunque prefiero la de Fabián porque la de Ritax me parece redundante. . Ahh!! Y hablando de validar... Aquí les dejo mi test para validar no entienda como identificar una expresión que no comience con número.

    def test_identifier_cant_start_with_number(self) -> None:
        source: str = '1_foo;'
        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []
        for i in range(3):
            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.IDENTIFIER, '1_foo'),
            Token(TokenType.SEMICOLON, ';'),
            Token(TokenType.EOF, ''),
        ]

        self.assertIsNot(tokens, expected_tokens)
        self.assertEqual(len(tokens), 3)

Piero Rolando

Hace 5 años

Te quiero mucho David

Raúl Humberto Peñate Ramírez

Gracias profe, va quedando bonito:

luimarco daniel Carrascal Diaz

Hace 3 años

Jherom Chacon

Implementación del start_repl función

Miguel Angel Velazquez Romero

ya terminé mi lexer, pero antes de pasar al paser quiero implementar el reconocimiento de un ciclo for, pero me está resultando muy confuso tan solo hacer la función del lexer_test y no encuentro info en San Google.

Podrían apoyarme?

Alex Camacho

Profesor

¿Qué es lo que te resulta confuso? Si explicas a más detalle será más fácil ayudarte :D

Si lo dije, desde crear la función del lexer_test. Pero lo lo investigué y lo comprendí en estas horas.

Solo estaba confundido, creí que debía seguir la sintaxis de Python para que mi analizador léxico identificara mis tokens, pero ya comprendí que no es así, yo debo de crear mi propia sintaxis.

Ya que todo depende de mi reglas de diseño, es decir, cómo quiero que funcione el lenguaje, ya que todo lo que haga debo de encontrar encontrar una forma de interpretarlo después, aquí en el lexer solo se va a validar que se generen bien los token que necesitan, pero más adelante con el parser tendré que validar que se cumpla la sintaxis y en el evaluador validará que realmente el for funcione.

Mi solución al bug:

Dándo como resultado

Esteban Krauwezuk

Eso funciona, pero tu método tiene un comportamiento que está discrepando con el nombre que lleva, sería algo confuso para alguien que tenga que leer el código en el futuro, incluso para ti si lo vuelves a ver luego de un tiempo.

Ricardo Soler

Normalmente no se permite que los nombres de variable comiencen por numero. Esta solución permitiría variables con nombres como 1var o 2_variable.

Introducción al desarrollo de intérpretes y lenguajes de programación

Construcción de Intérpretes de Software en Python 3.8

Creación de Compiladores e Intérpretes con Lenguaje Platzi

Construcción del lexer o tokenizador

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

Definición de Tokens en Lenguaje de Programación Platzi

Desarrollo de un Lexer con Test-Driven Development

Pruebas de Operadores, Delimitadores y Fin de Archivo en Lexer Python

Lexer: Identificación de Keywords y Tokens Complejos

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

Implementación de Operadores y Condicionales en Lexer de Platzi

Implementación de Operadores de Dos Caracteres en Lexer

Creación de un REPL en Python para Lenguaje de Programación

Construcción del parser o analizador sintáctico

Construcción de un Parser para el Lenguaje Platzi

Definición de Nodos Abstractos para Árbol de Sintaxis (AST) en Python

Desarrollo de un AST en Python: Creación de la Clase Programa

Parseo de Let Statements en Lenguaje Platzi

Implementación de funciones advanced y expected tokens

Manejo de Errores en Parsers con Test Driven Development

Parseo de Return Statements en Lenguaje Platzi

Técnicas de Parsing: Top-Down y Bottom-Up

Pruebas de AST para Let y Return Statements en Parsers

Pratt Parsing: Implementación y Registro de Funciones en Python

Parseo de Identificadores en Lenguajes de Programación

Parseo de Expression Statements en Platzi Parser

Parseo de Enteros en Lenguaje Platzi

Implementación de Operadores Prefijo en Parsers

Operadores InFix en Expresiones: Implementación y Pruebas

Implementación de Operadores InFix en un Parser

Expresiones Booleanas en el Lenguaje de Programación Platzi

Evaluación de Precedencia y Testeo de Booleanos en Parsers

Evaluación de Expresiones Agrupadas en un Parser

Parseo de Condicionales en Lenguaje Platzi

Implementación de Condicionales en Parser de Lenguaje

Parsing de Funciones en Lenguaje Platzi: Creación de Nodos AST

Construcción de nodos de función en un parser AST

Llamadas a Funciones en Lenguajes de Programación

Implementación de llamadas a funciones en un parser con AST

Parseo de Expresiones en LET y RETURN Statements

Implementación de REPL para Árbol de Sintaxis Abstracta

Evaluación o análisis semántico

Evaluación Semántica en Lenguajes de Programación

Estrategias de Evaluación en Lenguajes de Programación

Representación de Nodos AST y Objetos en Python

Evaluación de Expresiones en JavaScript y Python

Implementación del Patrón Singleton para Booleanos y Nulos

Evaluación de Prefijos en Lenguaje de Programación Platzi

Evaluación de Expresiones Infix en Lenguaje Platzi

Evaluación de Condicionales en Lenguaje de Programación Platzi

Evaluación y Uso del Return Statement en Programación

Manejo de Errores Semánticos en Lenguaje Platzi

Declaración y Gestión de Variables en Lenguajes de Programación

Manejo de Ambientes y Variables en Lenguajes de Programación

Declaración de Funciones en Lenguaje de Programación Platzi

Implementación de Llamadas a Funciones en PlatziLang

Mejora del intérprete

Implementación de Strings en un Intérprete de Lenguaje de Programación

Operaciones de Concatenación y Comparación de Strings en Intérprete

Implementación de Funciones Built-in en Python

Implementación de Built-ins en el Lenguaje Platzi

Siguientes pasos

Desarrollo de Lenguaje de Programación y Estructuras de Datos en Python

Construcción de un Intérprete en Python desde Cero

Creación de un REPL en Python para Lenguaje de Programación