diff --git a/smnp/ast/node/chain.py b/smnp/ast/node/chain.py
index 600bde6..3e2cc2b 100644
--- a/smnp/ast/node/chain.py
+++ b/smnp/ast/node/chain.py
@@ -1,3 +1,4 @@
+from smnp.ast.node.list import ListParser
 from smnp.ast.node.operator import BinaryOperator
 from smnp.ast.node.valuable import Valuable
 from smnp.ast.parser import Parsers
@@ -15,7 +16,7 @@ def ChainParser():
     from smnp.ast.node.atom import AtomParser
 
     itemParser = Parsers.oneOf(
-        #ListParser,
+        ListParser,
         #MapParser,
         AtomParser,
         name="chainItem"
diff --git a/smnp/ast/node/iterable.py b/smnp/ast/node/iterable.py
index 7f39ef9..e8892e1 100644
--- a/smnp/ast/node/iterable.py
+++ b/smnp/ast/node/iterable.py
@@ -1,7 +1,7 @@
 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 Parsers
+from smnp.ast.parser import Parsers, DecoratorParser
 from smnp.token.type import TokenType
 
 
@@ -31,14 +31,14 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
     class AbstractIterableTail(AbstractIterable):
         pass
 
-    def abstractIterableParser(input):
+    def abstractIterableParser():
         return Parsers.oneOf(
-            emptyIterable,
-            openIterable,
+            emptyIterable(),
+            openIterable(),
             name=name
-        )(input)
+        )
 
-    def emptyIterable(input):
+    def emptyIterable():
         def createNode(open, close):
             node = AbstractIterable(open.pos)
             node.value = open
@@ -50,9 +50,9 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
             Parsers.terminal(closeTokenType),
             createNode=createNode,
             name=name+"Empty"
-        )(input)
+        )
 
-    def openIterable(input):
+    def openIterable():
         def createNode(open, item, tail):
             node = AbstractIterable(open.pos)
             node.value = item
@@ -62,19 +62,19 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
         return Parsers.allOf(
             Parsers.terminal(openTokenType),
             itemParser,
-            abstractIterableTailParser,
+            abstractIterableTailParser(),
             createNode=createNode,
             name=name+"Open"
-        )(input)
+        )
 
-    def abstractIterableTailParser(input):
+    def abstractIterableTailParser():
         return Parsers.oneOf(
-            closeIterable,
-            nextItem,
+            closeIterable(),
+            nextItem(),
             name=name+"Tail"
-        )(input)
+        )
 
-    def nextItem(input):
+    def nextItem():
         def createNode(comma, item, tail):
             node = AbstractIterableTail(item.pos)
             node.value = item
@@ -84,22 +84,21 @@ def abstractIterableParser(iterableNodeType, openTokenType, closeTokenType, item
         return Parsers.allOf(
             Parsers.terminal(TokenType.COMMA, doAssert=True),
             itemParser,
-            abstractIterableTailParser,
+            abstractIterableTailParser(),
             name=name+"NextItem",
             createNode=createNode
-        )(input)
+        )
 
-    def closeIterable(input):
-        return Parsers.terminal(closeTokenType)(input)
+    def closeIterable():
+        return Parsers.terminal(closeTokenType)
 
 
-    return toFlatDesiredNode(iterableNodeType, abstractIterableParser)
+    return abstractIterableParser()
+    #return toFlatDesiredNode(iterableNodeType, abstractIterableParser())
 
 
 def toFlatDesiredNode(iterableNodeType, parser):
-    def parse(input):
-        result = parser(input)
-
+    def wrapper(result):
         if result.result:
             value = flattenList(result.node)
             node = iterableNodeType(result.node.pos)
@@ -110,7 +109,7 @@ def toFlatDesiredNode(iterableNodeType, parser):
 
         return ParseResult.FAIL()
 
-    #return Parser(parse, "flat", [parser])
+    return DecoratorParser(wrapper, parser)
 
 
 def flattenList(node, output=None):
diff --git a/smnp/ast/node/list.py b/smnp/ast/node/list.py
index 2e25649..ee26c0d 100644
--- a/smnp/ast/node/list.py
+++ b/smnp/ast/node/list.py
@@ -1,3 +1,4 @@
+from smnp.ast.node.atom import AtomParser
 from smnp.ast.node.iterable import abstractIterableParser
 from smnp.ast.node.model import Node
 from smnp.token.type import TokenType
@@ -7,7 +8,6 @@ class List(Node):
     pass
 
 
-def ListParser(input):
-    from smnp.ast.node.expression import MaxPrecedenceExpressionParser
-    return abstractIterableParser(List, TokenType.OPEN_SQUARE, TokenType.CLOSE_SQUARE,
-                                    MaxPrecedenceExpressionParser)(input)
+def ListParser():
+    return abstractIterableParser(List, TokenType.OPEN_SQUARE, TokenType.CLOSE_SQUARE, AtomParser(), name="list")
+                                    #MaxPrecedenceExpressionParser)(input)
diff --git a/smnp/ast/parser.py b/smnp/ast/parser.py
index f25a283..943ce01 100644
--- a/smnp/ast/parser.py
+++ b/smnp/ast/parser.py
@@ -81,6 +81,18 @@ class Parsers:
         return LoopParser(startParser, itemParser, endParser, createNode, name)
 
 
+class DecoratorParser(Parser):
+    def __init__(self, wrapper, parser):
+        super().__init__(parser.name)
+        self.wrapper = wrapper
+        self.parser = parser
+        self._grammarRules = parser._grammarRules
+
+    def _parse(self, input):
+        result = self.parser.parse(input)
+        return self.wrapper(result)
+
+
 class TerminalParser(Parser):
 
     def __init__(self, expectedType, createNode=lambda val, pos: IgnoredNode(pos), doAssert=False):
diff --git a/smnp/main.py b/smnp/main.py
index 831e78a..2330d96 100644
--- a/smnp/main.py
+++ b/smnp/main.py
@@ -1,4 +1,6 @@
 from smnp.ast.node.atom import AtomParser
+from smnp.ast.node.chain import ChainParser
+from smnp.ast.node.list import ListParser
 from smnp.ast.node.model import Node
 from smnp.error.base import SmnpException
 from smnp.token.tokenizer import tokenize
@@ -15,9 +17,9 @@ def main():
                 super().__init__((-1, -1))
                 self.children = children
 
-        tokens = tokenize(['"fsfsvd" "Fsefs"'])
-        parser = AtomParser()
-        print(parser.grammar())
+        tokens = tokenize(['[1, 2]'])
+        parser = ListParser()
+        #print(parser.grammar())
         res = parser.parse(tokens)
 
         print()