Operadores de dos caracteres

Hice varios cambios a mi código, en sí estoy creando o más bien intentando crear un lenguaje que llamaré SigmaF, tengo planeado que sea del paradigma funcional, y está muy basada en Haskell, un lenguaje que me gusta bastante.
Aquí les dejo un link a mi repositorio, por si tienen curiosidad o si les intereso mi proyecto 😉
https://github.com/FabianVegaA/sigmaF/tree/dev

Vengo del futuro a extender los tokens que acepta el Lexer (para tener un lenguaje con más operadores, no es spoiler 😄) para que ahora acepte <= y >= (menor o igual que) y “mayor o igual que”:
.
Primero, tenemos que añadir los tokens a la lista de tokens en token.py:
.

GE = auto() # Gretater Than or Equal To (>=)
LE = auto() # Less Than or Equal To (<=)

.
Después, en los matches donde revisamos los caracteres “<” y “>”, tenemos que agregar las condicionales para aceptar los tokens de doble caracter:

elif match(r"^<$", self._character):

    # Aquí revisamos si el siguiente token es "=", por lo que tendríamos un "<="
    if self._peek_character() == "=":
        token = self._make_two_character_token(TokenType.LE)

    else:
        token = Token(TokenType.LT, self._character)

elif match(r"^>$", self._character):

    # Aquí revisamos si el siguiente token es "=", por lo que tendríamos un ">="
    if self._peek_character() == "=":
        token = self._make_two_character_token(TokenType.GE)

    else:
        token = Token(TokenType.GT, self._character)

Con eso basta por ahora, no es necesario, pero recomiendo agregar los tests al lexer, pueden ver mis tests para estos operadores aquí:
.
Test Two Characters Operators
.
Durante el curso no se hace ninguna implementación para estos operadores (el LPP original del profesor no los soporta), pero pueden ir buscando mis aportes donde yo les iré dando el código junto con sus tests para que puedan implementar estos operadores al LPP 😄. Yo ya tengo el lenguaje funcionando con estos operadores así que trust me jaja

Pongo el código de mi Lexer.

from re import match
from cantte.token import TokenType, Token, lookup_token_type


class Lexer:
    def __init__(self, source: str) -> None:
        self._source: str = source
        self._character: str = ''
        self._read_position: int = 0
        self._position: int = 0

        self._read_character()

    def next_token(self) -> Token:
        self._skip_whitespace()

        if self._is_letter(self._character):
            ident_literal: str = self._read_identifier()
            token_type = lookup_token_type(ident_literal)
            token = Token(token_type, ident_literal)
        elif self._is_number(self._character):
            num_literal: str = self._read_number()
            token = Token(TokenType.INT, num_literal)
        else:
            token_type = self._get_token_type()
            if token_type == TokenType.EQUAL or token_type == TokenType.NOT_EQUAL:
                token = self._make_two_character_token(token_type)
            else:
                token = Token(token_type, self._character)
            self._read_character()

        return token

    def _get_token_type(self):
        if match(r'^=$', self._character):
            if self._peek_character() == '=':
                token_type = TokenType.EQUAL
            else:
                token_type = TokenType.ASSIGN
        elif match(r'^\+$', self._character):
            token_type = TokenType.PLUS
        elif match(r'^-$', self._character):
            token_type = TokenType.MINUS
        elif match(r'^\*$', self._character):
            token_type = TokenType.MULTIPLICATION
        elif match(r'^/$', self._character):
            token_type = TokenType.DIVISION
        elif match(r'^$', self._character):
            token_type = TokenType.EOF
        elif match(r'^\($', self._character):
            token_type = TokenType.LPAREN
        elif match(r'^\)$', self._character):
            token_type = TokenType.RPAREN
        elif match(r'^{$', self._character):
            token_type = TokenType.LBRACE
        elif match(r'^}$', self._character):
            token_type = TokenType.RBRACE
        elif match(r'^,$', self._character):
            token_type = TokenType.COMMA
        elif match(r'^;$', self._character):
            token_type = TokenType.SEMICOLON
        elif match(r'^<$', self._character):
            token_type = TokenType.LESS_THAN
        elif match(r'^>$', self._character):
            token_type = TokenType.GREATER_THAN
        elif match(r'^!$', self._character):
            if self._peek_character() == '=':
                token_type = TokenType.NOT_EQUAL
            else:
                token_type = TokenType.NEGATION
        else:
            token_type = TokenType.ILLEGAL

        return token_type

    @staticmethod
    def _is_letter(character: str) -> bool:
        return bool(match(r'^[a-zA-ZñÑ_]$', character))

    @staticmethod
    def _is_number(character: str) -> bool:
        return bool(match(r'^\d$', character))

    def _make_two_character_token(self, token_type: TokenType) -> Token:
        prefix = self._character
        self._read_character()
        suffix = self._character

        return Token(token_type, f'{prefix}{suffix}')

    def _peek_character(self) -> str:
        if self._read_position >= len(self._source):
            return ''
        return self._source[self._read_position]

    def _read_identifier(self) -> str:
        initial_position = self._position

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

        return self._source[initial_position:self._position]

    def _read_character(self) -> None:
        if self._read_position >= len(self._source):
            self._character = ''
        else:
            self._character = self._source[self._read_position]

        self._position = self._read_position
        self._read_position += 1

    def _read_number(self) -> str:
        initial_position = self._position

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

        return self._source[initial_position:self._position]

    def _skip_whitespace(self) -> None:
        while match(r'^\s$', self._character):
            self._read_character()

Wohh!! Acabo de extender el lexer para añadir un operador de triple igualdad y de diferenciación, los típicos de === y !===
.
Primero escribí los tests, para este caso quise esribir dos tests, uno para probar la triple igualdad y otro para porbar la mezcla de los dobles y triples:

    def test_three_character_operator(self) -> None:

        source: str = """
            10 === 10;
            10 !== 9;
        """

        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []

        for i in range(8):

            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.INT, "10"),
            Token(TokenType.SIMILAR, "==="),
            Token(TokenType.INT, "10"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.DIFF, "!=="),
            Token(TokenType.INT, "9"),
            Token(TokenType.SEMICOLON, ";"),
        ]

        self.assertEquals(tokens, expected_tokens)


    def test_mixed_character_operator(self) -> None:

        source: str = """
            10 === 10;
            10 !== 9;
            10 == 10;
            10 != 9;
        """

        lexer: Lexer = Lexer(source)

        tokens: List[Token] = []

        for i in range(16):

            tokens.append(lexer.next_token())

        expected_tokens: List[Token] = [
            Token(TokenType.INT, "10"),
            Token(TokenType.SIMILAR, "==="),
            Token(TokenType.INT, "10"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.DIFF, "!=="),
            Token(TokenType.INT, "9"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.EQ, "=="),
            Token(TokenType.INT, "10"),
            Token(TokenType.SEMICOLON, ";"),
            Token(TokenType.INT, "10"),
            Token(TokenType.NOT_EQ, "!="),
            Token(TokenType.INT, "9"),
            Token(TokenType.SEMICOLON, ";"),
        ]

        self.assertEquals(tokens, expected_tokens)

Luego agregué los tokens:

DIFF = auto() # Diferencia (!==)
SIMILAR = auto() # Triple igualdad (===)

Para hacerlos funcionar, modifiqué el lexer para el operador de asignación y de diferencia:

        if match(r"^=$", self._character):

            if self._peek_character() == "=":
                token = self._make_two_character_token(TokenType.EQ)

                if self._peek_character(2) == "=":
                    token = self._make_three_character_token(TokenType.SIMILAR)

                else:
                    token = self._make_two_character_token(TokenType.EQ)

Condición para el operador de diferencia:

        elif match(r"^!$", self._character):

            if self._peek_character() == "=":
                token = self._make_two_character_token(TokenType.NOT_EQ)

                if self._peek_character(2) == "=":
                    token = self._make_three_character_token(TokenType.DIFF)

                else:
                    token = self._make_two_character_token(TokenType.NOT_EQ)

            else:
                token = Token(TokenType.NEGATION, self._character)

Para este caso, tuve que modificar el método _peek_character para que aceptara cuántos espacios se quiere salltar:

def _peek_character(self, skip = 1) -> str:

        if self._read_position >= len(self._source):
            return ""

        return self._source[self._read_position] if skip == 1 else self._source[self._read_position + (skip - 1)] 

Y agregué otro método para que construyera el token de 3 caracteres:

def _make_three_character_token(self, token_type: TokenType) -> Token:

        first = self._character
        self._read_character()
        second = self._character
        self._read_character()
        third = self._character

        return Token(token_type, f"{first}{second}{third}")

Y con eso ya tu lexer ya acepta tokens de 3 caracteres como la triple igualdad o la diferenciación 😄

Estoy muy feliz con este curso, me está ayudando muchísimo en la materia de Compiladores de mi carrera universitaria, aunque tengo que traducir de Python a Java porque me piden que lo haga en Java,

Si hice algunos cambios, empezando por el test, se me hizo más sencillo validarlos en una única cadena separada por ;

Por otra parte decidí hacer el Diferente a usando <>

Al final todo ha funcionado perfecto