rising-stretch 0.0.3__tar.gz

rising_stretch-0.0.3/.gitignore

@@ -0,0 +1,2 @@
+# Created by venv; see https://docs.python.org/3/library/venv.html
+*

rising_stretch-0.0.3/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: rising-stretch
+Version: 0.0.3
+Summary: a custom interpreter for a modular/extendable super simple programming language called stretch
+Author-email: rising <risingwanabe@gmail.com>
+Maintainer-email: rising <risingwanabe@gmail.com>
+Requires-Dist: rising-garnish

rising_stretch-0.0.3/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+
+[project]
+name = "rising-stretch"
+version = "0.0.3"
+description = "a custom interpreter for a modular/extendable super simple programming language called stretch"
+authors = [
+  { name = "rising", email = "risingwanabe@gmail.com" },
+]
+maintainers = [
+  { name = "rising", email = "risingwanabe@gmail.com" },
+]
+dependencies = ["rising-garnish"]
+
+
+[tool.hatch.envs.default]
+dependencies = [ "rising-garnish", ]
+
+[tool.hatch.build]
+include = ["stretch"]
+
+[project.scripts]
+stretch = "stretch.command:run"

rising_stretch-0.0.3/stretch/__init__.py

@@ -0,0 +1,10 @@
+from .interpreter import CoreProcessor
+from .scope_types import Module, Scope
+from .core_types import DotPath, RawToken, Alias, StretchSkipline, StretchTerminate, Stack
+import sys
+
+def run_stretch(dot_path):
+    processor = CoreProcessor()
+    module = Module(processor, DotPath(processor, dot_path))
+    processor.run_scope(module)
+    

rising_stretch-0.0.3/stretch/builtin_extensions/__init__.py

@@ -0,0 +1,11 @@
+import importlib
+
+imported = {}
+
+def __getattr__(extension_name):
+    if extension_name in imported:
+        extension = imported[extension_name]
+    else:
+        extension = importlib.import_module("." + extension_name, 'stretch.builtin_extensions')
+        imported[extension_name] = extension
+    return extension

rising_stretch-0.0.3/stretch/builtin_extensions/input.py

@@ -0,0 +1,20 @@
+
+from stretch.extension import Extender
+
+__extensions__ = Extender()
+with __extensions__ as extend:
+    @extend.term.use("in")
+    def get_input(proc, scope, tokens):
+        message = ""
+        if len(tokens) > 0:
+            message = tokens.pop(0)
+        if message != "":
+            message += "\n"
+        tokens.insert(0, input(message))
+        return tokens
+    @extend.term.use("int_in")
+    def get_int_input(proc, scope, tokens):
+        tokens = get_input(proc, scope, tokens)
+        tokens.insert(0, int(tokens.pop(0)))
+        return tokens
+    

rising_stretch-0.0.3/stretch/builtin_extensions/mathematics.py

@@ -0,0 +1,14 @@
+from stretch.extension import Extender
+
+__extensions__ = Extender()
+with __extensions__ as extend:
+    
+
+    
+    @extend.operator.use("*", "/")
+    def __mul__(proc, scope, l, r):
+        return l * r
+    
+    @extend.operator.use("/", "+")
+    def __div__(proc, scope, l, r):
+        return l / r

rising_stretch-0.0.3/stretch/command.py

@@ -0,0 +1,9 @@
+from . import run_stretch
+import sys
+
+
+def run():
+    if len(sys.argv) > 1:
+        run_stretch(sys.argv[1])
+    else:
+        print("Please enter the name of a stretch file to interpret it.")

rising_stretch-0.0.3/stretch/core.py

@@ -0,0 +1,193 @@
+from garnish import garnish
+from .core_types import DotPath, RawToken, StretchTerminate, Alias, StretchSkipline
+from .scope_types import Scope, Module
+import importlib
+from .precedence import PrecedenceGraph
+from . import builtin_extensions
+
+__operators__ = {}
+__operator_precedence__ = PrecedenceGraph()
+__terms__ = {}
+@garnish
+def operator(func, symbol:str, low=None, high=None):
+    if low is not None:
+        low = RawToken(low)
+    if high is not None:
+        high = RawToken(high)
+    __operators__[RawToken(symbol)] = func
+    __operator_precedence__.add(RawToken(symbol), low, high)
+    return func
+@garnish
+def term(func, term:str):
+    __terms__[term] = func
+    return func
+
+
+#OPERATORS
+@operator.use('.')
+def chain(proc, scope, l, r):
+    if isinstance(l, RawToken):
+        l = DotPath(l, scope=scope)
+    l.extend(r, scope=scope)
+    return l
+
+@operator.use('+', "-")
+def add(proc, scope, l, r):
+    return l + r
+
+@operator.use('-', "==")
+def subtract(proc, scope, l, r):
+    return l - r
+
+@operator.use('==')
+def is_eq(proc, scope, l, r):
+    return l == r
+@operator.use('!=')
+def not_eq(proc, scope, l, r):
+    return l != r
+@operator.use('>')
+def is_gt(proc, scope, l, r):
+    return l > r
+@operator.use('<')
+def is_lt(proc, scope, l, r):
+    return l < r
+
+
+#TERMS
+# error handling
+
+@term.use("shutdown")
+def shutdown(proc, scope, tokens):
+    proc.running = False
+    if len(tokens) > 0:
+        raise StretchTerminate(tokens.pop())
+    raise StretchTerminate()
+
+@term.use("raise")
+def error(proc, scope, tokens):
+    message = "error with no defined message"
+    if len(tokens) > 0:
+        message = tokens.pop(0)
+    message = f"[Line:'{scope.current_line}' in '{scope.name}'] {message}"
+    shutdown(proc, scope, [message])
+
+def expects(proc, scope, owner:str, tokens, type = None):
+    if not len(tokens) > 0:
+        error(proc, scope, [f"{owner} expected token, recieved nothing"])
+    elif type is not None and not isinstance(tokens[0], type):
+        error(proc, scope, [f"{owner} expected {type.__name__} in tokens, recieved {tokens}"])
+
+
+@term.use('as')
+def alias(proc, scope, tokens):
+    expects(proc, scope, "alias", tokens, RawToken)
+    return Alias(tokens.pop())
+    
+@term.use("Stack")
+def get_stack(proc, scope, tokens):
+    tokens.insert(0, proc.stack())
+    return tokens
+
+@term.use("print")
+def _print(proc, scope, tokens):
+    print(*tokens)
+    return tokens
+
+# control scope
+
+@term.use("import")
+def import_module(proc, scope, tokens):
+    if len(tokens) > 0:
+        if isinstance(tokens[0], DotPath):
+            dotpath = tokens.pop(0)
+        elif isinstance(tokens[0], RawToken):
+            dotpath = DotPath(tokens.pop(0), scope)
+        else:
+            error(proc, scope, [f"import expected DotPath or Alias to module, recieved {type(tokens[0]).__name__}: '{tokens[0]}'"])
+        module = Module(proc, dotpath)
+        proc.init_scope(module)
+        if isinstance(tokens[0], Alias):
+            name = tokens.pop(0).name
+            scope.store(name, module)
+        tokens.insert(0, module)
+        return tokens
+    else:
+        error(proc, scope, [f"import expected DotPath to module, recieved nothing"])
+
+@term.use("extend")
+def import_extension(proc, scope, tokens):
+    expects(proc, scope, "extend", tokens, (DotPath, RawToken))
+    dotpath = tokens.pop(0)
+    if isinstance(dotpath, RawToken):
+        dotpath = DotPath(dotpath, scope)
+    name = dotpath.file_name()
+    if name.startswith('@'):
+        extension = getattr(builtin_extensions, name[1:])
+    else:
+        extension = __import__(name)
+    if hasattr(extension, '__extensions__'):
+        extension.__extensions__.extend(proc, scope)
+    return tokens
+    
+@term.use("enter")
+def enter_scope(proc, scope, tokens):
+    expects(proc, scope, "enter", tokens, Module)
+    into = tokens.pop(0)
+    line = 0
+    if len(tokens) > 0 and isinstance(tokens[0], int):
+        line = tokens.pop(0) - 1
+    if into is scope:
+        scope.go_to(line)
+        raise StretchSkipline()
+
+    return proc.process_scope(into, line)
+          
+# control-flow  
+
+@term.use("Line")
+def get_line(proc, scope, tokens):
+    return scope.current_line + 1
+
+@term.use("True")
+def ret_true(proc, scope, tokens):
+    tokens.insert(0, True)
+    return tokens
+
+@term.use("False")
+def ret_false(proc, scope, tokens):
+    tokens.insert(0, False)
+    return tokens
+
+@term.use("if")
+def if_stat(proc, scope, tokens):
+    expects(proc, scope, "if", tokens, bool)
+    if not tokens.pop(0):
+        raise StretchSkipline()
+@term.use("unless")
+def unless_stat(proc, scope, tokens):
+    expects(proc, scope, "unless", tokens, bool)
+    if tokens.pop(0):
+        raise StretchSkipline()
+
+@term.use("goto")
+def goto(proc, scope, tokens):
+    expects(proc, scope, "goto", tokens, int)
+    
+    line = scope.current_line + 1
+    scope.current_line = tokens.pop() - 1
+    tokens.insert(0, line)
+    return tokens
+
+@term.use("Scope")
+def get_scope(proc, scope, tokens):
+    tokens.insert(0, scope)
+    return tokens
+
+
+    
+        
+    
+    
+
+
+    

rising_stretch-0.0.3/stretch/core_types.py

@@ -0,0 +1,159 @@
+__types__ = {}
+from garnish import garnish
+@garnish
+def add_type(type, determine=None):
+    if determine is None:
+        determine = type.__determine__
+    __types__[determine] = type
+
+class StretchTerminate(Exception): pass
+class StretchSkipline(Exception): pass
+
+class Stack(list):
+    __slots__ = ("single_layer")
+    class StackError(StretchTerminate): pass
+    def __init__(self, *iterable, single_layer=False):
+        if single_layer:
+            if any([isinstance(obj, Stack) for obj in iterable]):
+                raise Stack.StackError(f"Cannot move vertically in a single layer stack")
+        self.single_layer = single_layer
+        super().__init__(iterable)
+    def level(self, index = 1):
+        if self.single_layer:
+            if index != 1:
+                raise Stack.StackError(f"Cannot move vertically in a single layer stack")
+            return self
+        current_stack = self
+        stacks = [current_stack]
+        while len(current_stack) > 0:
+            if isinstance(current_stack[-1], Stack):
+                current_stack = current_stack[-1]
+                stacks.append(current_stack)
+            else:
+                break
+        return stacks[-index]
+    
+    def up(self, levels:int=1):
+        if self.single_layer:
+            raise Stack.StackError(f"Cannot move vertically in a single layer stack")
+        for _ in range(levels):
+            self.level().push(Stack())
+    def down(self, levels:int = 1):
+        if self.single_layer:
+            raise Stack.StackError(f"Cannot move vertically in a single layer stack")
+        return self.level(1 + levels).pop()
+    
+    def push(self, value):
+        if self.single_layer:
+            if isinstance(value, Stack):
+                raise Stack.StackError(f"Cannot move vertically in a single layer stack")
+        self.level().append(value)
+    def pull(self, index=1):
+        return self.level().pop(-index)
+    def peek(self, index=1):
+        return self.level()[-index]
+    def empty(self, level:int=1):
+        self.level(level).clear()
+    def copy(self, index = 1):
+        self.push(self.peek(index))
+    def surface(self, index):
+        self.push(self.pull(index))
+        
+    def extend(self, ls):
+        list.extend(self.level(), ls)
+    
+    def take(self, *types):
+        taking = []
+        for type in types:
+            if len(self.level(1)) < 1:
+                sorted = None
+                if len(taking) > 0:
+                    sorted = ', '.join([obj.__class__.__name__ + ":" + f"'{str(obj)}'" for obj in taking])
+                raise Stack.StackError(f"stack.take() expected ({", ".join([type.__name__ for type in types])}), recieved {{{sorted or ""}, '...'}} ")
+            if not isinstance(self.peek(), type):
+                sorted = None
+                if len(taking) > 0:
+                    sorted = ', '.join([obj.__class__.__name__ + ":" + f"'{str(obj)}'" for obj in taking])
+                fin_val = self.peek(2)
+                final = fin_val.__class__.__name__ + ":" + f"'{str(fin_val)}'"
+                if sorted is not None:
+                    final = ", " + final
+                raise Stack.StackError(f"stack.take() expected ({", ".join([type.__name__ for type in types])}), recieved {{{(sorted or "") + final}}} ")
+            taking.append(self.pull())
+        return taking
+    
+    def take_if(self, *types):
+        taking = []
+        for type in types:
+            if len(self.level()) < 1:
+                return taking
+            if not isinstance(self.peek(), type):
+                return taking
+            taking.append(self.pull())
+        return taking
+
+class RawToken:
+    __slots__ = ("literal",)
+    __raw__ = {}
+    
+    def __new__(cls, literal:str, *args):
+        if literal in cls.__raw__:
+            instance = cls.__raw__[literal]
+        else:
+            instance = super().__new__(cls)
+            instance.literal = literal
+            cls.__raw__[literal] = instance
+        return instance
+    
+    def __hash__(self):
+        return hash((RawToken, self.literal))
+    
+    def __eq__(self, other):
+        if isinstance(other, RawToken):
+            return self.literal == other.literal
+        elif isinstance(other, str):
+            return False
+        return False
+    
+    def __repr__(self):
+        return f"(Raw:'{self.literal}')"
+    
+class DotPath:
+    __slots__ = ("chain")
+    def __init__(self, *chain, scope=None):
+        self.chain = []
+        for segment in chain:
+            if isinstance(segment, str):
+                for str_seg in segment.strip().split('.'):
+                    if scope is not None:
+                        self.chain.append(scope.parse_raw(RawToken(str_seg)))
+                    else:
+                        self.chain.append(RawToken(str_seg))
+            elif isinstance(segment, RawToken):
+                self.chain.append(segment)
+    
+    def __repr__(self):
+        return f"<{'.'.join([str(seg) if not isinstance(seg, RawToken) else seg.literal for seg in self.chain])}>"
+    
+    def extend(self, *segments, scope=None):
+        for segment in segments:
+            if isinstance(segment, str):
+                for str_seg in segment.strip().split('.'):
+                    if scope is not None:
+                        self.chain.append(scope.parse_raw(RawToken(str_seg)))
+                    else:
+                        self.chain.append(RawToken(str_seg))
+            elif isinstance(segment, RawToken):
+                self.chain.append(segment)
+    
+    def file_name(self, ext:str=None) -> str:
+        if ext is not None: ext = '.' + ext
+        return "/".join([name.literal for name in self.chain]) + (ext or "")
+    def end(self) -> RawToken:
+        return RawToken(self.chain[-1])
+        
+class Alias:
+    __slots__ = ("name")
+    
+    def __init__(self, name):
+        self.name = name.literal

rising_stretch-0.0.3/stretch/extension.py

@@ -0,0 +1,51 @@
+from garnish import garnish
+from .core import __operators__, __terms__, __operator_precedence__
+from .core_types import RawToken
+
+class Extender:
+    def __init__(self):
+        self.__operators__ = __operators__
+        self.__operator_precedence__ = __operator_precedence__.copy()
+        self.__terms__ = __terms__
+        self.__types__ = {}
+        
+        self.__direct__ = []
+    
+    
+    def extend(self, proc, scope):
+        for operator in self.__operator_precedence__.sort():
+            scope.__operators__[operator] = self.__operators__[operator]
+        scope.__terms__.update(self.__terms__)
+        scope.__types__.update(self.__types__)
+        
+        for func in self.__direct__:
+            func(proc, scope)
+    
+    
+    def __enter__(self):
+        return self
+    def __exit__(self, *exc_args): pass
+    
+    def __call__(self, func):
+        self.__direct__.append(func)
+    
+    @garnish
+    def operator(self, func, symbol:str, low=None, high=None):
+        if low is not None:
+            low = RawToken(low)
+        if high is not None:
+            high = RawToken(high)
+        self.__operators__[RawToken(symbol)] = func
+        self.__operator_precedence__.add(RawToken(symbol), low, high)
+        return func
+
+    @garnish
+    def term(self, func, term:str):
+        self.__terms__[RawToken(term)] = func
+        return func
+    
+    @garnish
+    def type(self, cls):
+        pass
+    
+

rising_stretch-0.0.3/stretch/interpreter.py

@@ -0,0 +1,164 @@
+from .core import __operators__ as core_operators, __terms__ as core_terms
+from .core_types import Stack, DotPath, RawToken, StretchTerminate, StretchSkipline
+from .scope_types import Scope, Module
+from typing import Generator
+
+class CoreProcessor:
+    def __init__(self):
+        self.__modules__ = {}
+        self.__stack__ = Stack()
+        self.running = True
+        
+        self.__operators__ = core_operators
+        self.__terms__ = core_terms
+        self.__types__ = {}
+
+    def add_module(self, module:Module):
+        if not isinstance(module, Module):
+            raise TypeError(f"processor.add_module() expected a module, not {module.__class__.__name__} '{module}'")
+        self.__modules__[module.name] = module
+    
+    def modules(self, name=None):
+        if name is None:
+            return self.__modules__
+        return self.__modules__[name]
+    
+    # STACK
+    def stack(self):
+        return self.__stack__
+    
+    def process_line(self, scope:Scope, line):
+        try:
+            tokens = Stack(self.tokenize_line(scope, line))
+            
+            self.apply_operators(scope, scope.operators(), tokens) # apply scope / module level extension operators first
+            self.apply_operators(scope, self.__operators__, tokens) # apply builtin operators
+            
+            self.apply_terms(scope, scope.terms(), tokens)
+            self.apply_terms(scope, self.__terms__, tokens)
+            
+            self.save_vars(scope, tokens)
+        except StretchSkipline:
+            pass
+            
+    def apply_operators(self, scope, operators, tokens):
+        for operator in operators:
+            while operator in tokens:
+                index = tokens.index(operator) - 1
+                l = tokens.pop(index)
+                _ = tokens.pop(index)
+                r = tokens.pop(index)
+                        
+                result = operators[operator](self, scope, l, r) # an operator operates on the tokens to its left and to its right, and has access to the processor
+                if result is not None:
+                    tokens.insert(index, result)
+    def apply_terms(self, scope, terms, tokens): # terms don't have precedence, they are applied right to left on the tokens to their right
+        index = len(tokens) - 1
+        while index >= 0:
+            token = tokens[index]
+            if isinstance(token, RawToken) and token.literal in terms:
+                term_name = token.literal
+                tokens.pop(index) # remove term
+                r_toks = tokens[index:] # get the terms to the right
+                del tokens[index:] # remove them from the main list
+                # apply term
+                returned = terms[term_name](self, scope, r_toks)
+                if returned is None:
+                    returned = []
+                elif not isinstance(returned, (list, tuple, Generator)):
+                    returned = [returned] # append returned tokens
+                tokens.extend(returned)
+            index -= 1
+            
+    def save_vars(self, scope, tokens):
+        index = len(tokens) - 1
+        while index >= 0:
+            
+            token = tokens[index]
+            
+            if isinstance(token, RawToken):
+                if token.literal.endswith(":"):
+                    name = RawToken(token.literal[:-1])
+                    tokens.pop(index)
+                    if index > len(tokens):
+                        raise StretchTerminate(f"attempt to store {name} recieved no value")
+                    value = tokens.pop(index)
+                    scope.store(name, value)
+            
+            index -= 1
+        
+        
+    def tokenize_line(self, scope, line):
+        tokens = []
+        tok_str = []
+        start = None
+        for chunk in line.split():
+            
+            if start is None:
+                if chunk.startswith('"') and not chunk.endswith('"'):
+                    start = '"'
+            if start is not None:
+                tok_str.append(chunk)
+                if chunk.endswith(start):
+                    tokens.append(" ".join(tok_str)[1:-1])
+                    start = None
+            else:
+                for token in self.tokenize(chunk):
+                    tokens.append(self.parse_token(scope, token))
+        return tokens
+    
+    def tokenize(self, chunk):
+        tokens = []
+        for tok in chunk.split('.'):
+            tokens.append(tok)
+            tokens.append('.')
+        else:
+            tokens.pop()
+        for token in tokens:
+            yield token
+            
+    def parse_token(self, scope, token:str):
+        match token:
+            case token if token.isdigit():
+                return int(token)
+            case token if token.startswith('-') and token[1:].isdigit():
+                return int(token)
+            case token if token.startswith('"') and token.endswith('"'):
+                return token.strip('"')
+            case token if token.startswith("'") and token.endswith("'"):
+                return token.strip("'")
+            case token:
+                raw_token = RawToken(token)
+                if scope.contains(raw_token):
+                    
+                    return scope.retrieve(raw_token)
+                return raw_token
+    
+    def run_scope(self, scope:Scope):
+        self.init_scope(scope)
+        self.process_scope(scope)
+    
+    def init_scope(self, scope:Scope):
+        scope.go_to(0)
+        
+        while scope.current_line < len(scope.__lines__):
+            if not self.running:
+                break
+            line = scope.__lines__[scope.current_line]
+            if line.startswith("$"):
+                self.process_line(scope, line[1:])
+            scope.current_line += 1
+        
+    def process_scope(self, scope:Scope, start_line=0):
+        
+        scope.go_to(start_line)
+        
+        while scope.current_line < len(scope.__lines__):
+            if not self.running:
+                break
+            line = scope.__lines__[scope.current_line]
+            if not line.startswith("$"):
+                self.process_line(scope, line)
+            scope.current_line += 1
+    
+

rising_stretch-0.0.3/stretch/precedence.py

@@ -0,0 +1,64 @@
+class PrecedenceGraph:
+    def __init__(self):
+        self.lower = {}
+        self.higher = {}
+        self.nodes = []
+
+    def add_operator(self, op):
+        if op not in self.nodes:
+            self.nodes.append(op)
+
+    def add(self, operator, low=None, high=None):
+        self.add_operator(operator)
+        if low is not None:
+            self.add_sub(operator, low)
+        if high is not None:
+            self.add_dom(operator, high)
+    
+    def add_dom(self, low, high):
+        self.add_operator(low)
+        self.add_operator(high)
+
+        self.higher.setdefault(low, set()).add(high)
+        self.lower.setdefault(high, set()).add(low)
+
+    def add_sub(self, high, low):
+        self.add_dom(low, high)
+
+    def sort(self):
+        order = []
+        for op in self.nodes:
+            # find earliest valid insertion point
+            pos = 0
+            while pos < len(order):
+                before = order[:pos]
+                after = order[pos:]
+                # must come after all lower nodes
+                if any(l in after for l in self.lower.get(op, [])):
+                    pos += 1
+                    continue
+                # must come before all higher nodes
+                if any(h in before for h in self.higher.get(op, [])):
+                    pos += 1
+                    continue
+                break
+            order.insert(pos, op)
+        return order
+    
+    def update(self, other): # Add all nodes
+        for op in other.nodes:
+            self.add_operator(op) # Add all dominance (low < high) relationships
+        for low, highs in other.higher.items():
+            for high in highs:
+                self.add_dom(low, high)
+        for high, lows in other.lower.items():
+            for low in lows:
+                self.add_sub(high, low)
+
+    def copy(self):
+        instance = PrecedenceGraph()
+        instance.nodes = self.nodes[:]
+        instance.lower = {symbol: set(lower) for symbol, lower in self.lower.items()}
+        instance.higher = {symbol: set(higher) for symbol, higher in self.higher.items()}
+        return instance
+    

rising_stretch-0.0.3/stretch/scope_types.py

@@ -0,0 +1,91 @@
+
+type DotPath = None #alias
+
+class Scope:
+    def __init__(self, processor, name, parent):
+        self.processor = processor
+        self.name = name
+        self.parent = parent
+        
+        self.__lines__ = []
+        self.current_line = 0
+        self.__scope__ = {}
+    
+    def store(self, name, value):
+        self.__scope__[name] = value
+    
+    def retrieve(self, name):
+        return self.__scope__[name]
+    
+    def swap(self, name, value):
+        temp = self.__scope__[name]
+        self.__scope__[name] = value
+        return temp
+    
+    def erase(self, name):
+        del self.__scope__[name]
+    
+    def contains(self, name):
+        return name in self.__scope__
+    
+    def clear_line(self, line:int):
+        del self.__lines__[line]
+    def clear_lines(self):
+        self.__lines__.clear()
+    def write_line(self, line:str):
+        self.__lines__.append(line.strip())
+    def write_lines(self, lines:list[str]):
+        for line in lines:
+            self.write_line(line)
+    
+    def operators(self, symbol=None):
+        return self.parent.operators(symbol)
+    def terms(self, term=None):
+        return self.parent.terms(term)
+
+    def __iter__(self):
+        while self.current_line < len(self.__lines__):
+            yield self.__lines__[self.current_line]
+            self.current_line += 1
+    
+    def go_to(self, line):
+        self.current_line = line
+
+class Module(Scope):
+    @staticmethod
+    def load_module(file_path):
+        with open(file_path, 'r') as source:
+            return source.readlines()
+    
+    def __new__(cls, processor, module_path:DotPath, parent=None):
+        name = module_path.end().literal
+        if name in processor.modules():
+            instance = processor.modules(name)
+        else:
+            instance = super().__new__(cls)
+        return instance
+    
+    def register_operator(self, symbol:str, operation):
+        if symbol not in self.__operators__:
+            self.__operators__[symbol] = operation
+        
+    def __init__(self, processor, module_path:DotPath, parent=None):
+        super().__init__(processor, module_path.file_name(), parent)
+        self.path = module_path.file_name('str')
+        self.write_lines(self.load_module(self.path))
+        self.processor.add_module(self)
+        
+        self.__operators__ = processor.__operators__
+        self.__terms__ = processor.__terms__
+        self.__types__ = {}
+        self.__scope__ = {}
+        
+    def operators(self, symbol=None):
+        if symbol is None:
+            return self.__operators__
+        return self.__operators__[symbol]
+    
+    def terms(self, term=None):
+        if term is None:
+            return self.__terms__
+        return self.__terms__[term]