Fix 'range' function

smnp/ast/node/atom.py

@@ -44,31 +44,23 @@ class TypeLiteral(Atom):
 
 
 def IntegerParser(input):
-    return Parser.oneOf(
+    return Parser.terminal(TokenType.INTEGER, createNode=IntegerLiteral.withValue)(input)
-        Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteral.withValue(int(val), pos)),
-        Parser.allOf(
-            Parser.terminalParser(TokenType.MINUS),
-            Parser.terminalParser(TokenType.INTEGER, lambda val, pos: IntegerLiteral.withValue(int(val), pos)),
-            createNode=lambda minus, integer: IntegerLiteral.withValue(-integer.value, minus.pos),
-            name="negative integer"
-        )
-    )(input)
 
 
 def StringParser(input):
-    return Parser.terminalParser(TokenType.STRING, createNode=StringLiteral.withValue)(input)
+    return Parser.terminal(TokenType.STRING, createNode=StringLiteral.withValue)(input)
 
 
 def NoteParser(input):
-    return Parser.terminalParser(TokenType.NOTE, createNode=NoteLiteral.withValue)(input)
+    return Parser.terminal(TokenType.NOTE, createNode=NoteLiteral.withValue)(input)
 
 
 def BoolParser(input):
-    return Parser.terminalParser(TokenType.BOOL, createNode=BoolLiteral.withValue)(input)
+    return Parser.terminal(TokenType.BOOL, createNode=BoolLiteral.withValue)(input)
 
 
-def TypeParser(input):
+def TypeLiteralParser(input):
-    return Parser.terminalParser(TokenType.TYPE, createNode=TypeLiteral.withValue)(input)
+    return Parser.terminal(TokenType.TYPE, createNode=TypeLiteral.withValue)(input)
 
 
 def LiteralParser(input):
@@ -77,17 +69,21 @@ def LiteralParser(input):
         StringParser,
         NoteParser,
         BoolParser,
-        TypeParser,
+        TypeLiteralParser,
         name="literal"
     )(input)
 
 
 def AtomParser(input):
     from smnp.ast.node.identifier import IdentifierParser
+    from smnp.ast.node.list import ListParser
+    from smnp.ast.node.map import MapParser
 
     return Parser.oneOf(
         LiteralParser,
         IdentifierParser,
+        ListParser,
+        MapParser,
         name="atom"
     )(input)
 

smnp/ast/node/block.py

@@ -9,11 +9,9 @@ class Block(Node):
 
 
 def BlockParser(input):
-    parser = Parser.loop(
+    return Parser.loop(
-        Parser.terminalParser(TokenType.OPEN_CURLY),
+        Parser.terminal(TokenType.OPEN_CURLY),
         Parser.doAssert(StatementParser, f"statement or '{TokenType.CLOSE_CURLY.key}'"),
-        Parser.terminalParser(TokenType.CLOSE_CURLY),
+        Parser.terminal(TokenType.CLOSE_CURLY),
         createNode=lambda open, statements, close: Block.withChildren(statements, open.pos)
-    )
+    )(input)
-
-    return Parser(parser, "block", [parser])(input)

smnp/ast/node/chain.py

@@ -1,21 +0,0 @@
-from smnp.ast.node.atom import AtomParser
-from smnp.ast.node.list import ListParser
-from smnp.ast.node.map import MapParser
-from smnp.ast.node.operator import BinaryOperator
-from smnp.ast.node.valuable import Valuable
-from smnp.ast.parser import Parser
-from smnp.token.type import TokenType
-
-
-class Chain(Valuable):
-    pass
-
-itemParser = Parser.oneOf(
-    ListParser,
-    MapParser,
-    AtomParser,
-)
-
-ChainParser = Parser.leftAssociativeOperatorParser(itemParser, [TokenType.DOT], itemParser,
-                                                   lambda left, op, right: Chain.withValue(BinaryOperator.withValues(left, op, right)))
-

smnp/ast/node/condition.py

@@ -1,4 +1,4 @@
-from smnp.ast.node.expression import MaxPrecedenceExpressionParser
+from smnp.ast.node.expression import ExpressionParser
 from smnp.ast.node.model import Node
 from smnp.ast.node.none import NoneNode
 from smnp.ast.node.statement import StatementParser
@@ -46,23 +46,23 @@ class IfElse(Node):
 
 def IfElseStatementParser(input):
     ifStatementParser = Parser.allOf(
-        Parser.terminalParser(TokenType.IF),
+        Parser.terminal(TokenType.IF),
-        Parser.terminalParser(TokenType.OPEN_PAREN),
+        Parser.terminal(TokenType.OPEN_PAREN),
-        MaxPrecedenceExpressionParser,
+        ExpressionParser,
-        Parser.terminalParser(TokenType.CLOSE_PAREN),
+        Parser.terminal(TokenType.CLOSE_PAREN),
         StatementParser,
         createNode=lambda _, __, condition, ___, ifStatement: IfElse.createNode(ifStatement, condition),
         name="if statement"
     )
 
     ifElseStatementParser = Parser.allOf(
-        Parser.terminalParser(TokenType.IF),
+        Parser.terminal(TokenType.IF),
-        Parser.terminalParser(TokenType.OPEN_PAREN),
+        Parser.terminal(TokenType.OPEN_PAREN, doAssert=True),
-        MaxPrecedenceExpressionParser,
+        Parser.doAssert(ExpressionParser, "expression"),
-        Parser.terminalParser(TokenType.CLOSE_PAREN),
+        Parser.terminal(TokenType.CLOSE_PAREN, doAssert=True),
-        StatementParser,
+        Parser.doAssert(StatementParser, "statement"),
-        Parser.terminalParser(TokenType.ELSE),
+        Parser.terminal(TokenType.ELSE),
-        StatementParser,
+        Parser.doAssert(StatementParser, "statement"),
         createNode=lambda _, __, condition, ___, ifStatement, ____, elseStatement: IfElse.createNode(ifStatement, condition, elseStatement),
         name="if-else statement"
     )

smnp/ast/node/expression.py

@@ -1,63 +1,51 @@
 from smnp.ast.node.operator import BinaryOperator
 from smnp.ast.node.term import TermParser
-from smnp.ast.node.valuable import Valuable
 from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class Expression(Valuable):
+class Sum(BinaryOperator):
+    pass
+
+
+class Relation(BinaryOperator):
+    pass
+
+
+class And(BinaryOperator):
+    pass
+
+
+class Or(BinaryOperator):
     pass
 
 
 def ExpressionParser(input):
-    return Parser.leftAssociativeOperatorParser(
+    expr1 = Parser.leftAssociativeOperatorParser(
         TermParser,
         [TokenType.PLUS, TokenType.MINUS],
         TermParser,
-        lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
+        lambda left, op, right: Sum.withValues(left, op, right)
-    )(input)
+    )
 
+    expr2 = Parser.leftAssociativeOperatorParser(
+        expr1,
+        [TokenType.RELATION, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE],
+        expr1,
+        lambda left, op, right: Relation.withValues(left, op, right)
+    )
 
-def Expression2Parser(input):
+    expr3 = Parser.leftAssociativeOperatorParser(
-    return Parser.leftAssociativeOperatorParser(
+        expr2,
-        ExpressionParser,
-        [TokenType.RELATION],
-        ExpressionParser,
-        lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
-    )(input)
-
-
-def Expression3Parser(input):
-    return Parser.leftAssociativeOperatorParser(
-        Expression2Parser,
         [TokenType.AND],
-        Expression2Parser,
+        expr2,
-        lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
+        lambda left, op, right: And.withValues(left, op, right)
-    )(input)
+    )
 
-
+    return Parser.leftAssociativeOperatorParser(
-def Expression4Parser(input):
+        expr3,
-    from smnp.ast.node.condition import IfElse
-    exprParser = Parser.leftAssociativeOperatorParser(
-        Expression3Parser,
         [TokenType.OR],
-        Expression3Parser,
+        expr3,
-        lambda left, op, right: Expression.withValue(BinaryOperator.withValues(left, op, right))
+        lambda left, op, right: Or.withValues(left, op, right)
-    )
-
-    ifElseExpression = Parser.allOf(
-        exprParser,
-        Parser.terminalParser(TokenType.IF),
-        Expression4Parser,
-        Parser.terminalParser(TokenType.ELSE),
-        Expression4Parser,
-        createNode=lambda ifNode, _, condition, __, elseNode: IfElse.createNode(ifNode, condition, elseNode)
-    )
-
-    return Parser.oneOf(
-        ifElseExpression,
-        exprParser,
     )(input)
 
-
-MaxPrecedenceExpressionParser = Expression4Parser

smnp/ast/node/extend.py

@@ -1,70 +1,88 @@
-# from smnp.ast.node.block import BlockNode
+from smnp.ast.node.block import Block
-# from smnp.ast.node.function import FunctionDefinitionNode
+from smnp.ast.node.function import FunctionDefinitionParser
-# from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.identifier import IdentifierLiteralParser
-# from smnp.ast.node.none import NoneNode
+from smnp.ast.node.model import Node
-# from smnp.ast.node.statement import StatementNode
+from smnp.ast.node.none import NoneNode
-# from smnp.ast.node.type import TypeNode
+from smnp.ast.node.type import TypeParser
-# from smnp.ast.parser import Parser
+from smnp.ast.parser import Parser
-# from smnp.token.type import TokenType
+from smnp.token.type import TokenType
-#
+
-#
+
-# class ExtendNode(StatementNode):
+class Extend(Node):
-#     def __init__(self, pos):
+    def __init__(self, pos):
-#         super().__init__(pos)
+        super().__init__(pos)
-#         self.children = [NoneNode(), NoneNode(), NoneNode()]
+        self.children = [NoneNode(), NoneNode(), NoneNode()]
-#
+
-#     @property
+    @property
-#     def type(self):
+    def type(self):
-#         return self[0]
+        return self[0]
-#
+
-#     @type.setter
+    @type.setter
-#     def type(self, value):
+    def type(self, value):
-#         self[0] = value
+        self[0] = value
-#
+
-#     @property
+    @property
-#     def variable(self):
+    def variable(self):
-#         return self[1]
+        return self[1]
-#
+
-#     @variable.setter
+    @variable.setter
-#     def variable(self, value):
+    def variable(self, value):
-#         self[1] = value
+        self[1] = value
-#
+
-#     @property
+    @property
-#     def methods(self):
+    def methods(self):
-#         return self[2]
+        return self[2]
-#
+
-#     @methods.setter
+    @methods.setter
-#     def methods(self, value):
+    def methods(self, value):
-#         self[2] = value
+        self[2] = value
-#
+
-#     @classmethod
+    @classmethod
-#     def _parse(cls, input):
+    def withValues(cls, pos, type, variable, methods):
-#         def createNode(extend, type, asKeyword, variable, methods):
+        node = cls(pos)
-#             node = ExtendNode(extend.pos)
+        node.type = type
-#             node.type = type
+        node.variable = variable
-#             node.variable = variable
+        node.methods = methods
-#             node.methods = methods
+        return node
-#             return node
+
-#
+
-#         return Parser.allOf(
+def ExtendParser(input):
-#             Parser.terminalParser(TokenType.EXTEND),
+
-#             Parser.doAssert(TypeNode.parse, "type being extended"),
+    simpleExtend = Parser.allOf(
-#             Parser.terminalParser(TokenType.AS, doAssert=True),
+        Parser.terminal(TokenType.EXTEND),
-#             Parser.doAssert(IdentifierNode.identifierParser(), "variable name"),
+        TypeParser,
-#             Parser.doAssert(cls._methodsDeclarationsParser(), "methods declarations"),
+        Parser.terminal(TokenType.AS),
-#             createNode=createNode
+        IdentifierLiteralParser,
-#         )(input)
+        Parser.terminal(TokenType.WITH),
-#
+        Parser.doAssert(Parser.wrap(FunctionDefinitionParser, lambda method: Block.withChildren([ method ], method.pos)), "method definition"),
-#     @classmethod
+        createNode=lambda extend, type, _, variable, __, methods: Extend.withValues(extend.pos, type, variable, methods),
-#     def _methodsDeclarationsParser(cls):
+        name="simple extend"
-#         def createNode(openBracket, items, closeBracket):
+    )
-#             node = BlockNode(openBracket.pos)
+
-#             node.children = items
+    multiExtend = Parser.allOf(
-#             return node
+        Parser.terminal(TokenType.EXTEND),
-#
+        Parser.doAssert(TypeParser, "type being extended"),
-#         return Parser.loop(
+        Parser.terminal(TokenType.AS, doAssert=True),
-#             Parser.terminalParser(TokenType.OPEN_CURLY),
+        Parser.doAssert(IdentifierLiteralParser, "variable name"),
-#             Parser.doAssert(FunctionDefinitionNode.parse, f"method declaration or '{TokenType.CLOSE_CURLY.key}'"),
+        Parser.doAssert(MethodsDeclarationParser, f"block with methods definitions or '{TokenType.WITH.key}' keyword"),
-#             Parser.terminalParser(TokenType.CLOSE_CURLY),
+        createNode=lambda extend, type, _, variable, methods: Extend.withValues(extend.pos, type, variable, methods),
-#             createNode=createNode
+        name="multiple extend"
-#         )
+    )
+
+
+    return Parser.oneOf(
+        simpleExtend,
+        multiExtend,
+        name="extend"
+    )(input)
+
+
+def MethodsDeclarationParser(input):
+    return Parser.loop(
+        Parser.terminal(TokenType.OPEN_CURLY),
+        Parser.doAssert(FunctionDefinitionParser, f"method definition or '{TokenType.CLOSE_CURLY.key}'"),
+        Parser.terminal(TokenType.CLOSE_CURLY),
+        createNode=lambda open, methods, close: Block.withChildren(methods, open.pos),
+        name="methods block"
+    )(input)
+

smnp/ast/node/factor.py

@@ -1,64 +1,102 @@
-from smnp.ast.node.chain import ChainParser
+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.operator import BinaryOperator, Operator, UnaryOperator
-from smnp.ast.node.valuable import Valuable
+from smnp.ast.node.unit import UnitParser
 from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
-
-class Factor(Valuable):
-    pass
-
-
 class NotOperator(UnaryOperator):
     pass
 
+
+class Power(BinaryOperator):
+    pass
+
+
 class Loop(BinaryOperator):
+    def __init__(self, pos):
+        super().__init__(pos)
+        self.children.append(NoneNode())
+
+    @property
+    def parameters(self):
+        return self[3]
+
+    @parameters.setter
+    def parameters(self, value):
+        self[3] = value
+
+    @classmethod
+    def loop(cls, left, parameters, operator, right):
+        node = cls(left.pos)
+        node.left = left
+        node.parameters = parameters
+        node.operator = operator
+        node.right = right
+        return node
+
+
+class LoopParameters(Node):
     pass
 
 
 def FactorParser(input):
-    from smnp.ast.node.expression import MaxPrecedenceExpressionParser
+    from smnp.ast.node.expression import ExpressionParser
     from smnp.ast.node.statement import StatementParser
+    from smnp.ast.node.identifier import IdentifierLiteralParser
 
-    powerFactor = Parser.leftAssociativeOperatorParser(
+    parentheses = Parser.allOf(
-        ChainParser,
+        Parser.terminal(TokenType.OPEN_PAREN),
-        [TokenType.DOUBLE_ASTERISK],
+        Parser.doAssert(ExpressionParser, "expression"),
-        ChainParser,
+        Parser.terminal(TokenType.CLOSE_PAREN),
-        lambda left, op, right: Factor.withValue(BinaryOperator.withValues(left, op, right)),
-        name="power operator"
-    )
-
-    exprFactor = Parser.allOf(
-        Parser.terminalParser(TokenType.OPEN_PAREN),
-        MaxPrecedenceExpressionParser,
-        Parser.terminalParser(TokenType.CLOSE_PAREN),
         createNode=lambda open, expr, close: expr,
         name="grouping parentheses"
     )
 
-    factorParser = Parser.oneOf(
+    factorOperands = Parser.oneOf(
-        powerFactor,
+        parentheses,
-        exprFactor,
+        UnitParser,
-        name="basic factor"
+        name="factor operands"
+    )
+
+    powerFactor = Parser.leftAssociativeOperatorParser(
+        factorOperands,
+        [TokenType.DOUBLE_ASTERISK],
+        factorOperands,
+        lambda left, op, right: Power.withValues(left, op, right),
+        name="power operator"
     )
 
     notOperator = Parser.allOf(
-        Parser.terminalParser(TokenType.NOT, Operator.withValue),
+        Parser.terminal(TokenType.NOT, Operator.withValue),
-        factorParser,
+        powerFactor,
         createNode=NotOperator.withValues,
         name="not"
     )
 
+    loopParameters = Parser.allOf(
+        Parser.terminal(TokenType.AS),
+        Parser.oneOf(
+            Parser.wrap(IdentifierLiteralParser, lambda id: LoopParameters.withChildren([id], id.pos)),
+            abstractIterableParser(LoopParameters, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, IdentifierLiteralParser)
+        ),
+        createNode=lambda asKeyword, parameters: parameters,
+        name="loop parameters"
+    )
+
     loopFactor = Parser.allOf(
-        factorParser,
+        powerFactor,
-        Parser.terminalParser(TokenType.DASH, createNode=Operator.withValue),
+        Parser.optional(loopParameters),
+        Parser.terminal(TokenType.DASH, createNode=Operator.withValue),
         StatementParser,
-        createNode=Loop.withValues,
+        createNode=Loop.loop,
         name="dash-loop"
     )
 
     return Parser.oneOf(
         loopFactor,
         notOperator,
-        factorParser
+        powerFactor,
+        name="factor"
     )(input)

smnp/ast/node/function.py

@@ -1,128 +1,129 @@
-# from smnp.ast.node.block import BlockNode
+from smnp.ast.node.block import BlockParser
-# from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.identifier import IdentifierLiteralParser
-# from smnp.ast.node.identifier import IdentifierNode
+from smnp.ast.node.iterable import abstractIterableParser
-# from smnp.ast.node.iterable import abstractIterableParser
+from smnp.ast.node.model import Node
-# from smnp.ast.node.model import Node
+from smnp.ast.node.none import NoneNode
-# from smnp.ast.node.none import NoneNode
+from smnp.ast.node.type import TypeParser, Type
-# from smnp.ast.node.statement import StatementNode
+from smnp.ast.parser import Parser
-# from smnp.ast.node.type import TypeNode, TypeSpecifier
+from smnp.token.type import TokenType
-# from smnp.ast.parser import Parser
+
-# from smnp.token.type import TokenType
+
-#
+class ArgumentsDeclaration(Node):
-#
+    pass
-# class ArgumentsDeclarationNode(Node):
+
-#
+
-#     @classmethod
+class Argument(Node):
-#     def _parse(cls, input):
+
-#         raise RuntimeError("This class is not supposed to be automatically called")
+    def __init__(self, pos):
-#
+        super().__init__(pos)
-#
+        self.children = [NoneNode(), NoneNode(), False]
-# class VarargNode(Node):
+
-#     pass
+    @property
-#
+    def type(self):
-#
+        return self[0]
-# class ArgumentDefinitionNode(ExpressionNode):
+
-#     def __init__(self, pos):
+
-#         super().__init__(pos)
+    @type.setter
-#         self.children.extend([NoneNode(), False])
+    def type(self, value):
-#
+        self[0] = value
-#     @property
+
-#     def type(self):
+
-#         return self[0]
+    @property
-#
+    def variable(self):
-#     @type.setter
+        return self[1]
-#     def type(self, value):
+
-#         self[0] = value
+
-#
+    @variable.setter
-#     @property
+    def variable(self, value):
-#     def variable(self):
+        self[1] = value
-#         return self[1]
+
-#
+
-#     @variable.setter
+    @property
-#     def variable(self, value):
+    def vararg(self):
-#         self[1] = value
+        return self[2]
-#
+
-#     @property
+
-#     def vararg(self):
+    @vararg.setter
-#         return self[2]
+    def vararg(self, value):
-#
+        self[2] = value
-#     @vararg.setter
+
-#     def vararg(self, value):
+
-#         self[2] = value
+class VarargNode(Node):
-#
+    pass
-#
+
-#     @classmethod
+
-#     def parser(cls):
+class FunctionDefinition(Node):
-#         def createNode(type, variable, dots):
+    def __init__(self, pos):
-#             node = ArgumentDefinitionNode(type.pos)
+        super().__init__(pos)
-#             node.type = type
+        self.children = [NoneNode(), NoneNode(), NoneNode()]
-#             node.variable = variable
+
-#             node.vararg = isinstance(dots, VarargNode)
+    @property
-#             return node
+    def name(self):
-#
+        return self[0]
-#         return Parser.allOf(
+
-#             Parser.optional(Parser.oneOf(
+    @name.setter
-#                 TypeNode.parse,
+    def name(self, value):
-#                 TypeSpecifier.parse
+        self[0] = value
-#             )),
+
-#             Parser.doAssert(IdentifierNode.identifierParser(), "variable name"),
+    @property
-#             Parser.optional(Parser.terminalParser(TokenType.DOTS, lambda val, pos: VarargNode(pos))),
+    def arguments(self):
-#             createNode=createNode
+        return self[1]
-#         )
+
-#
+    @arguments.setter
-#     @classmethod
+    def arguments(self, value):
-#     def _parse(cls, input):
+        self[1] = value
-#         #TODO
+
-#         raise RuntimeError("Not implemented yet. There is still required work to correctly build AST related to IdentifierNode")
+    @property
-#
+    def body(self):
-#
+        return self[2]
-#
+
-# class FunctionDefinitionNode(StatementNode):
+    @body.setter
-#     def __init__(self, pos):
+    def body(self, value):
-#         super().__init__(pos)
+        self[2] = value
-#         self.children = [NoneNode(), NoneNode(), NoneNode()]
+
-#
+    @classmethod
-#     @property
+    def withValues(cls, name, arguments, body):
-#     def name(self):
+        node = cls(name.pos)
-#         return self[0]
+        node.name = name
-#
+        node.arguments = arguments
-#     @name.setter
+        node.body = body
-#     def name(self, value):
+        return node
-#         self[0] = value
+
-#
+
-#     @property
+def ArgumentParser(input):
-#     def arguments(self):
+    def createNode(type, variable, vararg):
-#         return self[1]
+        pos = type.pos if isinstance(type, Type) else variable.pos
-#
+        node = Argument(pos)
-#     @arguments.setter
+        node.type = type
-#     def arguments(self, value):
+        node.variable = variable
-#         self[1] = value
+        node.vararg = vararg is True
-#
+        return node
-#     @property
+
-#     def body(self):
+    return Parser.allOf(
-#         return self[2]
+        Parser.optional(TypeParser),
-#
+        Parser.doAssert(IdentifierLiteralParser, "argument name"),
-#     @body.setter
+        Parser.optional(Parser.terminal(TokenType.DOTS, lambda val, pos: True)),
-#     def body(self, value):
+        createNode=createNode,
-#         self[2] = value
+        name="function argument"
-#
+    )(input)
-#     @classmethod
+
-#     def _parse(cls, input):
+
-#         def createNode(function, name, arguments, body):
+def ArgumentsDeclarationParser(input):
-#             node = FunctionDefinitionNode(function.pos)
+    return abstractIterableParser(
-#             node.name = name
+        ArgumentsDeclaration,
-#             node.arguments = arguments
+        TokenType.OPEN_PAREN,
-#             node.body = body
+        TokenType.CLOSE_PAREN,
-#             return node
+        Parser.doAssert(ArgumentParser, "function/method argument")
-#
+    )(input)
-#         return Parser.allOf(
+
-#             Parser.terminalParser(TokenType.FUNCTION),
+
-#             Parser.doAssert(IdentifierNode.identifierParser(), "function name"),
+def FunctionDefinitionParser(input):
-#             Parser.doAssert(cls._argumentsDeclarationParser(), "arguments list"),
+    return Parser.allOf(
-#             Parser.doAssert(BlockNode.parse, "function body"),
+        Parser.terminal(TokenType.FUNCTION),
-#             createNode=createNode
+        Parser.doAssert(IdentifierLiteralParser, "function/method name"),
-#         )(input)
+        Parser.doAssert(ArgumentsDeclarationParser, "function/method arguments"),
-#
+        Parser.doAssert(BlockParser, "function/method body"),
-#     @staticmethod
+        createNode=lambda _, name, args, body: FunctionDefinition.withValues(name, args, body),
-#     def _argumentsDeclarationParser():
+        name="function definition"
-#         return abstractIterableParser(ArgumentsDeclarationNode, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, ArgumentDefinitionNode.parser())
+    )(input)
+

smnp/ast/node/identifier.py

@@ -1,5 +1,5 @@
 from smnp.ast.node.atom import Atom
-from smnp.ast.node.expression import MaxPrecedenceExpressionParser
+from smnp.ast.node.expression import ExpressionParser
 from smnp.ast.node.iterable import abstractIterableParser
 from smnp.ast.node.model import Node
 from smnp.ast.node.none import NoneNode
@@ -49,24 +49,26 @@ class Assignment(BinaryOperator):
     pass
 
 
-def IdentifierParser(input):
+def IdentifierLiteralParser(input):
-    identifierLiteralParser = Parser.terminalParser(TokenType.IDENTIFIER, createNode=Identifier.withValue)
+    return Parser.terminal(TokenType.IDENTIFIER, createNode=Identifier.withValue)(input)
 
+
+def IdentifierParser(input):
     functionCallParser = Parser.allOf(
-        identifierLiteralParser,
+        IdentifierLiteralParser,
-        abstractIterableParser(ArgumentsList, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, MaxPrecedenceExpressionParser),
+        abstractIterableParser(ArgumentsList, TokenType.OPEN_PAREN, TokenType.CLOSE_PAREN, Parser.doAssert(ExpressionParser, "expression")),
         createNode=lambda name, arguments: FunctionCall.withChildren(name, arguments)
     )
 
     assignmentParser = Parser.allOf(
-        identifierLiteralParser,
+        IdentifierLiteralParser,
-        Parser.terminalParser(TokenType.ASSIGN, createNode=Operator.withValue),
+        Parser.terminal(TokenType.ASSIGN, createNode=Operator.withValue),
-        MaxPrecedenceExpressionParser,
+        Parser.doAssert(ExpressionParser, "expression"),
         createNode=lambda identifier, assign, expr: Assignment.withValues(identifier, assign, expr)
     )
 
     return Parser.oneOf(
         assignmentParser,
         functionCallParser,
-        identifierLiteralParser
+        IdentifierLiteralParser
     )(input)

smnp/ast/node/imports.py

@@ -1,11 +1,3 @@
-# from smnp.ast.node.identifier import Identifier
-# 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
-#
 from smnp.ast.node.atom import StringParser
 from smnp.ast.node.model import Node
 from smnp.ast.parser import Parser
@@ -34,8 +26,8 @@ class Import(Node):
 
 def ImportParser(input):
     return Parser.allOf(
-        Parser.terminalParser(TokenType.IMPORT),
+        Parser.terminal(TokenType.IMPORT),
-        StringParser,
+        Parser.doAssert(StringParser, "import source as string"),
         createNode=lambda imp, source: Import.withValue(source),
         name="import"
     )(input)

smnp/ast/node/iterable.py

@@ -45,8 +45,8 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
             return node
 
         return Parser.allOf(
-            Parser.terminalParser(openTokenType),
+            Parser.terminal(openTokenType),
-            Parser.terminalParser(closeTokenType),
+            Parser.terminal(closeTokenType),
             createNode=createNode
         )(input)
 
@@ -58,7 +58,7 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
             return node
 
         return Parser.allOf(
-            Parser.terminalParser(openTokenType),
+            Parser.terminal(openTokenType),
             itemParser,
             abstractIterableTailParser,
             createNode=createNode
@@ -78,14 +78,14 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
             return node
 
         return Parser.allOf(
-            Parser.terminalParser(TokenType.COMMA, doAssert=True),
+            Parser.doAssert(Parser.terminal(TokenType.COMMA), f"'{TokenType.COMMA.key}' or '{closeTokenType.key}'"),
             itemParser,
             abstractIterableTailParser,
             createNode=createNode
         )(input)
 
     def closeIterable(input):
-        return Parser.terminalParser(closeTokenType)(input)
+        return Parser.terminal(closeTokenType)(input)
 
 
     return toFlatDesiredNode(iterableNodeType, abstractIterableParser)

smnp/ast/node/list.py

@@ -1,5 +1,6 @@
 from smnp.ast.node.iterable import abstractIterableParser
 from smnp.ast.node.model import Node
+from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
 
@@ -8,6 +9,11 @@ class List(Node):
 
 
 def ListParser(input):
-    from smnp.ast.node.expression import MaxPrecedenceExpressionParser
+    from smnp.ast.node.expression import ExpressionParser
-    return abstractIterableParser(List, TokenType.OPEN_SQUARE, TokenType.CLOSE_SQUARE,
+
-                                    MaxPrecedenceExpressionParser)(input)
+    return abstractIterableParser(
+        List,
+        TokenType.OPEN_SQUARE,
+        TokenType.CLOSE_SQUARE,
+        Parser.doAssert(ExpressionParser, "expression")
+    )(input)

smnp/ast/node/map.py

@@ -30,17 +30,21 @@ class Map(Node):
 
 
 def MapParser(input):
-    from smnp.ast.node.expression import MaxPrecedenceExpressionParser
+    from smnp.ast.node.expression import ExpressionParser
     keyParser = LiteralParser
-    valueParser = MaxPrecedenceExpressionParser
+    valueParser = ExpressionParser
 
     mapEntryParser = Parser.allOf(
         keyParser,
-        Parser.terminalParser(TokenType.ARROW, createNode=Operator.withValue),
+        Parser.terminal(TokenType.ARROW, createNode=Operator.withValue, doAssert=True),
-        valueParser,
+        Parser.doAssert(valueParser, "expression"),
         createNode=MapEntry.withValues
     )
 
-    mapParser = abstractIterableParser(Map, TokenType.OPEN_CURLY, TokenType.CLOSE_CURLY, mapEntryParser)
+    return abstractIterableParser(
+        Map,
+        TokenType.OPEN_CURLY,
+        TokenType.CLOSE_CURLY,
+        mapEntryParser
+    )(input)
 
-    return Parser(mapParser, "map", [mapParser])(input)

smnp/ast/node/model.py

@@ -28,21 +28,6 @@ class Node:
     def pop(self, index):
         return self.children.pop(index)
 
-    @classmethod
-    def _parse(cls, input):
-        pass
-
-    @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)
 

smnp/ast/node/operator.py

@@ -68,68 +68,7 @@ class BinaryOperator(Node):
         node.right = right
         return node
 
-#
+
-# class LeftAssociativeOperatorNode(ExpressionNode):
-#     def __init__(self, pos):
-#         super().__init__(pos)
-#         self.children = [NoneNode(), NoneNode(), NoneNode()]
-#
-#     @property
-#     def left(self):
-#         return self[0]
-#
-#     @left.setter
-#     def left(self, value):
-#         self[0] = value
-#
-#     @property
-#     def operator(self):
-#         return self[1]
-#
-#     @operator.setter
-#     def operator(self, value):
-#         self[1] = value
-#
-#     @property
-#     def right(self):
-#         return self[2]
-#
-#     @right.setter
-#     def right(self, value):
-#         self[2] = value
-#
-#     @classmethod
-#     def _parse(cls, input):
-#         def createNode(left, operator, right):
-#             node = LeftAssociativeOperatorNode(right.pos)
-#             node.left = left
-#             node.operator = operator
-#             node.right = right
-#             return node
-#
-#         return Parser.leftAssociativeOperatorParser(
-#             cls._lhsParser(),
-#             TokenType.DOT,
-#             cls._rhsParser(),
-#             createNode=createNode
-#         )(input)
-#
-#     @classmethod
-#     def _lhsParser(cls):
-#         raise RuntimeError(f"LHS parser is not implemented in {cls.__name__}")
-#
-#     @staticmethod
-#     def _rhsParser():
-#         from smnp.ast.node.identifier import IdentifierNode
-#
-#         return Parser.oneOf(
-#             # TODO!!!
-#             IdentifierNode._lhsParser(),
-#             IdentifierNode._functionCallParser(),
-#             exception=lambda input: SyntaxException(f"Expected property name or method call, found '{input.current().rawValue}'", input.currentPos())
-#         )
-#
-#
 class Operator(Node):
     def __init__(self, pos):
         super().__init__(pos)

smnp/ast/node/program.py

@@ -1,44 +1,36 @@
+from smnp.ast.node.extend import ExtendParser
+from smnp.ast.node.function import FunctionDefinitionParser
 from smnp.ast.node.imports import ImportParser
 from smnp.ast.node.model import Node, ParseResult
 from smnp.ast.node.statement import StatementParser
 from smnp.ast.parser import Parser
+from smnp.error.syntax import SyntaxException
 
 
 class Program(Node):
     def __init__(self):
         super().__init__((-1, -1))
 
-def parse(input):
+def ProgramParser(input):
-    root = Program()
+    def parse(input):
-    while input.hasCurrent():
+        root = Program()
-        result = Parser.oneOf(
+
-            # Start Symbol
+        # Start Symbol
+        startSymbolParser = Parser.oneOf(
             ImportParser,
+            FunctionDefinitionParser,
+            ExtendParser,
             StatementParser,
-            exception=RuntimeError("Nie znam tego wyrazenia")
+            exception=lambda inp: SyntaxException(f"Invalid statement: {inp.currentToEndOfLine()}", inp.current().pos),
-        )(input)
+            name="start symbol"
+        )
 
-        if result.result:
+        while input.hasCurrent():
-            root.append(result.node)
+            result = startSymbolParser(input)
 
-    return ParseResult.OK(root)
+            if result.result:
+                root.append(result.node)
 
-ProgramParser = Parser(parse, name="program")
+        return ParseResult.OK(root)
-    # @classmethod
+
-    # def _parse(cls, input):
+    return Parser(parse, name="program")(input)
-    #     def parseToken(input):
-    #         return Parser.oneOf(
-    #             FunctionDefinitionNode.parse,
-    #             ExtendNode.parse,
-    #             ExpressionNode.parse,
-    #             ImportNode.parse,
-    #             StatementNode.parse,
-    #             exception = SyntaxException(f"Invalid statement: {input.currentToEndOfLine()}", 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,32 +1,17 @@
-# from smnp.ast.node.expression import ExpressionNode
+from smnp.ast.node.expression import ExpressionParser
-# from smnp.ast.node.none import NoneNode
+from smnp.ast.node.valuable import Valuable
-# from smnp.ast.node.statement import StatementNode
+from smnp.ast.parser import Parser
-# from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
-# from smnp.token.type import TokenType
+
-#
+
-#
+class Return(Valuable):
-# class ReturnNode(StatementNode):
+    pass
-#     def __init__(self, pos):
+
-#         super().__init__(pos)
+
-#         self.children.append(NoneNode())
+def ReturnParser(input):
-#
+    return Parser.allOf(
-#     @property
+        Parser.terminal(TokenType.RETURN),
-#     def value(self):
+        Parser.optional(ExpressionParser),
-#         return self[0]
+        createNode=lambda ret, val: Return.withValue(val, ret.pos),
-#
+        name="return"
-#     @value.setter
+    )(input)
-#     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),
-#             Parser.doAssert(ExpressionNode.parse, "expression"),
-#             createNode=createNode
-#         )(input)

smnp/ast/node/statement.py

@@ -1,4 +1,3 @@
-from smnp.ast.node.expression import MaxPrecedenceExpressionParser
 from smnp.ast.node.model import Node
 from smnp.ast.parser import Parser
 
@@ -10,25 +9,13 @@ class Statement(Node):
 def StatementParser(input):
     from smnp.ast.node.block import BlockParser
     from smnp.ast.node.condition import IfElseStatementParser
+    from smnp.ast.node.expression import ExpressionParser
 
-    parser = Parser.oneOf(
+    from smnp.ast.node.ret import ReturnParser
+    return Parser.oneOf(
         IfElseStatementParser,
+        ExpressionParser,
         BlockParser,
-        MaxPrecedenceExpressionParser
+        ReturnParser,
-    )
+        name="statement"
-
+    )(input)
-    return Parser(parser, "statement", parser)(input)
-
-# 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(
-#             ExpressionNode.parse,
-#             BlockNode.parse,
-#             ReturnNode.parse,
-#         )(input)

smnp/ast/node/term.py

@@ -1,12 +1,17 @@
 from smnp.ast.node.factor import FactorParser
 from smnp.ast.node.operator import BinaryOperator
-from smnp.ast.node.valuable import Valuable
 from smnp.ast.parser import Parser
 from smnp.token.type import TokenType
 
 
-class Term(Valuable):
+class Product(BinaryOperator):
     pass
 
-TermParser = Parser.leftAssociativeOperatorParser(FactorParser, [TokenType.ASTERISK, TokenType.SLASH], FactorParser,
+
-                                                    lambda left, op, right: Term.withValue(BinaryOperator.withValues(left, op, right)))
+def TermParser(input):
+    return Parser.leftAssociativeOperatorParser(
+        FactorParser,
+        [TokenType.ASTERISK, TokenType.SLASH],
+        FactorParser,
+        lambda left, op, right: Product.withValues(left, op, right)
+    )(input)

smnp/ast/node/type.py

@@ -1,63 +1,67 @@
-# from smnp.ast.node.iterable import abstractIterableParser
+from smnp.ast.node.atom import TypeLiteralParser
-# from smnp.ast.node.model import Node
+from smnp.ast.node.iterable import abstractIterableParser
-# from smnp.ast.node.operator import LeftAssociativeOperatorNode
+from smnp.ast.node.model import Node
-# from smnp.ast.parser import Parser
+from smnp.ast.node.none import NoneNode
-# from smnp.token.type import TokenType
+from smnp.ast.parser import Parser
-# from smnp.type.model import Type
+from smnp.token.type import TokenType
-#
+
-#
+
-# class TypeSpecifier(Node):
+class Type(Node):
-#
+    def __init__(self, pos):
-#     @classmethod
+        super().__init__(pos)
-#     def _parse(cls, input):
+        self.children = [NoneNode(), NoneNode()]
-#         return abstractIterableParser(TypeSpecifier, TokenType.OPEN_ANGLE, TokenType.CLOSE_ANGLE,
+
-#                                       Parser.doAssert(cls._specifierItem(), "type"))(input)
+    @property
-#
+    def type(self):
-#     @classmethod
+        return self[0]
-#     def _specifierItem(cls):
+
-#         return Parser.oneOf(
+    @type.setter
-#             TypeNode.parse,
+    def type(self, value):
-#             cls.parse
+        self[0] = value
-#         )
+
-#
+    @property
-# class TypeSpecifiers(Node):
+    def specifiers(self):
-#     pass
+        return self[1]
-#
+
-#
+    @specifiers.setter
-# class TypeNode(LeftAssociativeOperatorNode):
+    def specifiers(self, value):
-#     def __init__(self, pos):
+        self[1] = value
-#         super().__init__(pos)
+
-#
+    @classmethod
-#     @property
+    def withValues(cls, pos, type, specifiers=NoneNode()):
-#     def type(self):
+        node = cls(pos)
-#         return self[0]
+        node.type = type
-#
+        node.specifiers = specifiers
-#     @type.setter
+        return node
-#     def type(self, value):
+
-#         self[0] = value
+
-#
+class TypesList(Node):
-#     @property
+    pass
-#     def specifiers(self):
+
-#         return self[1]
+
-#
+def TypesListParser(input):
-#     @specifiers.setter
+    return abstractIterableParser(
-#     def specifiers(self, value):
+        TypesList,
-#         self[1] = value
+        TokenType.OPEN_ANGLE,
-#
+        TokenType.CLOSE_ANGLE,
-#     @classmethod
+        TypeParser
-#     def _parse(cls, input):
+    )(input)
-#         def createNode(type, specifiers):
+
-#             node = TypeNode(type.pos)
+
-#             node.type = Type[type.value.upper()]
+class TypeSpecifiers(Node):
-#             node.specifiers = specifiers
+    pass
-#             return node
+
-#
+
-#         return Parser.allOf(
+def TypeParser(input):
-#             cls._rawTypeParser(),
+    typeWithSpecifier = Parser.allOf(
-#             Parser.many(TypeSpecifier.parse, lambda specifiers, pos: TypeSpecifiers.withChildren(specifiers, pos)),
+        TypeLiteralParser,
-#             createNode=createNode
+        Parser.many(TypesListParser, createNode=TypeSpecifiers.withChildren),
-#         )(input)
+        createNode=lambda type, specifiers: Type.withValues(type.pos, type, specifiers),
-#
+        name="type with specifiers?"
-#     @classmethod
+    )
-#     def _rawTypeParser(cls):
+
-#         return Parser.terminalParser(TokenType.TYPE, lambda val, pos: TypeNode.withValue(val, pos))
+    return Parser.oneOf(
+        typeWithSpecifier,
+        TypesListParser,
+        name="mult. types or type with specifier"
+    )(input)

smnp/ast/node/unit.py

@@ -0,0 +1,36 @@
+from smnp.ast.node.atom import AtomParser
+from smnp.ast.node.operator import BinaryOperator, UnaryOperator, Operator
+from smnp.ast.parser import Parser
+from smnp.token.type import TokenType
+
+
+class MinusOperator(UnaryOperator):
+    pass
+
+
+class Access(BinaryOperator):
+    pass
+
+
+def UnitParser(input):
+    minusOperator = Parser.allOf(
+        Parser.terminal(TokenType.MINUS, createNode=Operator.withValue),
+        Parser.doAssert(AtomParser, "atom"),
+        createNode=MinusOperator.withValues,
+        name="minus"
+    )
+
+    atom2 = Parser.oneOf(
+        minusOperator,
+        AtomParser,
+        name="atom2"
+    )
+
+    return Parser.leftAssociativeOperatorParser(
+        atom2,
+        [TokenType.DOT],
+        Parser.doAssert(atom2, "atom"),
+        createNode=lambda left, op, right: Access.withValues(left, op, right),
+        name="unit"
+    )(input)
+

smnp/ast/node/valuable.py

@@ -16,7 +16,7 @@ class Valuable(Node):
         self[0] = value
 
     @classmethod
-    def withValue(cls, value):
+    def withValue(cls, value, pos=None):
-        node = cls(value.pos)
+        node = cls(value.pos if pos is None else pos)
         node.value = value
         return node

smnp/ast/parser.py

@@ -41,7 +41,7 @@ class Parser:
 
     # a -> A
     @staticmethod
-    def terminalParser(expectedType, createNode=None, doAssert=False):
+    def terminal(expectedType, createNode=None, doAssert=False):
         def provideNode(value, pos):
             if createNode is None:
                 return IgnoredNode(pos)
@@ -62,13 +62,18 @@ class Parser:
 
     # oneOf -> a | b | c | ...
     @staticmethod
-    def oneOf(*parsers, exception=None, name="or"):
+    def oneOf(*parsers, assertExpected=None, exception=None, name="or"):
         def combinedParser(input):
             snap = input.snapshot()
             for parser in parsers:
                 value = parser(input)
                 if value.result:
                     return value
+                input.reset(snap)
+
+            if assertExpected is not None:
+                found = f", found '{input.current().rawValue}'" if input.hasCurrent() else ""
+                raise SyntaxException(f"Expected {assertExpected}{found}", input.currentPos())
 
             if exception is not None:
                 if callable(exception):
@@ -76,7 +81,6 @@ class Parser:
                 else:
                     raise exception
 
-
             input.reset(snap)
             return ParseResult.FAIL()
 
@@ -140,7 +144,7 @@ class Parser:
 
     @staticmethod
     def oneOfTerminals(*tokenTypes, createNode=None):
-        return Parser.oneOf(*[ Parser.terminalParser(expectedType, createNode=createNode) for expectedType in tokenTypes ], name='|'.join([t.value for t in tokenTypes]))
+        return Parser.oneOf(*[Parser.terminal(expectedType, createNode=createNode) for expectedType in tokenTypes], name='|'.join([t.value for t in tokenTypes]))
 
     # loop -> start item* end
     @staticmethod
@@ -207,3 +211,14 @@ class Parser:
                     return ParseResult.OK(createNode(results, pos) if len(results) > 0 else NoneNode())
 
         return Parser(parse, name, parsers=[parser])
+
+    @staticmethod
+    def wrap(parser, createNode):
+        def parse(input):
+            result = parser(input)
+            if result.result:
+                return ParseResult.OK(createNode(result.node))
+
+            return result
+
+        return parse

smnp/audio/sound.py

@@ -10,6 +10,9 @@ class Sound:
     def play(self):
         sd.play(self.data, self.fs, blocking=True)
 
+    def __eq__(self, other):
+        return self.file == other.file and self.data == other.data
+
     def __str__(self):
         return f"sound[{self.file}]"
 

smnp/library/loader.py

@@ -5,7 +5,5 @@ from smnp.program.interpreter import Interpreter
 
 def loadStandardLibrary():
     mainSource = resource_string('smnp.library.code', 'main.mus').decode("utf-8")
-    boolSource = resource_string('smnp.library.code', 'bool.mus').decode("utf-8")
     env = Interpreter.interpretString(mainSource)
-    return Interpreter.interpretString(boolSource, baseEnvironment=env)
+    return env
-

smnp/main.py

@@ -1,14 +1,17 @@
 import sys
 
 from smnp.error.base import SmnpException
+from smnp.library.loader import loadStandardLibrary
 from smnp.program.interpreter import Interpreter
 
 
 def main():
     try:
-        #stdLibraryEnv = loadStandardLibrary()
+        stdLibraryEnv = loadStandardLibrary()
-        Interpreter.interpretFile(sys.argv[1], printTokens=True, printAst=True, execute=False, baseEnvironment=None)
+        Interpreter.interpretFile(sys.argv[1], printTokens=False, printAst=False, execute=True, baseEnvironment=stdLibraryEnv)
         #draft()
+        #tokens = tokenize(['function a(b...) { x+y}'])
+        #FunctionDefinitionParser(tokens).node.print()
 
     except SmnpException as e:
         print(e.message())

smnp/module/iterable/__init__.py

@@ -1,4 +1,4 @@
-from smnp.module.iterable.function import combine, flat, map, range, get
+from smnp.module.iterable.function import combine, map, range, get
 
-functions = [ combine.function, flat.function, map.function, range.function ]
+functions = [ combine.function, map.function, range.function ]
 methods = [ get.function ]

smnp/module/iterable/function/flat.py

@@ -1,23 +0,0 @@
-from smnp.function.model import Function
-from smnp.function.signature import varargSignature
-from smnp.type.model import Type
-from smnp.type.signature.matcher.type import allTypes
-
-_signature = varargSignature(allTypes())
-def _function(env, vararg):
-    return Type.list(doFlat(vararg, [])).decompose()
-
-
-def doFlat(input, output=None):
-    if output is None:
-        output = []
-
-    for item in input:
-        if item.type == Type.LIST:
-            doFlat(item.value, output)
-        else:
-            output.append(item)
-    return output
-
-
-function = Function(_signature, _function, 'flat')

smnp/module/iterable/function/range.py

@@ -6,17 +6,17 @@ from smnp.type.signature.matcher.type import ofType
 
 _signature1 = signature(ofType(Type.INTEGER))
 def _function1(env, upper):
-    return Type.list(list(range(upper.value + 1)))
+    return Type.list([ Type.integer(i) for i in range(upper.value + 1)])
 
 
 _signature2 = signature(ofType(Type.INTEGER), ofType(Type.INTEGER))
 def _function2(env, lower, upper):
-    return Type.list(list(range(lower.value, upper.value + 1)))
+    return Type.list([ Type.integer(i) for i in range(lower.value, upper.value + 1)])
 
 
 _signature3 = signature(ofType(Type.INTEGER), ofType(Type.INTEGER), ofType(Type.INTEGER))
 def _function3(env, lower, upper, step):
-    return Type.list(list(range(lower.value, upper.value + 1, step.value)))
+    return Type.list([ Type.integer(i) for i in range(lower.value, upper.value + 1, step.value)])
 
 
 _signature4 = signature(ofType(Type.NOTE), ofType(Type.NOTE))

smnp/program/interpreter.py

@@ -1,7 +1,8 @@
 from smnp.ast.parser import parse
-#from smnp.environment.factory import createEnvironment
+from smnp.environment.factory import createEnvironment
 from smnp.error.runtime import RuntimeException
 from smnp.program.FileReader import readLines
+from smnp.runtime.evaluator import evaluate
 from smnp.token.tokenizer import tokenize
 
 
@@ -17,9 +18,9 @@ class Interpreter:
 
     @staticmethod
     def _interpret(lines, printTokens=False, printAst=False, execute=True, baseEnvironment=None):
-        #environment = createEnvironment()
+        environment = createEnvironment()
-        #if baseEnvironment is not None:
+        if baseEnvironment is not None:
-        #    environment.extend(baseEnvironment)
+            environment.extend(baseEnvironment)
 
         try:
             tokens = tokenize(lines)
@@ -30,10 +31,10 @@ class Interpreter:
             if printAst:
                 ast.print()
 
-            #if execute:
+            if execute:
-            #    evaluate(ast, environment)
+                evaluate(ast, environment)
 
-            #return environment
+            return environment
         except RuntimeException as e:
-            #e.environment = environment
+            e.environment = environment
             raise e

smnp/runtime/evaluator.py

@@ -1,9 +1,10 @@
-from smnp.ast.node.block import BlockNode
+from smnp.ast.node.block import Block
-from smnp.ast.node.extend import ExtendNode
+from smnp.ast.node.condition import IfElse
-from smnp.ast.node.function import FunctionDefinitionNode
+from smnp.ast.node.extend import Extend
-from smnp.ast.node.imports import ImportNode
+from smnp.ast.node.function import FunctionDefinition
+from smnp.ast.node.imports import Import
 from smnp.ast.node.program import Program
-from smnp.ast.node.ret import ReturnNode
+from smnp.ast.node.ret import Return
 from smnp.error.runtime import RuntimeException
 from smnp.type.model import Type
 
@@ -68,20 +69,27 @@ class EvaluationResult():
 
 def evaluate(node, environment):
     from smnp.runtime.evaluators.program import ProgramEvaluator
-    from smnp.runtime.evaluators.expression import expressionEvaluator
 
-    from smnp.runtime.evaluators.function import FunctionDefinitionEvaluator
+    from smnp.runtime.evaluators.expression import expressionEvaluator
-    from smnp.runtime.evaluators.extend import ExtendEvaluator
+    from smnp.runtime.evaluators.condition import IfElseStatementEvaluator
     from smnp.runtime.evaluators.block import BlockEvaluator
     from smnp.runtime.evaluators.imports import ImportEvaluator
+    from smnp.runtime.evaluators.function import FunctionDefinitionEvaluator
     from smnp.runtime.evaluators.function import ReturnEvaluator
+    from smnp.runtime.evaluators.extend import ExtendEvaluator
     result = Evaluator.oneOf(
         Evaluator.forNodes(ProgramEvaluator.evaluate, Program),
-        Evaluator.forNodes(ImportEvaluator.evaluate, ImportNode),
+        Evaluator.forNodes(IfElseStatementEvaluator.evaluate, IfElse),
-        Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinitionNode),
+        Evaluator.forNodes(BlockEvaluator.evaluate, Block),
-        Evaluator.forNodes(ExtendEvaluator.evaluate, ExtendNode),
+        Evaluator.forNodes(ImportEvaluator.evaluate, Import),
-        Evaluator.forNodes(BlockEvaluator.evaluate, BlockNode),
+        Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinition),
-        Evaluator.forNodes(ReturnEvaluator.evaluate, ReturnNode),
+        Evaluator.forNodes(ReturnEvaluator.evaluate, Return),
+        Evaluator.forNodes(ExtendEvaluator.evaluate, Extend),
+        #Evaluator.forNodes(ImportEvaluator.evaluate, ImportNode),
+        #Evaluator.forNodes(FunctionDefinitionEvaluator.evaluate, FunctionDefinitionNode),
+        #Evaluator.forNodes(ExtendEvaluator.evaluate, ExtendNode),
+        #Evaluator.forNodes(BlockEvaluator.evaluate, BlockNode),
+        #Evaluator.forNodes(ReturnEvaluator.evaluate, ReturnNode),
         expressionEvaluator()
     )(node, environment)
 

smnp/runtime/evaluators/access.py

@@ -1,5 +1,4 @@
-from smnp.ast.node.identifier import Identifier
+from smnp.ast.node.identifier import Identifier, FunctionCall
-from smnp.ast.node.invocation import FunctionCallNode
 from smnp.error.runtime import RuntimeException
 from smnp.runtime.evaluator import Evaluator
 from smnp.runtime.evaluators.expression import expressionEvaluator
@@ -20,9 +19,9 @@ class AccessEvaluator(Evaluator):
             except KeyError:
                 raise RuntimeException(f"Unknown property '{right.value}' of type '{left.type.name.lower()}'", right.pos)
 
-        if type(right) == FunctionCallNode:
+        if type(right) == FunctionCall:
             try:
-                arguments = abstractIterableEvaluator(expressionEvaluator(True))(right.arguments, environment)
+                arguments = abstractIterableEvaluator(expressionEvaluator(doAssert=True))(right.arguments, environment)
                 return environment.invokeMethod(left, right.name.value, arguments)
             except RuntimeException as e:
                 raise updatePos(e, right)

smnp/runtime/evaluators/assignment.py

@@ -1,4 +1,3 @@
-from smnp.error.runtime import RuntimeException
 from smnp.runtime.evaluator import Evaluator
 from smnp.runtime.evaluators.expression import expressionEvaluator
 
@@ -7,11 +6,8 @@ class AssignmentEvaluator(Evaluator):
 
     @classmethod
     def evaluator(cls, node, environment):
-        target = node.target.value
+        target = node.left.value
-        if target.startswith("_"):
+        value = expressionEvaluator(doAssert=True)(node.right, environment).value #TODO check if it isn't necessary to verify 'result' attr of EvaluatioNResult
-            raise RuntimeException("Declaration and assignation variables with names starting with '_' is not allowed", node.target.pos)
-
-        value = expressionEvaluator(doAssert=True)(node.value, environment).value #TODO check if it isn't necessary to verify 'result' attr of EvaluatioNResult
         scopeOfExistingVariable = environment.findVariableScope(target)
         if scopeOfExistingVariable is None:
             environment.scopes[-1][target] = value

smnp/runtime/evaluators/atom.py

@@ -0,0 +1,94 @@
+from smnp.ast.node.atom import StringLiteral, IntegerLiteral, NoteLiteral, BoolLiteral, TypeLiteral
+from smnp.ast.node.identifier import Identifier
+from smnp.ast.node.list import List
+from smnp.ast.node.map import Map
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.runtime.evaluators.iterable import abstractIterableEvaluator
+from smnp.runtime.tools.error import updatePos
+from smnp.type.model import Type
+
+
+class IntegerEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.integer(node.value)
+
+
+class StringEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.string(node.value)
+
+
+class NoteEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.note(node.value)
+
+
+class BoolEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.bool(node.value)
+
+
+class TypeEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Type.type(node.value)
+
+
+class ListEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        list = abstractIterableEvaluator(expressionEvaluator(doAssert=True))(node, environment)
+        return Type.list(list)
+
+
+class MapEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        map = {}
+        exprEvaluator = expressionEvaluator(doAssert=True)
+        for entry in node.children:
+            key = exprEvaluator(entry.key, environment).value
+            if key in map:
+                raise RuntimeException(f"Duplicated key '{key.stringify()}' found in map", entry.pos)
+            map[key] = exprEvaluator(entry.value, environment).value
+
+        return Type.map(map)
+
+
+class IdentifierEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        try:
+            return environment.findVariable(node.value)
+        except RuntimeException as e:
+            raise updatePos(e, node)
+
+
+class AtomEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return Evaluator.oneOf(
+            Evaluator.forNodes(StringEvaluator.evaluate, StringLiteral),
+            Evaluator.forNodes(IntegerEvaluator.evaluate, IntegerLiteral),
+            Evaluator.forNodes(NoteEvaluator.evaluate, NoteLiteral),
+            Evaluator.forNodes(BoolEvaluator.evaluate, BoolLiteral),
+            Evaluator.forNodes(TypeEvaluator.evaluate, TypeLiteral),
+            Evaluator.forNodes(IdentifierEvaluator.evaluate, Identifier),
+            Evaluator.forNodes(ListEvaluator.evaluate, List),
+            Evaluator.forNodes(MapEvaluator.evaluate, Map)
+        )(node, environment).value

smnp/runtime/evaluators/condition.py

@@ -0,0 +1,35 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator, evaluate
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class IfElseEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        condition = expressionEvaluator(doAssert=True)(node.condition, environment).value
+
+        if condition.type != Type.BOOL:
+            raise RuntimeException(f"Only {Type.BOOL.name.lower()} types can be used as conditions in conditional expression", node.condition.pos)
+
+        if condition.value:
+            return expressionEvaluator(doAssert=True)(node.ifNode, environment).value
+        else:
+            return expressionEvaluator(doAssert=True)(node.elseNode, environment).value
+
+
+class IfElseStatementEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        condition = expressionEvaluator(doAssert=True)(node.condition, environment).value
+
+        if condition.type != Type.BOOL:
+            raise RuntimeException(
+                f"Only {Type.BOOL.name.lower()} types can be used as conditions in conditional expression", node.condition.pos)
+
+        if condition.value:
+            evaluate(node.ifNode, environment)
+        else:
+            evaluate(node.elseNode, environment)

smnp/runtime/evaluators/expression.py

@@ -1,15 +1,9 @@
-from smnp.ast.node.assignment import AssignmentNode
+from smnp.ast.node.condition import IfElse
-from smnp.ast.node.asterisk import AsteriskNode
+from smnp.ast.node.expression import Sum, Relation
-from smnp.ast.node.bool import BoolLiteralNode
+from smnp.ast.node.factor import NotOperator, Power, Loop
-from smnp.ast.node.identifier import Identifier
+from smnp.ast.node.identifier import FunctionCall, Assignment
-from smnp.ast.node.integer import IntegerLiteralNode
+from smnp.ast.node.term import Product
-from smnp.ast.node.invocation import FunctionCallNode
+from smnp.ast.node.unit import MinusOperator, Access
-from smnp.ast.node.list import List
-from smnp.ast.node.map import MapNode
-from smnp.ast.node.note import NoteLiteralNode
-from smnp.ast.node.operator import LeftAssociativeOperatorNode
-from smnp.ast.node.string import StringLiteralNode
-from smnp.ast.node.type import TypeNode
 from smnp.error.runtime import RuntimeException
 from smnp.runtime.evaluator import Evaluator
 from smnp.type.model import Type
@@ -17,38 +11,38 @@ from smnp.type.model import Type
 
 def expressionEvaluator(doAssert=False):
     def evaluateExpression(node, environment):
-            from smnp.runtime.evaluators.string import StringEvaluator
+        from smnp.runtime.evaluators.function import FunctionCallEvaluator
-            from smnp.runtime.evaluators.integer import IntegerEvaluator
+        from smnp.runtime.evaluators.minus import MinusEvaluator
-            from smnp.runtime.evaluators.note import NoteEvaluator
+        from smnp.runtime.evaluators.atom import AtomEvaluator
-            from smnp.runtime.evaluators.identifier import IdentifierEvaluator
+        from smnp.runtime.evaluators.access import AccessEvaluator
-            from smnp.runtime.evaluators.list import ListEvaluator
+        from smnp.runtime.evaluators.negation import NotEvaluator
-            from smnp.runtime.evaluators.function import FunctionCallEvaluator
+        from smnp.runtime.evaluators.power import PowerEvaluator
+        from smnp.runtime.evaluators.loop import LoopEvaluator
+        from smnp.runtime.evaluators.assignment import AssignmentEvaluator
+        from smnp.runtime.evaluators.product import ProductEvaluator
 
-            from smnp.runtime.evaluators.access import AccessEvaluator
+        from smnp.runtime.evaluators.sum import SumEvaluator
-            from smnp.runtime.evaluators.assignment import AssignmentEvaluator
+        from smnp.runtime.evaluators.relation import RelationEvaluator
-            from smnp.runtime.evaluators.asterisk import AsteriskEvaluator
+        from smnp.runtime.evaluators.condition import IfElseEvaluator
-            from smnp.runtime.evaluators.map import MapEvaluator
+        result = Evaluator.oneOf(
-            from smnp.runtime.evaluators.type import TypeEvaluator
+            Evaluator.forNodes(FunctionCallEvaluator.evaluate, FunctionCall),
-            from smnp.runtime.evaluators.bool import BoolEvaluator
+            Evaluator.forNodes(MinusEvaluator.evaluate, MinusOperator),
-            result =  Evaluator.oneOf(
+            Evaluator.forNodes(AccessEvaluator.evaluate, Access),
-                Evaluator.forNodes(FunctionCallEvaluator.evaluate, FunctionCallNode),
+            Evaluator.forNodes(NotEvaluator.evaluate, NotOperator),
-                Evaluator.forNodes(StringEvaluator.evaluate, StringLiteralNode),
+            Evaluator.forNodes(PowerEvaluator.evaluate, Power),
-                Evaluator.forNodes(IntegerEvaluator.evaluate, IntegerLiteralNode),
+            Evaluator.forNodes(LoopEvaluator.evaluate, Loop),
-                Evaluator.forNodes(NoteEvaluator.evaluate, NoteLiteralNode),
+            Evaluator.forNodes(AssignmentEvaluator.evaluate, Assignment),
-                Evaluator.forNodes(BoolEvaluator.evaluate, BoolLiteralNode),
+            Evaluator.forNodes(ProductEvaluator.evaluate, Product),
-                Evaluator.forNodes(TypeEvaluator.evaluate, TypeNode),
+            Evaluator.forNodes(SumEvaluator.evaluate, Sum),
-                Evaluator.forNodes(IdentifierEvaluator.evaluate, Identifier),
+            Evaluator.forNodes(RelationEvaluator.evaluate, Relation),
-                Evaluator.forNodes(ListEvaluator.evaluate, List),
+            Evaluator.forNodes(IfElseEvaluator.evaluate, IfElse),
-                Evaluator.forNodes(AccessEvaluator.evaluate, LeftAssociativeOperatorNode),
+            AtomEvaluator.evaluate
-                Evaluator.forNodes(AssignmentEvaluator.evaluate, AssignmentNode),
+        )(node, environment)
-                Evaluator.forNodes(AsteriskEvaluator.evaluate, AsteriskNode),
-                Evaluator.forNodes(MapEvaluator.evaluate, MapNode)
-            )(node, environment)
 
-            if doAssert and result.result and result.value.type == Type.VOID:
+        if doAssert and result.result and result.value.type == Type.VOID:
-                raise RuntimeException(f"Expected expression", node.pos)
+            raise RuntimeException(f"Expected expression", node.pos)
+
+        return result
 
-            return result
 
     return evaluateExpression
-

smnp/runtime/evaluators/extend.py

@@ -17,11 +17,11 @@ class ExtendEvaluator(Evaluator):
     @classmethod
     def _typeToMethodSignature(cls, node):
         if type(node.specifiers) == NoneNode:
-            return signature(ofType(node.type))
+            return signature(ofType(node.type.value))
 
-        elif node.type == Type.LIST:
+        elif node.type.value == Type.LIST:
             return signature(listSpecifier(node.specifiers[0]))
-        elif node.type == Type.MAP:
+        elif node.type.value == Type.MAP:
             return signature(mapSpecifier(node.specifiers[0], node.specifiers[1]))
 
     @classmethod

smnp/runtime/evaluators/imports.py

@@ -1,4 +1,3 @@
-from smnp.ast.node.none import NoneNode
 from smnp.program.interpreter import Interpreter
 from smnp.runtime.evaluator import Evaluator
 
@@ -7,13 +6,6 @@ class ImportEvaluator(Evaluator):
 
     @classmethod
     def evaluator(cls, node, environment):
-        if type(node.type) == NoneNode:
-            cls._evaluateCodeImport(node, environment)
-        else:
-            raise RuntimeError("Importing types is not implemented yet")
-
-    @classmethod
-    def _evaluateCodeImport(cls, node, environment):
         source = node.source
-        newEnvironment = Interpreter.interpretFile(source.value)
+        newEnvironment = Interpreter.interpretFile(source.value, baseEnvironment=environment)
         environment.extend(newEnvironment)

smnp/runtime/evaluators/loop.py

@@ -0,0 +1,104 @@
+from smnp.ast.node.none import NoneNode
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator, evaluate
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class LoopEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        iterator = expressionEvaluator(doAssert=True)(node.left, environment).value
+        parameters = [ identifier.value for identifier in node.parameters ] if type(node.parameters) != NoneNode() else []
+
+        try:
+            environment.scopes.append({})
+
+            output = {
+                Type.INTEGER: cls.numberEvaluator,
+                Type.BOOL: cls.boolEvaluator,
+                Type.LIST: cls.listEvaluator,
+                Type.MAP: cls.mapEvaluator
+            }[iterator.type](node, environment, iterator, parameters)
+
+            environment.scopes.pop(-1)
+        except KeyError:
+            raise RuntimeException(f"The {iterator.type.name.lower()} type cannot stand as an iterator for loop statement", node.left.pos)
+
+        return Type.list(output)
+
+    @classmethod
+    def numberEvaluator(cls, node, environment, evaluatedIterator, parameters):
+        output = []
+
+
+        if len(parameters) > 1:
+            raise RuntimeException(f"Loop with numeric iterator can handle only one parameter", node.parameters.pos)
+
+        for i in range(evaluatedIterator.value):
+            if len(parameters) > 0:
+                environment.scopes[-1][parameters[0]] = Type.integer(i)
+
+            output.append(evaluate(node.right, environment).value)
+
+
+
+        return output
+
+    @classmethod
+    def boolEvaluator(cls, node, environment, evaluatedIterator, parameters):
+        output = []
+
+        if len(parameters) > 0:
+            raise RuntimeException(f"Loop with logic iterator can't' handle any parameters", node.parameters.pos)
+
+        condition = evaluatedIterator
+        while condition.value:
+            output.append(evaluate(node.right, environment).value)
+            condition = expressionEvaluator(doAssert=True)(node.left, environment).value
+
+        return output
+
+    @classmethod
+    def listEvaluator(cls, node, environment, evaluatedIterator, parameters):
+        output = []
+
+        if len(parameters) > 2:
+            raise RuntimeException(f"Loop with list iterator can handle only two parameters", node.parameters.pos)
+
+        for i, value in enumerate(evaluatedIterator.value):
+            if len(parameters) == 1:
+                environment.scopes[-1][parameters[0]] = value
+            if len(parameters) == 2:
+                environment.scopes[-1][parameters[0]] = Type.integer(i)
+                environment.scopes[-1][parameters[1]] = value
+
+            output.append(evaluate(node.right, environment).value)
+
+        return output
+
+
+    @classmethod
+    def mapEvaluator(cls, node, environment, evaluatedIterator, parameters):
+        output = []
+
+        if len(parameters) > 3:
+            raise RuntimeException(f"Loop with map iterator can handle only three parameters", node.parameters.pos)
+
+        i = 0
+        for key, value in evaluatedIterator.value.items():
+            if len(parameters) == 1:
+                environment.scopes[-1][parameters[0]] = value
+            if len(parameters) == 2:
+                environment.scopes[-1][parameters[0]] = key
+                environment.scopes[-1][parameters[1]] = value
+            if len(parameters) == 3:
+                environment.scopes[-1][parameters[0]] = Type.integer(i)
+                environment.scopes[-1][parameters[1]] = key
+                environment.scopes[-1][parameters[2]] = value
+                i += 1
+
+            output.append(evaluate(node.right, environment).value)
+
+        return output

smnp/runtime/evaluators/minus.py

@@ -0,0 +1,31 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator, evaluate
+from smnp.type.model import Type
+
+
+class MinusEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        value = evaluate(node.value, environment).value
+        try:
+            return {
+                Type.INTEGER: cls.evaluateForInteger,
+                Type.STRING: cls.evaluateForString,
+                Type.LIST: cls.evaluateForList
+            }[value.type](value.value)
+        except KeyError:
+            raise RuntimeException(f"Type {value.type.name.lower()} does not support '{node.operator.value}' operator", node.pos)
+
+    @classmethod
+    def evaluateForInteger(cls, value):
+
+        return Type.integer(-value)
+
+    @classmethod
+    def evaluateForString(cls, value):
+        return Type.string(value[::-1])
+
+    @classmethod
+    def evaluateForList(cls, value):
+        return Type.list(value[::-1])

smnp/runtime/evaluators/negation.py

@@ -0,0 +1,16 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class NotEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        value = expressionEvaluator(doAssert=True)(node.value, environment).value
+
+        if value.type != Type.BOOL:
+            raise RuntimeException(f"Operator '{node.operator.value}' is supported only by {Type.BOOL.name.lower()} type", node.value.pos)
+
+        return Type.bool(not value.value)

smnp/runtime/evaluators/power.py

@@ -0,0 +1,20 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class PowerEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        left = expressionEvaluator(doAssert=True)(node.left, environment).value
+        right = expressionEvaluator(doAssert=True)(node.right, environment).value
+
+        if left.type != Type.INTEGER:
+            raise RuntimeException( f"Operator '{node.operator.value}' is supported only by {Type.INTEGER.name.lower()} type", node.left.pos)
+
+        if right.type != Type.INTEGER:
+            raise RuntimeException( f"Operator '{node.operator.value}' is supported only by {Type.INTEGER.name.lower()} type", node.right.pos)
+
+        return Type.integer(int(left.value ** right.value))

smnp/runtime/evaluators/product.py

@@ -0,0 +1,31 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class ProductEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        left = expressionEvaluator(doAssert=True)(node.left, environment).value
+        right = expressionEvaluator(doAssert=True)(node.right, environment).value
+
+        if left.type != Type.INTEGER:
+            raise RuntimeException(
+                f"Operator '{node.operator.value}' is supported only by {Type.INTEGER.name.lower()} type", node.left.pos)
+
+        if right.type != Type.INTEGER:
+            raise RuntimeException(
+                f"Operator '{node.operator.value}' is supported only by {Type.INTEGER.name.lower()} type", node.right.pos)
+
+        if node.operator.value == "*":
+            return Type.integer(int(left.value * right.value))
+
+        if node.operator.value == "/":
+            if right.value == 0:
+                raise RuntimeException("Attempt to divide by 0", node.right.pos)
+            return Type.integer(int(left.value / right.value))
+
+        raise RuntimeError("This line should never be reached")
+

smnp/runtime/evaluators/relation.py

@@ -0,0 +1,46 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class RelationEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        left = expressionEvaluator(doAssert=True)(node.left, environment).value
+        right = expressionEvaluator(doAssert=True)(node.right, environment).value
+
+        if node.operator.value == "==":
+            return cls.equalOperatorEvaluator(left, node.operator, right)
+
+        if node.operator.value == "!=":
+            return cls.notEqualOperatorEvaluator(left, node.operator, right)
+
+        return cls.otherRelationOperatorsEvaluator(left, node.operator, right)
+
+    @classmethod
+    def equalOperatorEvaluator(cls, left, operator, right):
+        return Type.bool(left.value == right.value)
+
+    @classmethod
+    def notEqualOperatorEvaluator(cls, left, operator, right):
+        return Type.bool(left.value != right.value)
+
+    @classmethod
+    def otherRelationOperatorsEvaluator(cls, left, operator, right):
+        if left.type == right.type == Type.INTEGER:
+            if operator.value == ">":
+                return Type.bool(left.value > right.value)
+
+            if operator.value == ">=":
+                return Type.bool(left.value >= right.value)
+
+            if operator.value == "<":
+                return Type.bool(left.value < right.value)
+
+            if operator.value == "<=":
+                return Type.bool(left.value < right.value)
+
+        raise RuntimeException(f"Operator {operator.value} is not supported by {left.type.name.lower()} and {right.type.name.lower()} types", operator.pos)
+

smnp/runtime/evaluators/sum.py

@@ -0,0 +1,66 @@
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.type.model import Type
+
+
+class SumEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        left = expressionEvaluator(doAssert=True)(node.left, environment).value
+        right = expressionEvaluator(doAssert=True)(node.right, environment).value
+
+        if left.type == right.type == Type.INTEGER:
+            return cls.integerEvaluator(left, node.operator, right)
+
+        if left.type == right.type == Type.STRING:
+            return cls.stringEvaluator(left, node.operator, right)
+
+        if left.type == right.type == Type.LIST:
+            return cls.listEvaluator(left, node.operator, right)
+
+        if left.type == right.type == Type.MAP:
+            return cls.mapEvaluator(left, node.operator, right)
+
+        raise RuntimeException(f"Operator {node.operator.value} is not supported by {left.type.name.lower()} and {right.type.name.lower()} types", node.operator.pos)
+
+    @classmethod
+    def integerEvaluator(cls, left, operator, right):
+        if operator.value == "+":
+            return Type.integer(left.value + right.value)
+
+        if operator.value == "-":
+            return Type.integer(left.value - right.value)
+
+        raise RuntimeError("This line should never be reached")
+
+    @classmethod
+    def stringEvaluator(cls, left, operator, right):
+        if operator.value == "+":
+            return Type.string(left.value + right.value)
+
+        if operator.value == "-":
+            raise RuntimeException(f"Operator {operator.value} is not supported by string types", operator.pos)
+
+        raise RuntimeError("This line should never be reached")
+
+    @classmethod
+    def listEvaluator(cls, left, operator, right):
+        if operator.value == "+":
+            return Type.list(left.value + right.value)
+
+        if operator.value == "-":
+            raise RuntimeException(f"Operator {operator.value} is not supported by list types", operator.pos)
+
+        raise RuntimeError("This line should never be reached")
+
+    @classmethod
+    def mapEvaluator(cls, left, operator, right):
+        if operator.value == "+":
+            return Type.map({**left.value, **right.value})
+
+        if operator.value == "-":
+            raise RuntimeException(f"Operator {operator.value} is not supported by map types", operator.pos)
+
+        raise RuntimeError("This line should never be reached")

smnp/runtime/evaluators/unit.py

@@ -0,0 +1,34 @@
+from smnp.ast.node.identifier import Identifier, FunctionCall
+from smnp.error.runtime import RuntimeException
+from smnp.runtime.evaluator import Evaluator
+from smnp.runtime.evaluators.expression import expressionEvaluator
+from smnp.runtime.evaluators.iterable import abstractIterableEvaluator
+from smnp.runtime.tools.error import updatePos
+
+
+class UnitEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        return
+
+
+class AccessEvaluator(Evaluator):
+
+    @classmethod
+    def evaluator(cls, node, environment):
+        left = expressionEvaluator(doAssert=True)(node.left, environment).value  # TODO check if it isn't necessary to verify 'result' attr of EvaluatioNResult
+        right = node.right
+
+        if type(right) == Identifier:
+            try:
+                return left.properties[right.value]
+            except KeyError:
+                raise RuntimeException(f"Unknown property '{right.value}' of type '{left.type.name.lower()}'", right.pos)
+
+        if type(right) == FunctionCall:
+            try:
+                arguments = abstractIterableEvaluator(expressionEvaluator(doAssert=True))(right.arguments, environment)
+                return environment.invokeMethod(left, right.name.value, arguments)
+            except RuntimeException as e:
+                raise updatePos(e, right)

smnp/runtime/tools/signature.py

@@ -1,5 +1,6 @@
+from smnp.ast.node import type as ast
 from smnp.ast.node.none import NoneNode
-from smnp.ast.node.type import TypeNode, TypeSpecifier
+from smnp.ast.node.type import TypesList
 from smnp.error.runtime import RuntimeException
 from smnp.function.signature import varargSignature, signature
 from smnp.runtime.tools.error import updatePos
@@ -16,9 +17,9 @@ def argumentsNodeToMethodSignature(node):
         argumentsCount = len(node.children)
         for i, child in enumerate(node.children):
             matchers = {
-                TypeNode: (lambda c: c.type, typeMatcher),
+                ast.Type: (lambda c: c.type, typeMatcher),
                 NoneNode: (lambda c: c.type, lambda c: allTypes()),
-                TypeSpecifier: (lambda c: c, multipleTypeMatcher)
+                TypesList: (lambda c: c, multipleTypeMatcher)
             }
             evaluatedMatcher = matchers[type(child.type)][1](matchers[type(child.type)][0](child))
             if child.vararg:
@@ -49,10 +50,10 @@ def multipleTypeMatcher(typeNode):
 
 def typeMatcher(typeNode):
     if type(typeNode.specifiers) == NoneNode:
-        return ofType(typeNode.type)
+        return ofType(typeNode.type.value)
-    elif typeNode.type == Type.LIST and len(typeNode.specifiers) == 1:
+    elif typeNode.type.value == Type.LIST and len(typeNode.specifiers) == 1:
         return listSpecifier(typeNode.specifiers[0])
-    elif typeNode.type == Type.MAP and len(typeNode.specifiers) == 2:
+    elif typeNode.type.value == Type.MAP and len(typeNode.specifiers) == 2:
         return mapSpecifier(typeNode.specifiers[0], typeNode.specifiers[1])
 
     raise RuntimeException("Unknown type", typeNode.pos)  # Todo: Improve pointing position

smnp/token/tokenizer.py

@@ -8,7 +8,7 @@ from smnp.token.tokenizers.note import noteTokenizer
 from smnp.token.tokenizers.relation import relationOperatorTokenizer
 from smnp.token.tokenizers.string import stringTokenizer
 from smnp.token.tokenizers.whitespace import whitespacesTokenizer
-from smnp.token.tools import defaultTokenizer, separated, regexPatternTokenizer
+from smnp.token.tools import defaultTokenizer, separated, regexPatternTokenizer, mapValue
 from smnp.token.type import TokenType
 
 tokenizers = (
@@ -39,7 +39,7 @@ tokenizers = (
     defaultTokenizer(TokenType.DOT),
 
     # Types
-    separated(regexPatternTokenizer(TokenType.INTEGER, r'\d')),
+    mapValue(separated(regexPatternTokenizer(TokenType.INTEGER, r'\d')), int),
     stringTokenizer,
     noteTokenizer,
     boolTokenizer,
@@ -51,6 +51,7 @@ tokenizers = (
     separated(defaultTokenizer(TokenType.EXTEND)),
     separated(defaultTokenizer(TokenType.IMPORT)),
     separated(defaultTokenizer(TokenType.FROM)),
+    separated(defaultTokenizer(TokenType.WITH)),
     separated(defaultTokenizer(TokenType.ELSE)),
     separated(defaultTokenizer(TokenType.AND)),
     separated(defaultTokenizer(TokenType.NOT)),

smnp/token/tokenizers/keyword.py

@@ -3,7 +3,7 @@ from smnp.token.type import TokenType
 from smnp.type.model import Type
 
 
-typeTokenizer = separated(keywordsTokenizer(TokenType.TYPE, *[type.name.lower() for type in Type]))
+typeTokenizer = separated(keywordsTokenizer(TokenType.TYPE, *[type.name.lower() for type in Type], mapKeyword=lambda value: Type[value.upper()]))
 
 
 

smnp/token/tokenizers/note.py

@@ -14,7 +14,7 @@ def noteTokenizer(input, current, line):
     rawValue = ''
     if input[current] == '@':
         rawValue += input[current+consumedChars]
-        consumedChars += 1
+        consumedChars += 1  # TODO: Check if next item does even exist
         if input[current+consumedChars] in ('C', 'c', 'D', 'd', 'E', 'e', 'F', 'f', 'G', 'g', 'A', 'a', 'H', 'h', 'B', 'b'):
             rawValue += input[current + consumedChars]
             notePitch = input[current+consumedChars]

smnp/token/tokenizers/relation.py

@@ -3,4 +3,4 @@ from smnp.token.type import TokenType
 
 
 def relationOperatorTokenizer(input, current, line):
-    return keywordsTokenizer(TokenType.RELATION, "==", "!=", ">=", "<=", ">", "<")(input, current, line)
+    return keywordsTokenizer(TokenType.RELATION, "==", "!=", ">=", "<=")(input, current, line)

smnp/token/tokenizers/string.py

@@ -13,5 +13,5 @@ def stringTokenizer(input, current, line):
             char = input[current + consumedChars]
             value += char
             consumedChars += 1
-        return (consumedChars, Token(TokenType.STRING, value[1:len(value)-1], (line, current)))
+        return (consumedChars, Token(TokenType.STRING, value[1:len(value)-1], (line, current), value))
     return (0, None)

smnp/token/tools.py

@@ -16,10 +16,10 @@ def regexPatternTokenizer(type, pattern):
     return tokenizer
 
 
-def keywordsTokenizer(type, *keywords):
+def keywordsTokenizer(type, *keywords, mapKeyword=lambda x: x):
     def tokenizer(input, current, line):
         for keyword in keywords:
-            result = keywordTokenizer(type, keyword)(input, current, line)
+            result = keywordTokenizer(type, keyword, mapKeyword)(input, current, line)
             if result[0] > 0:
                 return result
         return (0, None)
@@ -27,10 +27,10 @@ def keywordsTokenizer(type, *keywords):
     return tokenizer
 
 
-def keywordTokenizer(type, keyword):
+def keywordTokenizer(type, keyword, mapKeyword=lambda x: x):
     def tokenizer(input, current, line):
         if len(input) >= current+len(keyword) and input[current:current+len(keyword)] == keyword:
-            return (len(keyword), Token(type, keyword, (line, current)))
+            return (len(keyword), Token(type, mapKeyword(keyword), (line, current)))
         return (0, None)
     return tokenizer
 
@@ -50,3 +50,14 @@ def separated(tokenizer, end=r"\W"):
         return (0, None)
 
     return separated
+
+
+def mapValue(tokenizer, mapper):
+    def tokenize(input, current, line):
+        consumedChars, token = tokenizer(input, current, line)
+        if consumedChars > 0:
+            return (consumedChars, Token(token.type, mapper(token.value), token.pos))
+
+        return (0, None)
+
+    return tokenize

smnp/token/type.py

@@ -2,7 +2,7 @@ from enum import Enum
 
 
 class TokenType(Enum):
-    RELATION = 'relation'
+    RELATION = '==, !=, >=, <='
     DOUBLE_ASTERISK = '**'
     OPEN_CURLY = '{'
     CLOSE_CURLY = '}'
@@ -36,6 +36,7 @@ class TokenType(Enum):
     EXTEND = 'extend'
     IMPORT = 'import'
     FROM = 'from'
+    WITH = 'with'
     ELSE = 'else'
     IF = 'if'
     AS = 'as'

smnp/type/model.py

@@ -73,6 +73,7 @@ class Type(Enum):
     def void():
         return Value(Type.VOID, None)
 
+
 def _failStringify(t):
     raise RuntimeException(f"Not able to interpret {t.name}'", None)