Evaluación de Expresiones Agrupadas en un Parser

¿Cómo se evalúan las expresiones y declaraciones en un AST?

Entender cómo se construye y evalúa un Árbol de Sintaxis Abstracta (AST) es crucial para desarrollar un lenguaje de programación. Este árbol es fundamental en la representación de la estructura de un código fuente. Inicialmente, es importante entender que los paréntesis determinan el orden de evaluación y es algo que observaremos al construir nuestro evaluador en futuras lecciones.

¿Cuál es el orden de evaluación estándar de las expresiones?

El orden en el que se evalúan las expresiones en un AST imitador sigue las convenciones de los lenguajes de programación usuales. Digamos que tenemos algo como 3 + 4 / 5 * 7 + 10. Por defecto, se evaluaría como:

1. 4 dividido entre 5.
2. El resultado multiplicado por 7.
3. Al resultado de la multiplicación sumarle 3.
4. Finalmente, sumar 10 al resultado anterior.

Los lenguajes de programación se basan en este orden para evaluar las operaciones de forma sistemática.

¿Cómo modificar el orden de evaluación usando paréntesis?

Si queremos alterar el orden de evaluación estándar, empleamos paréntesis. Por ejemplo, al enfrentar 5 * (2 + 5), primero se evalúa 2 + 5, y luego ese resultado se multiplica por 5. En contraposición, sin paréntesis, la operación sería: multiplicar 5 por 2 y luego sumar 5.

La modificación del orden mediante paréntesis permite:

• Personalizar el flujo lógico de las operaciones.
• Asegurar que ciertas operaciones se evalúen primero.

¿Cómo implementar cambios en el parser?

En el parser, para tratar correctamente las expresiones agrupadas por paréntesis se necesitan ciertos ajustes en el código. Aquí hay un flujo general de cómo puede hacerse:

1. Registrar un prefijo para el paréntesis izquierdo: Esto permite que cuando se encuentre un paréntesis izquierdo, el parser sepa que viene una expresión agrupada.

   register_prefix(token_type=PARENTHESIS_LEFT, fn=parse_group_expression)
   

2. Crear función para expresiones agrupadas: parse_group_expression se encarga de manejar la evaluación de estas expresiones.

   def parse_group_expression():
       # Avanzar al siguiente token
       next_token()
       # Crear una nueva expresión con precedencia más baja
       expression = parse_expression(precedence=LOWEST)
       # Verificar token esperado (paréntesis derecho)
       if not is_expected_token(PARENTHESIS_RIGHT):
           return None
       return expression
   

Ejemplo de pruebas para expresiones agrupadas

Pruebas adicionales ayudan a asegurar que el parser evalúe correctamente:

• Test de prioridad entre operaciones similares: Implementar pruebas donde, por ejemplo, a + (b * c) sea evaluado correctamente diferente a a + b * c.

• Errores sintácticos al no cerrar paréntesis: Probar escenarios donde un paréntesis no cerrado genere errores de sintaxis.

Al agregar estas pruebas, es mejor comprarlas con errores que producen otros lenguajes, como Python o JavaScript, para tener una visión más amplia y práctica de cómo los distintos parsers manejan situaciones similares.

¿Cómo afecta esto el desarrollo de un lenguaje?

El correcto manejo de los paréntesis y el orden de evaluación es fundamental en la construcción del evaluador de un lenguaje de programación. Nos permite definir cómo los desarrolladores utilizarán el lenguaje, cómo las operaciones se calcularán y cómo los errores se manejarán. Esto partiendo de un correcto diseño del parser, que acto seguido influye en la usabilidad y eficacia del lenguaje como tal.

Por último, se invita a los estudiantes a probar modificaciones en sus tests y compartir sus experiencias, además de comparar con otros lenguajes. Este es un ejercicio excelente para familiarizarse con problemas comunes y su resolución en distintos entornos. Recuerda: cada pequeño paso en el aprendizaje es vital para crear un lenguaje sólido y eficiente. ¡Sigamos construyendo juntos el lenguaje de programación Platzi!