data.py

import re
from dataclasses import dataclass, field
from typing import Any


class TYPE():

    value: Any

    def external_representation(self):
        return str(self.value)

    def evaluate(self, env):
        return self, env

    @classmethod
    def from_string(cls, string):
        return cls(string)


class NUMBER(TYPE):
    pass


@dataclass(frozen=True, init=True, repr=True)
class INTEGER(NUMBER):

    value: int

    def __repr__(self) -> str:
        return f"INT[{str(self.value)}]"

    def external_representation(self):
        return str(self.value)

    @classmethod
    def from_string(cls, string):
        return cls(int(string))


@dataclass(frozen=True, init=True, repr=True)
class FLOAT(NUMBER):

    value: float

    def __repr__(self) -> str:
        return f"FLOAT[{str(self.value)}]"

    @classmethod
    def from_string(cls, string):
        return cls(float(string))


@dataclass(frozen=True, init=True, repr=True)
class BOOLEAN(TYPE):

    value: bool

    def __repr__(self) -> str:
        return "BOOL["+("t" if self.value else "f")+"]"

    @classmethod
    def from_string(cls, string):
        return cls(True if string == "#t" else False)


@dataclass(frozen=True, init=True, repr=True)
class STRING(TYPE):

    value: str

    def __repr__(self) -> str:
        return "STRING["+self.value+"]"


@dataclass(frozen=True, init=True, repr=True)
class SYMBOL(TYPE):

    value: str

    def __repr__(self) -> str:
        return "SYMBOL["+self.value+"]"

    def external_representation(self):
        return f"{self.value}"

    def evaluate(self, env):
        return env.get_symbol(self.value), env

# ----------------
# COMPLEX
# -----------------


def evaluate_tail(tail, env):

    tail_results = []

    for tail_element in tail:

        result, env = tail_element.evaluate(env)
        tail_results.append(result)

    return tail_results


def check_procedure_arguments(tail, num_arguments=None, arguments_with_type=None):

    assert num_arguments is not None or arguments_with_type is not None

    if num_arguments is not None:

        if not isinstance(num_arguments, list):
            num_arguments = [num_arguments]

        assert len(tail) in num_arguments

    elif arguments_with_type is not None:

        assert len(tail) == len(arguments_with_type)

        for tail_element, expected_type in zip(tail, arguments_with_type):

            assert isinstance(tail_element, expected_type)


@dataclass(frozen=True, init=True, repr=True)
class LIST(TYPE):

    parts: tuple  # list = field(default_factory=list)

    # def __init__(self, parts=None) -> None:
    #    self.parts = [] if parts is None else parts

    def __repr__(self):
        result = ""
        for part in self.parts:
            result += str(part)+" "
        return "LIST("+result+")"

    def __len__(self):
        return len(self.parts)

    def external_representation(self):
        return "(" + " ".join([part.external_representation() for part in self.parts]) + ")"


    @property
    def head(self):
        return self.parts[0] if self.parts else None

    @property
    def tail(self):
        return self.parts[1:] if len(self.parts) > 0 else None

    def evaluate(self, env):
        from lili_builtins import BUILTIN_FUNCTIONS, SPECIAL_FORMS

        head = self.head
        tail = self.tail

        if head is None:
            return (None, env)

        if isinstance(head, LIST):

            head, env = head.evaluate(env)  # evaluate_expression_tree(head, env)

        # TODO make dispatch logic on Symbols

        # TODO what if head is Atom or just a symbol like a?

        # if head.value in SPECIAL_FORMS:
        #    result, env = SPECIAL_FORMS[head.value](self, env)

        # elif head.value in BUILTIN_FUNCTIONS:
        #    result, env = BUILTIN_FUNCTIONS[head.value](self, env)
        # else:

        if isinstance(head, SYMBOL):
            head, env = head.evaluate(env)

        assert isinstance(head, PROCEDURE)

        # TODO could also be just a variable

        if isinstance(head, (FUNCTION, BUILTIN_FUNCTION)):
            # evaluated_tail = evaluate_tail(tail, env)

            # Function call gets the unevaluated tail as input!
            # result, env = head.evaluate(self, evaluated_tail, env)
            result, env = head.evaluate(tail, env)

        elif isinstance(head, PRIMITIVE):

            result, env = head.evaluate(tail, env)



        return result, env


class PROCEDURE(TYPE):
    pass


class FUNCTION(PROCEDURE):

    def __init__(self, argument_list, body) -> None:

        assert isinstance(argument_list, LIST)
        self.argument_list = argument_list.parts

        # TODO is argument list a list or a LIST?
        # Make sure the argument list consists of symbols!
        check_procedure_arguments(self.argument_list, arguments_with_type=[SYMBOL]*len(self.argument_list))

        assert isinstance(body, (SYMBOL, LIST))
        self.body = body

    def external_representation(self):
        rep = "lambda "
        rep += "(" + " ".join([sym.external_representation() for sym in self.argument_list]) + ") "
        rep += self.body.external_representation()

        return rep

    def evaluate(self, tail, env):

        assert isinstance(tail, (list, tuple))

        if len(tail) > 0:
            for tail_element in tail:
                assert isinstance(tail_element, TYPE)

        evaluated_tail = evaluate_tail(tail, env)
        assert len(evaluated_tail) == len(self.argument_list), "Function called with wrong argument list size!"

        # Create call stack
        env = env.nest_env()

        # Create local scope
        env.push_local()

        for argument, argument_name in zip(evaluated_tail, self.argument_list):
            env.define_symbol(argument_name.value, argument)

        result, env = self.body.evaluate(env)

        # Remove local scope
        env.pop_local()
        # Wrap up call stack
        env = env.unnest_env()

        return result, env


class BUILTIN_FUNCTION(PROCEDURE):

    def __init__(self, name, body) -> None:

        # assert isinstance(argument_list, LIST)
        # self.argument_list = argument_list.parts

        # TODO is argument list a list or a LIST?
        # Make sure the argument list consists of symbols!
        # check_procedure_arguments(self.argument_list, arguments_with_type=[SYMBOL]*len(self.argument_list))

        # assert isinstance(body, (SYMBOL, LIST))
        self.name = name
        self.body = body

    def external_representation(self):
       return f"BUILTIN_FUNCTION({self.name})"

    def evaluate(self, tail, env):

        assert isinstance(tail, (list, tuple))

        if len(tail) > 0:
            for tail_element in tail:
                assert isinstance(tail_element, TYPE)

        evaluated_tail = evaluate_tail(tail, env)
        # assert len(evaluated_tail) == len(self.argument_list), "Function called with wrong argument list size!"

        # Create call stack
        # env = env.nest_env()

        # Create local scope
        # env.push_local()

        # for argument, argument_name in zip(evaluated_tail, self.argument_list):
        #    env.define_symbol(argument_name.value, argument)

        result, env = self.body(evaluated_tail, env)

        # Remove local scope
        # env.pop_local()
        # Wrap up call stack
        # env = env.unnest_env()

        return result, env

class MACRO(PROCEDURE):
    pass


class PRIMITIVE(PROCEDURE):

    def __init__(self, name, body) -> None:

        # assert isinstance(argument_list, LIST)
        # self.argument_list = argument_list.parts

        # TODO is argument list a list or a LIST?
        # Make sure the argument list consists of symbols!
        # check_procedure_arguments(self.argument_list, arguments_with_type=[SYMBOL]*len(self.argument_list))

        # assert isinstance(body, (SYMBOL, LIST))
        self.name = name
        self.body = body

    def external_representation(self):
       return f"PRIMITIVE({self.name})"

    def evaluate(self, tail, env):

        result, env = self.body(tail, env)

        return result, env