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

1

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

2

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

Construcción del lexer o tokenizador

3

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

4

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

5

Desarrollo de un Lexer con Test-Driven Development

6

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

7

Lexer: Identificación de Keywords y Tokens Complejos

8

Reconocimiento de Funciones en Lexer de Lenguaje de Programación

9

Implementación de Operadores y Condicionales en Lexer de Platzi

10

Implementación de Operadores de Dos Caracteres en Lexer

11

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

Construcción del parser o analizador sintáctico

12

Construcción de un Parser para el Lenguaje Platzi

13

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

14

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

15

Parseo de Let Statements en Lenguaje Platzi

16

Implementación de funciones advanced y expected tokens

17

Manejo de Errores en Parsers con Test Driven Development

18

Parseo de Return Statements en Lenguaje Platzi

19

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

20

Pruebas de AST para Let y Return Statements en Parsers

21

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

22

Parseo de Identificadores en Lenguajes de Programación

23

Parseo de Expression Statements en Platzi Parser

24

Parseo de Enteros en Lenguaje Platzi

25

Implementación de Operadores Prefijo en Parsers

26

Operadores InFix en Expresiones: Implementación y Pruebas

27

Implementación de Operadores InFix en un Parser

28

Expresiones Booleanas en el Lenguaje de Programación Platzi

29

Evaluación de Precedencia y Testeo de Booleanos en Parsers

30

Evaluación de Expresiones Agrupadas en un Parser

31

Parseo de Condicionales en Lenguaje Platzi

32

Implementación de Condicionales en Parser de Lenguaje

33

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

34

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

35

Llamadas a Funciones en Lenguajes de Programación

36

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

37

Parseo de Expresiones en LET y RETURN Statements

38

Implementación de REPL para Árbol de Sintaxis Abstracta

Evaluación o análisis semántico

39

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

40

Estrategias de Evaluación en Lenguajes de Programación

41

Representación de Nodos AST y Objetos en Python

42

Evaluación de Expresiones en JavaScript y Python

43

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

44

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

45

Evaluación de Expresiones Infix en Lenguaje Platzi

46

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

47

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

48

Manejo de Errores Semánticos en Lenguaje Platzi

49

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

50

Manejo de Ambientes y Variables en Lenguajes de Programación

51

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

52

Implementación de Llamadas a Funciones en PlatziLang

Mejora del intérprete

53

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

54

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

55

Implementación de Funciones Built-in en Python

56

Implementación de Built-ins en el Lenguaje Platzi

Siguientes pasos

57

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

58

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

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Evaluación de Precedencia y Testeo de Booleanos en Parsers

29/58
Recursos

¿Cómo abordar los desafíos de precedencia en el análisis sintáctico?

Con un sólido conocimiento en programación, estás listo para enfrentar challenges que desafiarán tu entendimiento sobre cómo los parsers manejan la precedencia y los tests booleanos. Estos ejercicios no solo te permitirán profundizar en el funcionamiento de un parser, sino que además, te ayudarán a entender cómo se ordenan las expresiones y cómo se evalúan.

¿Qué representa la precedencia en las expresiones?

La precedencia de operadores determina el orden en el que se evalúan las partes de una expresión. Es decir, los operadores tienen un orden de prioridad que dicta cómo se debe formar el árbol de análisis sintáctico (AST). Si la precedencia no se define correctamente, la evaluación del programa podría producir resultados incorrectos.

Por ejemplo, en la expresión -a * b:

  • Primero se agrupa -a debido a la mayor precedencia del operador negativo unario.
  • Luego, el resultado se multiplica por b.

Este tipo de consideraciones son fundamentales para que el parser sepa cómo agrupar las partes de una expresión correctamente.

¿Cómo implementar pruebas específicas para precedencia de operadores?

Crear un test que evalúe correctamente la precedencia de operadores es crucial. Aquí tienes un enfoque para realizarlo:

  1. Crear una lista de tuplas: Cada tupla debe contener:

    • Un string con la expresión original.
    • Un string con la expresión con el orden de precedencia esperado.
    • Un entero que indique el número de statements esperados.

    Ejemplo:

    tests = [
        ("-a * b", "((-a) * b)", 1),
        ("a + b / c", "(a + (b / c))", 1)
    ]
    
  2. Configurar el ciclo de prueba: Desempaqueta cada tupla y verifica que:

    • La cantidad de statements sea la esperada.
    • El resultado tenga el formato y orden correcto.
    for source, expected, expected_statements in tests:
        parsed_program = parser.parse(source)
        assert parsed_program.to_string() == expected
        assert len(parsed_program.statements) == expected_statements
    

¿Qué hacer con los booleanos pre-existentes en tests?

Con la capacidad de manejar booleanos en el parser, es momento de mejorar tus tests a través de dos retos adicionales:

  1. Modificar pruebas de expresiones prefijas: Añade pruebas para expresiones que incluyan booleanos. Ejemplo:

    • Incluir el test para -verdadero.
  2. Modificar pruebas de expresiones infijas: Examina las posibilidades de evaluaciones infijas con booleanos. Por ejemplo:

    • verdadero == verdadero.

Asegúrate de modificar los tests existentes para adaptarse a las nuevas capacidades del parser con el manejo de booleanos.

¿Cómo asegurar la calidad del código mediante tests?

La creación de tests es fundamental para garantizar un software libre de errores. A medida que aumentes los tests, generarás un conjunto de verificación más robusto que protege tu código contra bugs. Sin embargo, recuerda:

  • Aún con muchos tests, los bugs pueden ir y venir.
  • Cuando encuentres un error, crea un test que lo reproduzca.
  • Corrige el bug asegurándote de que el test recién creado se ejecute con éxito.

Finalmente, recuerda que las soluciones a estos desafíos están disponibles en GitHub, pero no dudes en compartir tus propios métodos. De esta manera, no solo mejorarás tus habilidades, sino que también contribuirás al aprendizaje colectivo. ¡A seguir programando!

Aportes 2

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Chicos, por si alguien aún no entiende muy bien cómo funciona el parseo de las expresiones, es decir, por qué ese -a * b; se transforma en ((-a) * b), hice un video explicando paso a paso cómo es que funciona el parser justo con este ejemplo, es decir, voy ejecutando y explicando paso por paso las instrucciones que se ejecutan para llegar a ese resultado, igual te permite entender cómo funciona el parser en general, por si a alguien le sirve, acá se los dejo:
.

Reto completado BJ Y gracias a RetaxMaster por el video que hizo, me quedó mucho más entendido como funciona nuestro parser