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

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

51/58
Recursos

¿Cómo declarar funciones en un intérprete?

Las funciones son una parte esencial de cualquier lenguaje de programación. No solo facilitan la reutilización del código, sino que también organizan el flujo del mismo de manera coherente. En el contexto de crear un intérprete, las funciones deben poder declararse y ejecutarse adecuadamente. Veamos cómo:

¿Cuáles son los componentes de una función?

Cada función tiene tres componentes principales:

  1. Parámetros: una lista de identificadores como x, y, z, etc.
  2. Cuerpo: un bloque de statements o instrucciones que la función ejecuta.
  3. Retorno: el resultado que devuelve la función después de su ejecución.

¿Cómo se implementan las funciones?

La implementación de funciones en un intérprete implica varios pasos. Primero, tenemos que declarar la función utilizando un keyword, como procedimiento, y luego programar cómo el intérprete evalúa estas declaraciones y llamadas de funciones.

Paso 1: Declarar la función

Para implementar funciones, primero necesitamos un test que declarará la función como un programa. Este test debe tener:

  • Una lista de parámetros.
  • Un cuerpo de la función que consiste en un bloque de código, por ejemplo, x + 2.
def test_function_evaluation():
    # Declarando la función con un parámetro y un cuerpo.
    procedimiento = Function(parameters=['x'], body='x + 2')
    # El cuerpo debería procesarse como un bloque.

Paso 2: Generar el objeto función

Los elementos del programa, como funciones, se convierten en objetos. Un objeto función tendrá:

  • Parámetros: que son una lista de identificadores.
  • Cuerpo: que es un bloque de código.
  • Ambiente: donde se ejecuta la función, su contexto de variables.
class Function(Object):
    def __init__(self, parameters, body, environment):
        self.parameters = parameters
        self.body = body
        self.environment = environment

    def tipo(self):
        return ObjectType.FUNCTION

    def inspect(self):
        params = ", ".join(str(param) for param in self.parameters)
        return f"procedimiento({params}) {{\n{str(self.body)}\n}}"

¿Cómo se evalúan las funciones?

En la clase, se habló sobre cómo modificar el evaluador para manejar las funciones adecuadamente. Esto incluye importar la función y actualizar el método evaluate para reconocer los nodos de las funciones y regresarlos como objetos función.

def evaluate(node, environment):
    if node.type == 'FUNCTION':
        return Function(parameters=node.parameters, body=node.body, environment=environment)
    # Otro código para evaluar diferentes nodos...

¿Por qué es importante entender este proceso?

El diseño e implementación de funciones no solo son vitales para completar un intérprete, sino que también demuestran la interconectividad de la lógica del software en un sistema más complejo. Al dominar este tema, se mejoran las habilidades de programación, se crea comprensión profunda de bases como el manejo de objetos y ambientes, y se avanza en la creación de un lenguaje de programación, transformando la abstracción en algo más tangible.

Recomendaciones prácticas

  • Prueba tus funciones en un REPL (Read-Eval-Print Loop): Esta herramienta interactiva te permite ver rápidamente cómo las funciones que declares serán evaluadas por el intérprete, proporcionando información clara y directa.
  • Experimenta con diferentes cuerpos de funciones: Probando diversas lógicas dentro del cuerpo de una función te ayudará a entender mejor los alcances y limitaciones del contexto en el que operan.
  • Aprovecha el enfoque de Test Driven Development (TDD): Como se mencionó, imaginar las propiedades de las funciones a través de tests facilita su concreción y asegura que el código cumpla con las expectativas desde el inicio.

El viaje para crear tu propio lenguaje de programación es desafiante pero igualmente gratificante. Sigue profundizando en conceptos avanzados, practica mucho, y pronto verás cómo cobra vida tu creación. ¡El entusiasmo es clave!

Aportes 2

Preguntas 0

Ordenar por:

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

En la versión 3.10 de Python (que está por salir) se incluirá match que hace justo la tarea de un switch.
Más info aquí.

Bueno, el declarado pasa pero el llamado aún vamos a ello jaja
.

Básicamente lo que hicimos ahora fue crear el objeto función y ya me imagino cómo será la llamada 👀