diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/AbstractIterableParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/AbstractIterableParser.kt
index b607c06..2738860 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/AbstractIterableParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/AbstractIterableParser.kt
@@ -7,35 +7,35 @@ import io.smnp.dsl.token.model.entity.TokenPosition
 import io.smnp.dsl.token.model.enumeration.TokenType
 
 abstract class AbstractIterableParser(
-    private val beginTokenType: TokenType,
-    private val itemParser: Parser,
-    private val endTokenType: TokenType,
-    private val createNode: (List<Node>, TokenPosition) -> Node
+   private val beginTokenType: TokenType,
+   private val itemParser: Parser,
+   private val endTokenType: TokenType,
+   private val createNode: (List<Node>, TokenPosition) -> Node
 ) : Parser() {
-    override fun tryToParse(input: TokenList): ParserOutput {
-        val emptyIterableParser = allOf(
-            terminal(beginTokenType),
-            terminal(endTokenType)
-        ) { createNode(listOf(), it[0].position) }
+   override fun tryToParse(input: TokenList): ParserOutput {
+      val emptyIterableParser = allOf(
+         terminal(beginTokenType),
+         terminal(endTokenType)
+      ) { (beginToken) -> createNode(listOf(), beginToken.position) }
 
-        val nonEmptyIterableParser = allOf(
-            terminal(beginTokenType),
-            allOf(
-                itemParser,
-                optional(repeat(allOf(
-                    terminal(TokenType.COMMA),
-                    itemParser
-                ) { it[1] }) { list, position -> object : Node(list, position) {} }
-                )) { list ->
-                object : Node(listOf(list[0]) + list[1].children, TokenPosition.NONE) {}
-            },
-            terminal(endTokenType)
-        ) { createNode(it[1].children.toList(), it[0].position) }
+      val nonEmptyIterableParser = allOf(
+         terminal(beginTokenType),
+         allOf(
+            itemParser,
+            optional(repeat(allOf(
+               terminal(TokenType.COMMA),
+               itemParser
+            ) { (_, item) -> item }) { list, position -> object : Node(list, position) {} }
+            )) { (firstItem, otherAggregatedItems) ->
+            object : Node(listOf(firstItem) + otherAggregatedItems.children, TokenPosition.NONE) {}
+         },
+         terminal(endTokenType)
+      ) { (beginToken, aggregatedItems) -> createNode(aggregatedItems.children.toList(), beginToken.position) }
 
-        return oneOf(
-            emptyIterableParser,
-            nonEmptyIterableParser
-        ).parse(input)
-    }
+      return oneOf(
+         emptyIterableParser,
+         nonEmptyIterableParser
+      ).parse(input)
+   }
 
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/AssignmentOperatorParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/AssignmentOperatorParser.kt
index 3ad8407..86a37c7 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/AssignmentOperatorParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/AssignmentOperatorParser.kt
@@ -6,13 +6,11 @@ import io.smnp.dsl.token.model.entity.TokenList
 import io.smnp.dsl.token.model.enumeration.TokenType
 
 class AssignmentOperatorParser : Parser() {
-    override fun tryToParse(input: TokenList): ParserOutput {
-        return allOf(
-            SimpleIdentifierParser(),
-            terminal(TokenType.ASSIGN),
-            assert(ExpressionParser(), "expression")
-        ) {
-            AssignmentOperatorNode(it[0], it[1], it[2])
-        }.parse(input)
-    }
+   override fun tryToParse(input: TokenList): ParserOutput {
+      return allOf(
+         SimpleIdentifierParser(),
+         terminal(TokenType.ASSIGN),
+         assert(ExpressionParser(), "expression")
+      ) { (target, assignToken, value) -> AssignmentOperatorNode(target, assignToken, value) }.parse(input)
+   }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/AtomParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/AtomParser.kt
index 32be059..bdc83b0 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/AtomParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/AtomParser.kt
@@ -10,9 +10,7 @@ class AtomParser : Parser() {
             terminal(TokenType.OPEN_PAREN),
             ExpressionParser(),
             terminal(TokenType.CLOSE_PAREN)
-        ) {
-            it[1]
-        }
+        ) { (_, expression) -> expression }
 
         val literalParser = oneOf(
             parenthesesParser,
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/ExtendParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/ExtendParser.kt
index 82a0201..8fc533b 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/ExtendParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/ExtendParser.kt
@@ -16,8 +16,8 @@ class ExtendParser : Parser() {
             assert(SimpleIdentifierParser(), "identifier"),
             terminal(TokenType.WITH),
             assert(mapNode(FunctionDefinitionParser()) { BlockNode(Node.NONE, listOf(it), Node.NONE) }, "method definition")
-        ) {
-            ExtendNode(it[1], it[3], it[5], it[0].position)
+        ) { (extendToken, targetType, identifier, method) ->
+ExtendNode(targetType, identifier, method, extendToken.position)
         }
 
         val complexExtendParser = allOf(
@@ -28,8 +28,8 @@ class ExtendParser : Parser() {
             assert(loop(terminal(TokenType.OPEN_CURLY), assert(FunctionDefinitionParser(), "method definition or }"), terminal(TokenType.CLOSE_CURLY)) {
                 begin, methods, end -> BlockNode(begin, methods, end)
             }, "block with methods' definitions or 'with' keyword with single method definition")
-        ) {
-            ExtendNode(it[1], it[3], it[4], it[0].position)
+        ) { (extendToken, targetType, identifier, methods) ->
+            ExtendNode(targetType, identifier, methods, extendToken.position)
         }
 
         return oneOf(
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/FactorParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/FactorParser.kt
index 88765b2..c51b1ed 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/FactorParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/FactorParser.kt
@@ -7,25 +7,21 @@ import io.smnp.dsl.token.model.entity.TokenList
 import io.smnp.dsl.token.model.enumeration.TokenType
 
 class FactorParser : Parser() {
-    override fun tryToParse(input: TokenList): ParserOutput {
-        val factorParser = leftAssociativeOperator(
-            UnitParser(),
-            listOf(TokenType.DOUBLE_ASTERISK),
-            assert(UnitParser(), "expression")
-        ) { lhs, operator, rhs ->
-            PowerOperatorNode(lhs, operator, rhs)
-        }
+   override fun tryToParse(input: TokenList): ParserOutput {
+      val factorParser = leftAssociativeOperator(
+         UnitParser(),
+         listOf(TokenType.DOUBLE_ASTERISK),
+         assert(UnitParser(), "expression")
+      ) { lhs, operator, rhs -> PowerOperatorNode(lhs, operator, rhs) }
 
-        val notOperatorParser = allOf(
-            terminal(TokenType.NOT),
-            assert(factorParser, "expression")
-        ) {
-            NotOperatorNode(it[0], it[1])
-        }
+      val notOperatorParser = allOf(
+         terminal(TokenType.NOT),
+         assert(factorParser, "expression")
+      ) { (notToken, expression) -> NotOperatorNode(notToken, expression) }
 
-        return oneOf(
-            notOperatorParser,
-            factorParser
-        ).parse(input)
-    }
+      return oneOf(
+         notOperatorParser,
+         factorParser
+      ).parse(input)
+   }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionCallParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionCallParser.kt
index 50f0714..610c31c 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionCallParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionCallParser.kt
@@ -5,12 +5,10 @@ import io.smnp.dsl.ast.model.node.FunctionCallNode
 import io.smnp.dsl.token.model.entity.TokenList
 
 class FunctionCallParser : Parser() {
-    override fun tryToParse(input: TokenList): ParserOutput {
-        return allOf(
-            SimpleIdentifierParser(),
-            FunctionCallArgumentsParser()
-        ) {
-            FunctionCallNode(it[0], it[1])
-        }.parse(input)
-    }
+   override fun tryToParse(input: TokenList): ParserOutput {
+      return allOf(
+         SimpleIdentifierParser(),
+         FunctionCallArgumentsParser()
+      ) { (identifier, arguments) -> FunctionCallNode(identifier, arguments) }.parse(input)
+   }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionDefinitionParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionDefinitionParser.kt
index c566e8a..1f8b325 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionDefinitionParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/FunctionDefinitionParser.kt
@@ -12,8 +12,8 @@ class FunctionDefinitionParser : Parser() {
             assert(SimpleIdentifierParser(), "function/method name"),
             assert(FunctionDefinitionArgumentsParser(), "function/method arguments list"),
             assert(BlockParser(), "function/method body")
-        ) {
-            FunctionDefinitionNode(it[1], it[2], it[3], it[0].position)
+        ) { (functionToken, identifier, arguments, body) ->
+            FunctionDefinitionNode(identifier, arguments, body, functionToken.position)
         }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/LoopParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/LoopParser.kt
index e78bc51..b7585f1 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/LoopParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/LoopParser.kt
@@ -14,12 +14,12 @@ class LoopParser : Parser() {
                 mapNode(SimpleIdentifierParser()) { LoopParametersNode(listOf(it), it.position) },
                 LoopParametersParser()
             ), "loop parameters")
-        ) { it[1] }
+        ) { (_, parameters) -> parameters }
 
         val loopFilterParser = allOf(
             terminal(TokenType.PERCENT),
             assert(SubexpressionParser(), "filter as bool expression")
-        ) { it[1] }
+        ) { (_, filter) -> filter }
 
         return allOf(
             SubexpressionParser(),
@@ -27,8 +27,8 @@ class LoopParser : Parser() {
             terminal(TokenType.CARET),
             assert(StatementParser(), "statement"),
             optional(loopFilterParser)
-        ) {
-            LoopNode(it[0], it[1], it[2], it[3], it[4])
+        ) { (iterator, parameters, caretToken, statement, filter) ->
+            LoopNode(iterator, parameters, caretToken, statement, filter)
         }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/MapEntryParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/MapEntryParser.kt
index b8e0507..cff0422 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/MapEntryParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/MapEntryParser.kt
@@ -16,8 +16,6 @@ class MapEntryParser : Parser() {
             keyParser,
             terminal(TokenType.ARROW),
             assert(SubexpressionParser(), "expression")
-        ) {
-            MapEntryNode(it[0], it[1], it[2])
-        }.parse(input)
+        ) { (key, arrowToken, value) -> MapEntryNode(key, arrowToken, value) }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt
index cd907ad..5e4274e 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/OptionalFunctionDefinitionArgumentParser.kt
@@ -14,11 +14,11 @@ class OptionalFunctionDefinitionArgumentParser : Parser() {
             optional(allOf(
                 terminal(TokenType.COLON),
                 assert(TypeParser(), "type name")
-            ) { it[1] }) { UnionTypeNode(emptyList(), TokenPosition.NONE) },
+            ) { (_, type) -> type }) { UnionTypeNode(emptyList(), TokenPosition.NONE) },
             terminal(TokenType.ASSIGN),
             assert(ExpressionParser(), "expression")
-        ) {
-            OptionalFunctionDefinitionArgumentNode(it[0], it[1], it[3])
+        ) { (identifier, type, defaultValue) ->
+            OptionalFunctionDefinitionArgumentNode(identifier, type, defaultValue)
         }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt
index f58b37c..567bb74 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/RegularFunctionDefinitionArgumentParser.kt
@@ -15,7 +15,7 @@ class RegularFunctionDefinitionArgumentParser : Parser() {
             optional(allOf(
                 terminal(TokenType.COLON),
                 assert(TypeParser(), "type name")
-            ) { it[1] }) { UnionTypeNode(emptyList(), TokenPosition.NONE) }
+            ) { (_, type) -> type }) { UnionTypeNode(emptyList(), TokenPosition.NONE) }
         ) { (vararg, identifier, type) ->
             RegularFunctionDefinitionArgumentNode(identifier, type, vararg)
         }.parse(input)
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/SingleTypeParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/SingleTypeParser.kt
index ed411cf..79d9cfb 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/SingleTypeParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/SingleTypeParser.kt
@@ -10,8 +10,6 @@ class SingleTypeParser : Parser() {
         return allOf(
             SimpleIdentifierParser(),
             optional(repeat(TypeSpecifierParser()) { list, tokenPosition -> TypeSpecifiersNode(list, tokenPosition) })
-        ) {
-            SingleTypeNode(it[0], it[1])
-        }.parse(input)
+        ) { (identifier, specifiers) -> SingleTypeNode(identifier, specifiers) }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/StatementParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/StatementParser.kt
index 60fefd2..390bdf0 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/StatementParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/StatementParser.kt
@@ -15,8 +15,6 @@ class StatementParser : Parser() {
                 ThrowParser()
             ),
             optional(terminal(TokenType.SEMICOLON))
-        ) {
-            it[0]
-        }.parse(input)
+        ) { (statement) -> statement }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/ThrowParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/ThrowParser.kt
index 01c116a..efaa515 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/ThrowParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/ThrowParser.kt
@@ -10,8 +10,6 @@ class ThrowParser : Parser() {
         return allOf(
             terminal(TokenType.THROW),
             optional(SubexpressionParser())
-        ) {
-            ThrowNode(it[1])
-        }.parse(input)
+        ) { (_, value) -> ThrowNode(value) }.parse(input)
     }
 }
\ No newline at end of file
diff --git a/app/src/main/kotlin/io/smnp/dsl/ast/parser/UnitParser.kt b/app/src/main/kotlin/io/smnp/dsl/ast/parser/UnitParser.kt
index 427519c..7960fd6 100644
--- a/app/src/main/kotlin/io/smnp/dsl/ast/parser/UnitParser.kt
+++ b/app/src/main/kotlin/io/smnp/dsl/ast/parser/UnitParser.kt
@@ -7,21 +7,21 @@ import io.smnp.dsl.token.model.entity.TokenList
 import io.smnp.dsl.token.model.enumeration.TokenType
 
 class UnitParser : Parser() {
-    override fun tryToParse(input: TokenList): ParserOutput {
-        val minusOperatorParser = allOf(
-            terminal(TokenType.MINUS),
-            assert(AtomParser(), "expression")
-        ) {
-            MinusOperatorNode(it[0], it[1])
-        }
+   override fun tryToParse(input: TokenList): ParserOutput {
+      val minusOperatorParser = allOf(
+         terminal(TokenType.MINUS),
+         assert(AtomParser(), "expression")
+      ) { (minusToken, expression) -> MinusOperatorNode(minusToken, expression) }
 
-        val atom2 = oneOf(
-            minusOperatorParser,
-            AtomParser()
-        )
+      val atom2 = oneOf(
+         minusOperatorParser,
+         AtomParser()
+      )
 
-        return leftAssociativeOperator(atom2, listOf(TokenType.DOT), assert(atom2, "property or method call")) { lhs, operator, rhs ->
-            AccessOperatorNode(lhs, operator, rhs)
-        }.parse(input)
-    }
+      return leftAssociativeOperator(
+         atom2,
+         listOf(TokenType.DOT),
+         assert(atom2, "property or method call")
+      ) { lhs, operator, rhs -> AccessOperatorNode(lhs, operator, rhs) }.parse(input)
+   }
 }
\ No newline at end of file