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

Clase 4 de 58 • Curso de Creación de Lenguajes de Programación: Intérpretes

Resumen

¿Cómo definir los primeros tokens en un lenguaje de programación?

Definir tokens es un paso crucial para desarrollar cualquier lenguaje de programación. En el caso del lenguaje de programación Platzi (LPP), iniciaremos definiendo un subconjunto que incluye números, variables, identificadores (o identifiers en inglés), palabras clave (keywords) y varios caracteres especiales. Estos elementos constituyen la base sobre la cual crearemos nuestros primeros tokens. Aprenderemos a generar un archivo token.py, donde definiremos dos clases: tipo de token y token en sí mismo. Utilizaremos enumeraciones (enums) para diferenciar una lista de valores finitos, y aprovecharemos la clase namedtuple de typing para mejorar la definición de tokens.

¿Cuál es el proceso para empezar a definir tokens?

Crear un archivo token.py: Este archivo será el núcleo de nuestras definiciones. Empezaremos por importar los módulos necesarios.
```
from enum import Enum, auto, unique
from typing import NamedTuple
```

Definir la clase TokenType: Creamos una clase que contenga los diferentes tipos de tokens que usaremos.

@unique
class TokenType(Enum):
    ASSIGN = auto()
    COMMA = auto()
    EOF = auto()  # End of file
    FUNCTION = auto()
    IDENT = auto()  # Identifier
    ILLEGAL = auto()
    INT = auto()
    LEFT_BRACE = auto()
    LET = auto()
    LEFT_PAREN = auto()
    PLUS = auto()
    RIGHT_BRACE = auto() 
    RIGHT_PAREN = auto()
    SEMICOLON = auto()

Crear la clase Token: Utilizamos NamedTuple para definir la estructura de nuestros tokens.
```
class Token(NamedTuple):
    token_type: TokenType
    literal: str
```
Agregar métodos adicionales: Integramos el método especial __str__ para controlar cómo se imprime el Token.
```
def __str__(self) -> str:
    return f"Type: {self.token_type}, Literal: {self.literal}"
```

¿Cómo preparar el entorno de desarrollo?

Antes de comenzar a programar, necesitamos preparar nuestro entorno con Python 3.8. Para ello, seguiremos estos pasos:

Crear un ambiente virtual: Nos aseguramos de que todo el trabajo de desarrollo esté aislado.
```
python3.8 -m venv bnb
source bnb/bin/activate
```
Instalar las dependencias necesarias: Lo haremos a través del archivo requirements.txt que contiene nose para tests y mypy para tipado.
```
pip3 install -r requirements.txt
```

¿Cómo administrar el control de versiones con git?

Es esencial organizar nuestro proyecto usando git. Configuramos ramas dedicadas para dividir el trabajo y asegurar la estabilidad de nuestra base de código.

Comprobar la rama actual: Utilizar la rama main como base.
```
git branch
```
Cambiar o crear una nueva rama:
```
git checkout -b define-tokens
```

¿Dónde encontrar recursos adicionales y resúmenes de código?

Para facilitar el aprendizaje, el código fuente completo y otros recursos estarán disponibles en GitHub. Busca la información relacionada en los comentarios del curso o consulta el repositorio directamente.

Recuerda, definir tus propios tokens y comprenden su propósito es vital en el viaje de construir un lenguaje de programación. La simplicidad y claridad son aliados a lo largo de este proceso, así que no dudes en revisar y practicar. A medida que avancemos, el concepto de tokens y su implementación se aclararán. ¡Sigue adelante!