Remove old parser and move new parser to 'ast' package

smnp/ast/node/access.py

@@ -1,10 +1,54 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.ignore import IgnoredNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
 
 
-class AccessNode(Node):
-    def __init__(self, element, property, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.extend([element, property])
+class AccessNode(ExpressionNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children.append(IgnoredNode(pos))
 
-        self.element = self.children[0]
-        self.property = self.children[1]
+    @property
+    def left(self):
+        return self[0]
+
+    @left.setter
+    def left(self, value):
+        self[0] = value
+
+    @property
+    def right(self):
+        return self[1]
+
+    @right.setter
+    def right(self, value):
+        self[1] = value
+
+    @classmethod
+    def _parse(cls, input):
+        def createNode(left, right):
+            node = AccessNode(right.pos)
+            node.left = left
+            node.right = right
+            return node
+
+        return Parser.leftAssociativeOperatorParser(
+            cls._literalParser(),
+            TokenType.DOT,
+            cls._parseAccessingProperty(),
+            createNode=createNode
+        )(input)
+
+    @classmethod
+    def _literalParser(cls):
+        pass
+
+    @staticmethod
+    def _parseAccessingProperty():
+        from smnp.ast.node.identifier import IdentifierNode
+
+        return Parser.oneOf(
+            IdentifierNode._literalParser(),
+            IdentifierNode._functionCallParser()
+        )

smnp/ast/node/args.py

@@ -0,0 +1,11 @@
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.iterable import abstractIterableParser
+from smnp.ast.node.model import Node
+from smnp.token.type import TokenType
+
+
+class ArgumentsListNode(Node):
+
+    @classmethod
+    def _parse(cls, input):
+        return abstractIterableParser(ArgumentsListNode, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, ExpressionNode.parse)(input)

smnp/ast/node/assignment.py

@@ -1,10 +1,28 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.none import NoneNode
 
 
-class AssignmentNode(Node):
-    def __init__(self, target, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.extend([target, value])
+class AssignmentNode(ExpressionNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children.append(NoneNode())
 
-        self.target = self.children[0]
-        self.value = self.children[1]
+    @property
+    def target(self):
+        return self[0]
+
+    @target.setter
+    def target(self, value):
+        self[0] = value
+
+    @property
+    def value(self):
+        return self[1]
+
+    @value.setter
+    def value(self, value):
+        self[1] = value
+
+    @classmethod
+    def _parse(cls, input):
+        raise RuntimeError("This class is not supposed to be automatically called")

smnp/ast/node/asterisk.py

@@ -1,10 +1,28 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.statement import StatementNode
 
 
-class AsteriskNode(Node):
-    def __init__(self, iterator, statement, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.extend([iterator, statement])
+class AsteriskNode(StatementNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children = [NoneNode(), NoneNode()]
 
-        self.iterator = self.children[0]
-        self.statement = self.children[1]
+    @property
+    def iterator(self):
+        return self[0]
+
+    @iterator.setter
+    def iterator(self, value):
+        self[0] = value
+
+    @property
+    def statement(self):
+        return self[1]
+
+    @statement.setter
+    def statement(self, value):
+        self[1] = value
+
+    @classmethod
+    def _parse(cls, input):
+        raise RuntimeError("This class is not supposed to be automatically called")

smnp/ast/node/block.py

@@ -1,17 +1,20 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.statement import StatementNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
 
 
-class BlockNode(Node):
-    pass
+class BlockNode(StatementNode):
 
+    @classmethod
+    def _parse(cls, input):
+        def createNode(start, items, end):
+            node = BlockNode(start.pos)
+            node.children = items
+            return node
 
-class BlockItemNode(Node):
-    def __init__(self, statement, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(statement)
-
-        self.statement = self.children[0]
-
-
-class CloseBlockNode(Node):
-    pass
+        return Parser.loop(
+            Parser.terminalParser(TokenType.OPEN_BRACKET),
+            StatementNode.parse,
+            Parser.terminalParser(TokenType.CLOSE_BRACKET),
+            createNode=createNode
+        )(input)

smnp/ast/node/colon.py

@@ -1,10 +0,0 @@
-from smnp.ast.node.model import Node
-
-
-class ColonNode(Node):
-    def __init__(self, a, b, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.extend([a, b])
-
-        self.a = self.children[0]
-        self.b = self.children[1]

smnp/ast/node/expression.py

@@ -0,0 +1,65 @@
+from smnp.ast.node.asterisk import AsteriskNode
+from smnp.ast.node.model import Node
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.statement import StatementNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+class ExpressionNode(Node):
+    def __init__(self, pos):
+        super().__init__(pos, [NoneNode()])
+
+    @property
+    def value(self):
+        return self[0]
+
+
+    @value.setter
+    def value(self, v):
+        self[0] = v
+
+
+    @classmethod
+    def withValue(cls, val, pos):
+        node = cls(pos)
+        node.value = val
+        return node
+
+    @classmethod
+    def _parse(cls, input):
+        return Parser.oneOf(
+            cls._asteriskParser(),
+            cls._expressionParser(),
+        )(input)
+
+    @classmethod
+    def _asteriskParser(cls):
+        def createNode(iterator, asterisk, statement):
+            node = AsteriskNode(asterisk.pos)
+            node.iterator = iterator
+            node.statement = statement
+            return node
+
+        return Parser.allOf(
+            cls._expressionParser(),
+            Parser.terminalParser(TokenType.ASTERISK),
+            StatementNode.parse,
+            createNode=createNode
+        )
+
+    @classmethod
+    def _expressionParser(cls):
+        from smnp.ast.node.integer import IntegerLiteralNode
+        from smnp.ast.node.string import StringLiteralNode
+        from smnp.ast.node.note import NoteLiteralNode
+        from smnp.ast.node.identifier import IdentifierNode
+        from smnp.ast.node.list import ListNode
+
+        return Parser.oneOf(
+            IntegerLiteralNode.parse,
+            StringLiteralNode.parse,
+            NoteLiteralNode.parse,
+            IdentifierNode.parse,
+            ListNode.parse
+        )

smnp/ast/node/extend.py

@@ -0,0 +1,70 @@
+from smnp.ast.node.block import BlockNode
+from smnp.ast.node.function import FunctionDefinitionNode
+from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.statement import StatementNode
+from smnp.ast.node.type import TypeNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+class ExtendNode(StatementNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children = [NoneNode(), NoneNode(), NoneNode()]
+
+    @property
+    def type(self):
+        return self[0]
+
+    @type.setter
+    def type(self, value):
+        self[0] = value
+
+    @property
+    def variable(self):
+        return self[1]
+
+    @variable.setter
+    def variable(self, value):
+        self[1] = value
+
+    @property
+    def methods(self):
+        return self[2]
+
+    @methods.setter
+    def methods(self, value):
+        self[2] = value
+
+    @classmethod
+    def _parse(cls, input):
+        def createNode(extend, type, asKeyword, variable, methods):
+            node = ExtendNode(extend.pos)
+            node.type = type
+            node.variable = variable
+            node.methods = methods
+            return node
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.EXTEND),
+            TypeNode.parse,
+            Parser.terminalParser(TokenType.AS),
+            IdentifierNode.identifierParser(),
+            cls._methodsDeclarationsParser(),
+            createNode=createNode
+        )(input)
+
+    @classmethod
+    def _methodsDeclarationsParser(cls):
+        def createNode(openBracket, items, closeBracket):
+            node = BlockNode(openBracket.pos)
+            node.children = items
+            return node
+
+        return Parser.loop(
+            Parser.terminalParser(TokenType.OPEN_BRACKET),
+            FunctionDefinitionNode.parse,
+            Parser.terminalParser(TokenType.CLOSE_BRACKET),
+            createNode=createNode
+        )

smnp/ast/node/function.py

@@ -1,20 +1,67 @@
+from smnp.ast.node.block import BlockNode
+from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.iterable import abstractIterableParser
 from smnp.ast.node.model import Node
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.statement import StatementNode
+from smnp.ast.node.variable import TypedVariableNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
 
 
-class FunctionCallNode(Node):
-    def __init__(self, identifier, arguments, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.extend([identifier, arguments])
+class ArgumentsDeclarationNode(Node):
 
-        self.identifier = self.children[0]
-        self.arguments = self.children[1]
+    @classmethod
+    def _parse(cls, input):
+        raise RuntimeError("This class is not supposed to be automatically called")
 
 
-class FunctionDefinitionNode(Node):
-    def __init__(self, name, parameters, body, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.extend([name, parameters, body])
+class FunctionDefinitionNode(StatementNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children = [NoneNode(), NoneNode(), NoneNode()]
 
-        self.name = self.children[0]
-        self.parameters = self.children[1]
-        self.body = self.children[2]
+    @property
+    def name(self):
+        return self[0]
+
+    @name.setter
+    def name(self, value):
+        self[0] = value
+
+    @property
+    def arguments(self):
+        return self[1]
+
+    @arguments.setter
+    def arguments(self, value):
+        self[1] = value
+
+    @property
+    def body(self):
+        return self[2]
+
+    @body.setter
+    def body(self, value):
+        self[2] = value
+
+    @classmethod
+    def _parse(cls, input):
+        def createNode(function, name, arguments, body):
+            node = FunctionDefinitionNode(function.pos)
+            node.name = name
+            node.arguments = arguments
+            node.body = body
+            return node
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.FUNCTION),
+            IdentifierNode.identifierParser(),
+            cls._argumentsDeclarationParser(),
+            BlockNode.parse,
+            createNode=createNode
+        )(input)
+
+    @staticmethod
+    def _argumentsDeclarationParser():
+        return abstractIterableParser(ArgumentsDeclarationNode, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, TypedVariableNode.parser())

smnp/ast/node/identifier.py

@@ -1,9 +1,54 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.access import AccessNode
+from smnp.ast.node.args import ArgumentsListNode
+from smnp.ast.node.assignment import AssignmentNode
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.invocation import FunctionCall
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
 
 
-class IdentifierNode(Node):
-    def __init__(self, identifier, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(identifier)
+class IdentifierNode(AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        del self.children[1]
 
-        self.identifier = self.children[0]
+    @classmethod
+    def _literalParser(cls):
+        return Parser.oneOf(
+            IdentifierNode._functionCallParser(),
+            IdentifierNode._assignmentParser(),
+            IdentifierNode.identifierParser()
+        )
+
+    @staticmethod
+    def _assignmentParser():
+        def createNode(target, assignment, value):
+            node = AssignmentNode(assignment.pos)
+            node.target = target
+            node.value = value
+            return node
+
+        return Parser.allOf(
+            IdentifierNode.identifierParser(),
+            Parser.terminalParser(TokenType.ASSIGN),
+            ExpressionNode.parse,
+            createNode=createNode
+        )
+
+    @staticmethod
+    def _functionCallParser():
+        def createNode(name, arguments):
+            node = FunctionCall(name.pos)
+            node.name = name
+            node.arguments = arguments
+            return node
+
+        return Parser.allOf(
+            IdentifierNode.identifierParser(),
+            ArgumentsListNode.parse,
+            createNode=createNode
+        )
+
+    @staticmethod
+    def identifierParser():
+        return Parser.terminalParser(TokenType.IDENTIFIER, lambda val, pos: IdentifierNode.withValue(val, pos))

smnp/ast/node/ignore.py

@@ -0,0 +1,6 @@
+from smnp.ast.node.model import Node
+
+
+class IgnoredNode(Node):
+    def __init__(self, pos):
+        super().__init__(pos)

smnp/ast/node/imports.py

@@ -0,0 +1,76 @@
+from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.model import Node
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.string import StringLiteralNode
+from smnp.ast.node.type import TypeNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+class ImportNode(Node):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children = [NoneNode(), NoneNode(), NoneNode()]
+
+    @property
+    def source(self):
+        return self[0]
+
+    @source.setter
+    def source(self, value):
+        self[0] = value
+
+    @property
+    def type(self):
+        return self[1]
+
+    @type.setter
+    def type(self, value):
+        self[1] = value
+
+    @property
+    def variable(self):
+        return self[2]
+
+    @variable.setter
+    def variable(self, value):
+        self[2] = value
+
+    @classmethod
+    def _parse(cls, input):
+        return Parser.oneOf(
+            cls._literalImportParser(),
+            cls._fileImportParser()
+        )(input)
+
+    @classmethod
+    def _literalImportParser(cls):
+        def createNode(importKeyword, type, fromKeyword, source, asKeyword, variable):
+            node = ImportNode(importKeyword.pos)
+            node.source = source
+            node.type = type
+            node.variable = variable
+            return node
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.IMPORT),
+            TypeNode.parse,
+            Parser.terminalParser(TokenType.FROM),
+            StringLiteralNode._literalParser(),
+            Parser.terminalParser(TokenType.AS),
+            IdentifierNode.identifierParser(),
+            createNode=createNode
+        )
+
+    @classmethod
+    def _fileImportParser(cls):
+        def createNode(importKeyword, source):
+            node = ImportNode(importKeyword.pos)
+            node.source = source
+            return node
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.IMPORT),
+            StringLiteralNode._literalParser(),
+            createNode=createNode
+        )

smnp/ast/node/integer.py

@@ -1,9 +1,31 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.access import AccessNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
 
 
-class IntegerLiteralNode(Node):
-    def __init__(self, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(value)
+class IntegerLiteralNode(AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        del self.children[1]
 
-        self.value = self.children[0]
+    @classmethod
+    def _literalParser(cls):
+        return Parser.oneOf(
+            cls._negativeIntegerParser(),
+            cls._positiveIntegerParser()
+        )
+
+    @classmethod
+    def _negativeIntegerParser(cls):
+        def createNode(minus, integer):
+            return IntegerLiteralNode.withValue(-integer.value, minus.pos)
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.MINUS),
+            cls._positiveIntegerParser(),
+            createNode=createNode
+        )
+
+    @classmethod
+    def _positiveIntegerParser(cls):
+        return Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteralNode.withValue(int(val), pos))

smnp/ast/node/invocation.py

@@ -0,0 +1,27 @@
+from smnp.ast.node.access import AccessNode
+
+
+class FunctionCall(AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+
+    @property
+    def name(self):
+        return self[0]
+
+    @name.setter
+    def name(self, value):
+        self[0] = value
+
+    @property
+    def arguments(self):
+        return self[1]
+
+    @arguments.setter
+    def arguments(self, value):
+        self[1] = value
+
+    @classmethod
+    def _parse(cls, input):
+        raise RuntimeError("This class is not supposed to be automatically called")
+

smnp/ast/node/iterable.py

@@ -0,0 +1,130 @@
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.ignore import IgnoredNode
+from smnp.ast.node.model import Node, ParseResult
+from smnp.ast.node.none import NoneNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, itemParser):
+    class AbstractIterableTailNode(ExpressionNode):
+        def __init__(self, pos):
+            super().__init__(pos)
+
+            self.children.append(NoneNode())
+
+        @property
+        def next(self):
+            return self[1]
+
+        @next.setter
+        def next(self, value):
+            self[1] = value
+
+        @classmethod
+        def _parse(cls, input):
+            return Parser.oneOf(
+                AbstractIterableTailNode._parser1(),
+                AbstractIterableTailNode._parser2(),
+            )(input)
+
+        @staticmethod
+        def _parser1():
+            return Parser.terminalParser(closeTokenType)
+
+        @staticmethod
+        def _parser2():
+            def createNode(comma, expr, iterableTail):
+                node = AbstractIterableTailNode(expr.pos)
+                node.value = expr
+                node.next = iterableTail
+                return node
+
+            return Parser.allOf(
+                Parser.terminalParser(TokenType.COMMA),
+                itemParser,
+                AbstractIterableTailNode.parse,
+                createNode=createNode
+            )
+
+    class AbstractIterableNode(ExpressionNode):
+        def __init__(self, pos):
+            super().__init__(pos)
+
+            self.children.append(NoneNode())
+
+        @property
+        def next(self):
+            return self[1]
+
+        @next.setter
+        def next(self, value):
+            self[1] = value
+
+        @classmethod
+        def _parse(cls, input):
+            return Parser.oneOf(
+                AbstractIterableNode._parser1(),
+                AbstractIterableNode._parser2()
+            )(input)
+
+        @staticmethod
+        def _parser1():
+            def emptyIterable(openToken, closeToken):
+                node = AbstractIterableNode(openToken.pos)
+                node.value = openToken
+                node.next = closeToken
+                return node
+
+            return Parser.allOf(
+                Parser.terminalParser(openTokenType),
+                Parser.terminalParser(closeTokenType),
+                createNode=emptyIterable
+            )
+
+        @staticmethod
+        def _parser2():
+            def createNode(openParen, expr, iterableTail):
+                node = AbstractIterableNode(openParen.pos)
+                node.value = expr
+                node.next = iterableTail
+                return node
+
+            return Parser.allOf(
+                Parser.terminalParser(openTokenType, lambda val, pos: Node(pos)),
+                itemParser,
+                AbstractIterableTailNode.parse,
+                createNode=createNode
+            )
+
+    return toFlatDesiredNode(iterableNodeType, AbstractIterableNode.parse)
+
+
+def toFlatDesiredNode(iterableNodeType, parser):
+    def parse(input):
+        result = parser(input)
+
+        if result.result:
+            value = flattenList(result.node)
+            node = iterableNodeType(result.node.pos)
+            node.children.clear()
+            for v in value:
+                node.append(v)
+            return ParseResult.OK(node)
+
+        return ParseResult.FAIL()
+
+    return parse
+
+
+def flattenList(node, output=None):
+    if output is None:
+        output = []
+
+    if type(node.value) != IgnoredNode:
+        output.append(node.value)
+
+    if type(node.next) != IgnoredNode:
+        flattenList(node.next, output)
+
+    return output

smnp/ast/node/list.py

@@ -1,17 +1,11 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.access import AccessNode
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.iterable import abstractIterableParser
+from smnp.token.type import TokenType
 
 
-class ListNode(Node):
-    pass
+class ListNode(AccessNode):
 
-
-class ListItemNode(Node):
-    def __init__(self, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(value)
-
-        self.value = self.children[0]
-
-
-class CloseListNode(Node):
-    pass
+    @classmethod
+    def _literalParser(cls):
+        return abstractIterableParser(ListNode, TokenType.OPEN_SQUARE, TokenType.CLOSE_SQUARE, ExpressionNode.parse)

smnp/ast/node/literal.py

@@ -0,0 +1,18 @@
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.parser import Parser
+
+
+class LiteralNode(ExpressionNode):
+
+    @classmethod
+    def _getTokenType(cls):
+        pass
+
+    @classmethod
+    def _processValue(cls, value):
+        return value
+
+    @classmethod
+    def _literalParser(cls):
+        createNode = lambda val, pos: cls.withValue(cls._processValue(val), pos)
+        return Parser.terminalParser(cls._getTokenType(), createNode)

smnp/ast/node/model.py

@@ -1,44 +1,81 @@
-from smnp.note.model import Note
-
 class Node:
-    def __init__(self, parent, pos):
-        self.children = []
-        self.parent = parent
+    def __init__(self, pos, children=None):
+        if children is None:
+            children = []
+        self.children = children
         self.pos = pos
+        self.parent = None
         for child in self.children:
-            child.parent = self
-
-    def __repr__(self):
-        return self.__str__()
+            if isinstance(child, Node):
+                child.parent = self
 
     def __len__(self):
         return len(self.children)
 
-    def __getitem__(self, index):
-        return self.children[index]
+    def __getitem__(self, key):
+        return self.children[key]
+
+    def __setitem__(self, key, value):
+        if isinstance(value, Node):
+            value.parent = self
+        self.children[key] = value
 
     def append(self, node):
-        node.parent = self
+        if isinstance(node, Node):
+            node.parent = self
         self.children.append(node)
 
     def pop(self, index):
         return self.children.pop(index)
 
-    def print(self):
-        print(self._print(0))
+    @classmethod
+    def _parse(cls, input):
+        pass
 
-    def _print(self, level):
-        string = f"{pad(level)}{self.__class__.__name__}({self.parent.__class__.__name__}):\n"
-        for child in self.children:
-            if isinstance(child, str) or isinstance(child, int) or isinstance(child, Note):
-                string += pad(level + 1) + f"'{child}'\n"
+    @classmethod
+    def parse(cls, input):
+        result = cls._parse(input)
+        if result is None:
+            return ParseResult.FAIL()
+
+        if not isinstance(result, ParseResult):
+            raise RuntimeError(f"_parse() method of '{cls.__name__}' class haven't returned ParseResult object")
+
+        return result
+
+    def print(self):
+        self._print(first=True)
+
+    def _print(self, prefix="", last=True, first=False):
+        print(prefix, '' if first else '└─' if last else '├─', self.__class__.__name__, sep="")
+        prefix += '   ' if last else '│  '
+        for i, child in enumerate(self.children):
+            last = i == len(self.children) - 1
+            if isinstance(child, Node):
+                child._print(prefix, last)
             else:
-                string += child._print(level + 1)
-        return string
+                print(prefix, '└' if last else '├', f"'{str(child)}'", sep="")
 
     def __str__(self):
-        return self._print(0)
+        return self.__class__.__name__
+
+
+class ParseResult():
+    def __init__(self, result, node):
+        if result and node is None:
+            raise RuntimeError("Node musn't be None if result is set to True for ParseResult")
+        self.result = result
+        self.node = node
+
+    @staticmethod
+    def FAIL():
+        return ParseResult(False, None)
+
+    @staticmethod
+    def OK(node):
+        return ParseResult(True, node)
+
+    def __str__(self):
+        return f"{'OK' if self.result else 'FAILED'}[{self.node}]"
 
 
-def pad(level):
-    return "   " * level

smnp/ast/node/none.py

@@ -0,0 +1,9 @@
+from smnp.ast.node.model import Node
+
+
+class NoneNode(Node):
+    def __init__(self):
+        super().__init__((-1, -1))
+
+    def _parse(self, input):
+        pass

smnp/ast/node/note.py

@@ -1,9 +1,13 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.access import AccessNode
+from smnp.ast.node.literal import LiteralNode
+from smnp.token.type import TokenType
 
 
-class NoteLiteralNode(Node):
-    def __init__(self, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(value)
+class NoteLiteralNode(LiteralNode, AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        del self.children[1]
 
-        self.value = self.children[0]
+    @classmethod
+    def _getTokenType(cls):
+        return TokenType.NOTE

smnp/ast/node/percent.py

@@ -1,9 +0,0 @@
-from smnp.ast.node.model import Node
-
-
-class PercentNode(Node):
-    def __init__(self, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(value)
-
-        self.value = self.children[0]

smnp/ast/node/program.py

@@ -1,6 +1,32 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.extend import ExtendNode
+from smnp.ast.node.function import FunctionDefinitionNode
+from smnp.ast.node.imports import ImportNode
+from smnp.ast.node.model import Node, ParseResult
+from smnp.ast.node.statement import StatementNode
+from smnp.ast.parser import Parser
+from smnp.error.syntax import SyntaxException
 
 
 class Program(Node):
     def __init__(self):
-        Node.__init__(self, None, (-1, -1))
+        super().__init__((-1, -1))
+
+    @classmethod
+    def _parse(cls, input):
+        def parseToken(input):
+            return Parser.oneOf(
+                FunctionDefinitionNode.parse,
+                ExtendNode.parse,
+                ExpressionNode.parse,
+                ImportNode.parse,
+                StatementNode.parse,
+                exception = SyntaxException(f"Unknown statement: {input.current().pos}")
+            )(input)
+
+        root = Program()
+        while input.hasCurrent():
+            result = parseToken(input)
+            if result.result:
+                root.append(result.node)
+        return ParseResult.OK(root)

smnp/ast/node/ret.py

@@ -1,9 +1,32 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.statement import StatementNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
 
 
-class ReturnNode(Node):
-    def __init__(self, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(value)
+class ReturnNode(StatementNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children.append(NoneNode())
 
-        self.value = self.children[0]
+    @property
+    def value(self):
+        return self[0]
+
+    @value.setter
+    def value(self, value):
+        self[0] = value
+
+    @classmethod
+    def _parse(cls, input):
+        def createNode(ret, value):
+            node = ReturnNode(ret.pos)
+            node.value = value
+            return node
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.RETURN),
+            ExpressionNode.parse,
+            createNode=createNode
+        )(input)

smnp/ast/node/statement.py

@@ -0,0 +1,17 @@
+from smnp.ast.node.model import Node
+from smnp.ast.parser import Parser
+
+
+class StatementNode(Node):
+
+    @classmethod
+    def _parse(cls, input):
+        from smnp.ast.node.block import BlockNode
+        from smnp.ast.node.expression import ExpressionNode
+        from smnp.ast.node.ret import ReturnNode
+
+        return Parser.oneOf(
+            BlockNode.parse,
+            ReturnNode.parse,
+            ExpressionNode.parse
+        )(input)

smnp/ast/node/string.py

@@ -1,9 +1,13 @@
-from smnp.ast.node.model import Node
+from smnp.ast.node.access import AccessNode
+from smnp.ast.node.literal import LiteralNode
+from smnp.token.type import TokenType
 
 
-class StringLiteralNode(Node):
-    def __init__(self, value, parent, pos):
-        Node.__init__(self, parent, pos)
-        self.children.append(value)
+class StringLiteralNode(LiteralNode, AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        del self.children[1]
 
-        self.value = self.children[0]
+    @classmethod
+    def _getTokenType(cls):
+        return TokenType.STRING

smnp/ast/node/type.py

@@ -0,0 +1,13 @@
+from smnp.ast.node.access import AccessNode
+from smnp.ast.node.literal import LiteralNode
+from smnp.token.type import TokenType
+
+
+class TypeNode(LiteralNode, AccessNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        del self.children[1]
+
+    @classmethod
+    def _getTokenType(cls):
+        return TokenType.TYPE

smnp/ast/node/variable.py

@@ -0,0 +1,46 @@
+from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.none import NoneNode
+from smnp.ast.node.type import TypeNode
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+class TypedVariableNode(ExpressionNode):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children.append(NoneNode())
+
+    @property
+    def type(self):
+        return self[0]
+
+    @type.setter
+    def type(self, value):
+        self[0] = value
+
+    @property
+    def variable(self):
+        return self[1]
+
+    @variable.setter
+    def variable(self, value):
+        self[1] = value
+
+    @classmethod
+    def parser(cls):
+        def createNode(type, variable):
+            node = TypedVariableNode(type.pos)
+            node.type = type
+            node.variable = variable
+            return node
+
+        return Parser.allOf(
+            Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos)),
+            IdentifierNode.identifierParser(),
+            createNode=createNode
+        )
+
+    @classmethod
+    def _parse(cls, input):
+        #TODO
+        raise RuntimeError("Not implemented yet. There is still required work to correctly build AST related to IdentifierNode")

smnp/ast/parser.py

@@ -1,12 +1,115 @@
+from smnp.ast.node.ignore import IgnoredNode
+from smnp.ast.node.model import ParseResult, Node
 from smnp.ast.node.program import Program
-from smnp.ast.parsers.token import parseToken
 
 
 def parse(input):
-    root = Program()
-    while input.hasCurrent():
-        root.append(parseToken(input, root))    
-    return root
+    return Program.parse(input)
+
+class Parser:
+
+    # a -> A
+    @staticmethod
+    def terminalParser(expectedType, createNode=None):
+        def provideNode(value, pos):
+            if createNode is None:
+                return IgnoredNode(pos)
+            return createNode(value, pos)
+
+        def parse(input):
+            if input.hasCurrent() and input.current().type == expectedType:
+                token = input.current()
+                input.ahead()
+                return ParseResult.OK(provideNode(token.value, token.pos))
+            return ParseResult.FAIL()
+
+        return parse
+
+    # oneOf -> a | b | c | ...
+    @staticmethod
+    def oneOf(*parsers, exception=None):
+        def combinedParser(input):
+            snap = input.snapshot()
+            for parser in parsers:
+                value = parser(input)
+                if value.result:
+                    return value
+
+            if exception is not None:
+                raise exception
+
+            input.reset(snap)
+            return ParseResult.FAIL()
+
+        return combinedParser
+
+    # allOf -> a b c ...
+    @staticmethod
+    def allOf(*parsers, createNode, exception=None):
+        if len(parsers) == 0:
+            raise RuntimeError("Pass one parser at least")
+
+        def extendedParser(input):
+            snap = input.snapshot()
+
+            results = []
+
+            for parser in parsers:
+                result = parser(input)
+
+                if not result.result:
+                    if exception is not None:
+                        raise exception
+
+                    input.reset(snap)
+                    return ParseResult.FAIL()
+
+                results.append(result.node)
+
+            node = createNode(*results)
+            if not isinstance(node, Node):
+                raise RuntimeError("Function 'createNode' haven't returned a Node object. Probably forget to pass 'return'")
+
+            return ParseResult.OK(node)
 
 
-__all__ = ["parse"]
+
+        return extendedParser
+
+
+    # leftAssociative -> left | left OP right
+    @staticmethod
+    def leftAssociativeOperatorParser(leftParser, operatorTokenType, rightParser, createNode):
+        def parse(input):
+            left = leftParser(input)
+            if left.result:
+                while Parser.terminalParser(operatorTokenType)(input).result:
+                    right = rightParser(input)
+                    left = ParseResult.OK(createNode(left.node, right.node))
+
+                return left
+
+            return ParseResult.FAIL()
+
+        return parse
+
+    # loop -> start item* end
+    @staticmethod
+    def loop(startParser, itemParser, endParser, createNode):
+        def parse(input):
+            items = []
+            start = startParser(input)
+            if start.result:
+                while True:
+                    end = endParser(input)
+                    if end.result:
+                        return ParseResult.OK(createNode(start.node, items, end.node))
+                    item = itemParser(input)
+                    if not item.result:
+                        return ParseResult.FAIL()
+                    items.append(item.node)
+
+            return ParseResult.FAIL()
+
+        return parse
+

smnp/ast/parsers/access.py

@@ -1,24 +0,0 @@
-from smnp.ast.node.access import AccessNode
-from smnp.ast.parsers.expression import parseExpression
-from smnp.token.type import TokenType
-
-
-# access -> expr '.' expr
-# TODO: dodać dziedziczenie wszystkich expressions po jednym typie ExpressionNode
-# i potem sprawdzać przy wszystkich parent.pop(-1) czy pobrany z parenta element
-# jest rzeczywiście wyrażeniem, bo teraz możliwe jest np. {}.fun()
-def parseAccess(input, parent):
-    if input.isCurrent(TokenType.DOT):
-        token = input.current()
-        input.ahead()
-
-        element = parent.pop(-1)
-
-        property = parseExpression(input, parent)
-
-        node = AccessNode(element, property, parent, token.pos)
-        element.parent = node
-        property.parent = node
-
-        return node
-    return None

smnp/ast/parsers/asterisk.py

@@ -1,18 +0,0 @@
-from smnp.ast.node.asterisk import AsteriskNode
-from smnp.ast.parsers.statement import parseStatement
-from smnp.token.type import TokenType
-
-
-# asterisk -> expr '*' stmt
-def parseAsterisk(expr, input, parent):
-    if input.hasMore() and input.isCurrent(TokenType.ASTERISK):
-        token = input.current()
-        input.ahead()
-
-        stmt = parseStatement(input, parent)
-
-        asterisk = AsteriskNode(expr, stmt, parent, token.pos)
-        expr.parent = asterisk
-        stmt.parent = asterisk
-        return asterisk
-    return None

smnp/ast/parsers/block.py

@@ -1,47 +0,0 @@
-from smnp.ast.node.block import BlockNode, CloseBlockNode, BlockItemNode
-from smnp.ast.parsers.statement import parseStatement
-from smnp.token.type import TokenType
-
-
-def parseBlock(input, parent):
-    # '{'
-    if input.current().type == TokenType.OPEN_BRACKET:
-        token = input.current()
-        input.ahead()
-
-        node = BlockNode(parent, token.pos)
-
-        # '}'
-        if input.isCurrent(TokenType.CLOSE_BRACKET):
-            input.ahead()
-            return node
-
-        # blockItem
-        if input.hasCurrent():
-            item = parseBlockItem(input, node)
-            node.append(item)
-            return node
-
-    return None
-
-
-# blockItem -> stmt | '}'
-def parseBlockItem(input, parent):
-    # '}'
-    if input.isCurrent(TokenType.CLOSE_BRACKET):
-        close = CloseBlockNode(parent, input.current().pos)
-        input.ahead()
-        return close
-
-    if input.hasCurrent():
-        stmt = parseStatement(input, parent)
-
-        if stmt is not None:
-            item = BlockItemNode(stmt, parent, stmt.pos)
-            stmt.parent = item
-            nextBlockItem = parseBlockItem(input, item)
-            if nextBlockItem != None:
-                item.append(nextBlockItem)
-            return item
-
-    return None

smnp/ast/parsers/colon.py

@@ -1,20 +0,0 @@
-from smnp.ast.node.colon import ColonNode
-from smnp.ast.parsers.expression import parseExpression
-from smnp.error.syntax import SyntaxException
-from smnp.token.type import TokenType
-
-
-# colon -> expr ':' expr
-def parseColon(expr1, input, parent):
-    if input.isCurrent(TokenType.COLON):
-        token = input.current()
-        input.ahead()
-        expr2 = parseExpression(input, parent)
-
-        if expr2 is None:
-            raise SyntaxException(f"Expected expression '{input.current().value}'", input.current().pos)
-        colon = ColonNode(expr1, expr2, parent, token.pos)
-        expr1.parent = colon
-        expr2.parent = colon
-        return colon
-    return None

smnp/ast/parsers/expression.py

@@ -1,28 +0,0 @@
-def parseExpression(input, parent):
-    from smnp.ast.tools import combineParsers
-    from smnp.ast.parsers.access import parseAccess
-    from smnp.ast.parsers.colon import parseColon
-    from smnp.ast.parsers.identifier import parseIdentifierOrFunctionCallOrAssignment
-    from smnp.ast.parsers.integer import parseIntegerAndPercent
-    from smnp.ast.parsers.list import parseList
-    from smnp.ast.parsers.minus import parseMinus
-    from smnp.ast.parsers.note import parseNote
-    from smnp.ast.parsers.string import parseString
-
-    parsers = [
-        parseIntegerAndPercent,
-        parseMinus,
-        parseString,
-        parseNote,
-        parseList,
-        parseIdentifierOrFunctionCallOrAssignment,
-        parseAccess,
-    ]
-
-    expr = combineParsers(parsers)(input, parent)
-
-    colon = parseColon(expr, input, parent)
-    if colon is not None:
-        return colon
-
-    return expr

smnp/ast/parsers/function.py

@@ -1,29 +0,0 @@
-from smnp.ast.node.function import FunctionDefinitionNode
-from smnp.ast.parsers.block import parseBlock
-from smnp.ast.parsers.identifier import parseIdentifier
-from smnp.ast.parsers.list import parseList
-from smnp.ast.tools import assertToken
-from smnp.token.type import TokenType
-
-
-def parseFunctionDefinition(input, parent):
-    if input.isCurrent(TokenType.FUNCTION):
-        token = input.current()
-        input.ahead()
-
-        assertToken(TokenType.IDENTIFIER, input)
-        identifier = parseIdentifier(input, parent)
-
-        assertToken(TokenType.OPEN_PAREN, input)
-        args = parseList(input, parent)
-
-        assertToken(TokenType.OPEN_BRACKET, input)
-        body = parseBlock(input, parent)
-
-        function = FunctionDefinitionNode(identifier, args, body, parent, token.pos)
-        identifier.parent = function
-        args.parent = function
-        body.parent = function
-
-        return function
-    return None

smnp/ast/parsers/identifier.py

@@ -1,48 +0,0 @@
-from smnp.ast.node.assignment import AssignmentNode
-from smnp.ast.node.function import FunctionCallNode
-from smnp.ast.node.identifier import IdentifierNode
-from smnp.ast.parsers.expression import parseExpression
-from smnp.ast.parsers.list import parseList
-from smnp.ast.tools import greedy
-from smnp.token.type import TokenType
-
-
-# id -> IDENTIFIER
-def parseIdentifier(input, parent):
-    if input.isCurrent(TokenType.IDENTIFIER):
-        identifier = IdentifierNode(input.current().value, parent, input.current().pos)
-        input.ahead()
-
-        return identifier
-    return None
-
-
-# identifier -> IDENTIFIER
-# functionCall -> identifier list
-# assignment -> identifier '=' expr
-def parseIdentifierOrFunctionCallOrAssignment(input, parent):
-    identifier = parseIdentifier(input, parent)
-
-    # assignment -> identifier '=' expr
-    if identifier is not None and input.hasCurrent():
-        if input.current().type == TokenType.ASSIGN:
-            token = input.current()
-            input.ahead()
-
-            expr = greedy(parseExpression)(input, parent)
-
-            assignment = AssignmentNode(identifier, expr, parent, token.pos)
-            identifier.parent = assignment
-            expr.parent = assignment
-
-            return assignment
-
-        # functionCall -> identifier list
-        args = parseList(input, parent)
-        if args is not None:
-            functionCall = FunctionCallNode(identifier, args, parent, identifier.pos)
-            args.parent = functionCall
-            identifier.parent = functionCall
-            return functionCall
-
-    return identifier

smnp/ast/parsers/integer.py

@@ -1,26 +0,0 @@
-from smnp.ast.node.integer import IntegerLiteralNode
-from smnp.ast.node.percent import PercentNode
-from smnp.token.type import TokenType
-
-
-# int -> INTEGER
-def parseInteger(input, parent):
-    if input.isCurrent(TokenType.INTEGER):
-        integer = IntegerLiteralNode(int(input.current().value), parent, input.current().pos)
-        input.ahead()
-
-        return integer
-    return None
-
-
-# percent -> int '%'
-# int -> int
-def parseIntegerAndPercent(input, parent):
-    integer = parseInteger(input, parent)
-    if integer is not None and input.isCurrent(TokenType.PERCENT):
-        percent = PercentNode(integer, parent, input.current().pos)
-        integer.parent = percent
-        input.ahead()
-
-        return percent
-    return integer

smnp/ast/parsers/list.py

@@ -1,54 +0,0 @@
-from smnp.ast.node.list import ListNode, ListItemNode, CloseListNode
-from smnp.ast.parsers.expression import parseExpression
-from smnp.ast.tools import greedy, assertToken
-from smnp.token.type import TokenType
-
-
-# list -> CLOSE_PAREN | expr listTail
-def parseList(input, parent):
-    if input.isCurrent(TokenType.OPEN_PAREN):
-        node = ListNode(parent, input.current().pos)
-        input.ahead()
-
-        # list -> CLOSE_PAREN (end of list)
-        if input.isCurrent(TokenType.CLOSE_PAREN):
-            close = CloseListNode(node, input.current().pos)
-            node.append(close)
-            input.ahead()
-            return node
-
-            # list -> expr listTail
-        if input.hasCurrent():
-            token = input.current()
-            expr = greedy(parseExpression)(input, parent)
-            item = ListItemNode(expr, node, token.pos)
-            expr.parent = item
-            node.append(item)
-            listTail = parseListTail(input, item)
-            item.append(listTail)
-            return node
-    return None
-
-
-# listTail -> COMMA expr listTail | CLOSE_PAREN
-def parseListTail(input, parent):
-    # listTail -> CLOSE_PAREN
-    if input.isCurrent(TokenType.CLOSE_PAREN):
-        close = CloseListNode(parent, input.current().pos)
-        input.ahead()
-        return close
-
-    # listTail -> COMMA expr listTail
-    if input.hasCurrent() and input.hasMore():
-        assertToken(TokenType.COMMA, input)
-        input.ahead()
-        expr = greedy(parseExpression)(input, parent)
-        if expr is not None:
-            item = ListItemNode(expr, parent, expr.pos)
-            expr.parent = item
-            listTail = parseListTail(input, item)
-            item.append(listTail)
-            listTail.parent = item
-            return item
-
-    return None

smnp/ast/parsers/minus.py

@@ -1,17 +0,0 @@
-from smnp.ast.node.integer import IntegerLiteralNode
-from smnp.ast.parsers.integer import parseInteger
-from smnp.token.type import TokenType
-
-
-# minus -> '-' int
-def parseMinus(input, parent):
-    if input.isCurrent(TokenType.MINUS):
-        token = input.current()
-        input.ahead()
-
-        if input.hasCurrent():
-            expr = parseInteger(input, parent)
-
-            return IntegerLiteralNode(-expr.value, parent, token.pos)
-
-    return None

smnp/ast/parsers/note.py

@@ -1,39 +0,0 @@
-import re
-
-from smnp.ast.node.note import NoteLiteralNode
-from smnp.note.model import Note
-from smnp.token.type import TokenType
-
-
-# note -> NOTE
-def parseNote(input, parent):
-    if input.isCurrent(TokenType.NOTE):
-        token = input.current()
-        value = token.value
-        consumedChars = 1
-        notePitch = value[consumedChars]
-        consumedChars += 1
-        octave = 4
-        duration = 4
-        dot = False
-        if consumedChars < len(value) and value[consumedChars] in ('b', '#'):
-            notePitch += value[consumedChars]
-            consumedChars += 1
-        if consumedChars < len(value) and re.match(r'\d', value[consumedChars]):
-            octave = int(value[consumedChars])
-            consumedChars += 1
-        if consumedChars < len(value) and value[consumedChars] == '.':
-            consumedChars += 1
-            durationString = ''
-            while consumedChars < len(value) and re.match(r'\d', value[consumedChars]):
-                durationString += value[consumedChars]
-                consumedChars += 1
-                duration = int(durationString)
-            if consumedChars < len(value) and value[consumedChars] == 'd':
-                dot = True
-                consumedChars += 1
-
-        input.ahead()
-        return NoteLiteralNode(Note(notePitch, octave, duration, dot), parent, token.pos)
-
-    return None

smnp/ast/parsers/ret.py

@@ -1,17 +0,0 @@
-from smnp.ast.node.ret import ReturnNode
-from smnp.ast.parsers.expression import parseExpression
-from smnp.token.type import TokenType
-
-
-def parseReturn(input, parent):
-    if input.isCurrent(TokenType.RETURN):
-        token = input.current()
-        input.ahead()
-
-        expr = parseExpression(input, parent)
-
-        node = ReturnNode(expr, parent, token.pos)
-        expr.parent = node
-
-        return node
-    return None

smnp/ast/parsers/statement.py

@@ -1,22 +0,0 @@
-def parseStatement(input, parent):
-    from smnp.ast.tools import combineParsers
-    from smnp.ast.parsers.asterisk import parseAsterisk
-    from smnp.ast.parsers.block import parseBlock
-    from smnp.ast.parsers.expression import parseExpression
-    from smnp.ast.parsers.function import parseFunctionDefinition
-    from smnp.ast.parsers.ret import parseReturn
-
-    parsers = [
-        parseBlock,
-        parseFunctionDefinition,
-        parseReturn,
-        parseExpression,
-    ]
-
-    stmt = combineParsers(parsers)(input, parent)
-
-    asterisk = parseAsterisk(stmt, input, parent)
-    if asterisk is not None:
-        return asterisk
-
-    return stmt

smnp/ast/parsers/string.py

@@ -1,12 +0,0 @@
-from smnp.ast.node.string import StringLiteralNode
-from smnp.token.type import TokenType
-
-
-# string -> STRING
-def parseString(input, parent):
-    if input.isCurrent(TokenType.STRING):
-        string = StringLiteralNode(input.current().value[1:len(input.current().value) - 1], parent, input.current().pos)
-        input.ahead()
-
-        return string
-    return None

smnp/ast/parsers/token.py

@@ -1,12 +0,0 @@
-from smnp.ast.parsers.statement import parseStatement
-from smnp.ast.tools import combineParsers
-from smnp.error.syntax import SyntaxException
-
-
-def parseToken(input, parent):
-    value = combineParsers([ parseStatement ])(input, parent)
-
-    if value is None:
-        raise SyntaxException("Unknown statement")  # TODO
-
-    return value

smnp/ast/tools.py

@@ -1,30 +1,8 @@
-from smnp.ast.node.model import Node
 from smnp.error.syntax import SyntaxException
 
 
-def greedy(parser):
-    def _rollup(input, parent):
-        node = Node(None, (-1, -1))
-        elem = parser(input, node)
-        while elem is not None:
-            node.append(elem)
-            elem = parser(input, node)
-        return node.children[0] if len(node.children) > 0 else None
-    return _rollup
-
-
-def assertToken(expected, input):    
+def assertToken(expected, input):
     if not input.hasCurrent():
         raise SyntaxException(f"Expected '{expected}'")
     if expected != input.current().type:
         raise SyntaxException(f"Expected '{expected}', found '{input.current().value}'", input.current().pos)
-
-
-def combineParsers(parsers):
-    def combinedParser(input, parent):
-        for parser in parsers:
-            value = parser(input, parent)
-            if value is not None:
-                return value
-        return None
-    return combinedParser