diff --git a/Parser/MParser.cs b/Parser/MParser.cs
index 31adc4b..1b84aa9 100644
--- a/Parser/MParser.cs
+++ b/Parser/MParser.cs
@@ -73,6 +73,7 @@ namespace Parser
         private List<Token> Tokens { get; }
         private int _index;
         private Token CurrentToken => Tokens[_index];
+        private Token PeekToken(int n) => Tokens[_index + n];
         private SyntaxFactory Factory { get; }
         
         public MParser(List<Token> tokens)
@@ -144,8 +145,17 @@ namespace Parser
         {
             if (CurrentToken.Kind == TokenKind.Identifier)
             {
-                var result = EatToken();
-                return Factory.FunctionOutputDescription(new List<SyntaxNode> { Factory.Token(result) });
+                if (PeekToken(1).Kind == TokenKind.Assignment)
+                {
+                    var identifier = EatToken();
+                    var assignmentSign = EatToken(TokenKind.Assignment);                    
+                    return Factory.FunctionOutputDescription(
+                        new List<SyntaxNode> { Factory.Token(identifier) },
+                        Factory.Token(assignmentSign)
+                        );
+                }
+
+                return null;
             } else if (CurrentToken.Kind == TokenKind.OpeningSquareBracket)
             {
                 var leftBracket = EatToken();
@@ -154,7 +164,8 @@ namespace Parser
                 var nodes = new List<SyntaxNode> {Factory.Token(leftBracket)};
                 nodes.AddRange(outputs);
                 nodes.Add(Factory.Token(rightBracket));
-                return Factory.FunctionOutputDescription(nodes);
+                var assignmentSign = EatToken(TokenKind.Assignment);                    
+                return Factory.FunctionOutputDescription(nodes, Factory.Token(assignmentSign));
             }
             throw new ParsingException($"Unexpected token {CurrentToken.PureToken} during parsing function output descritpion at {CurrentToken.PureToken.Position}.");
         }
@@ -198,7 +209,6 @@ namespace Parser
         {
             var functionKeyword = EatIdentifier("function");
             var outputDescription = ParseFunctionOutputDescription();
-            var assignment = EatToken(TokenKind.Assignment);
             var name = EatToken(TokenKind.Identifier);
             var inputDescription = ParseFunctionInputDescription();
             var body = ParseStatements();
@@ -213,7 +223,6 @@ namespace Parser
             return Factory.FunctionDeclaration(
                 Factory.Token(functionKeyword),
                 outputDescription,
-                Factory.Token(assignment),
                 Factory.Token(name),
                 inputDescription,
                 body,
diff --git a/Parser/SyntaxFactory.cs b/Parser/SyntaxFactory.cs
index a436c14..151bd29 100644
--- a/Parser/SyntaxFactory.cs
+++ b/Parser/SyntaxFactory.cs
@@ -18,24 +18,22 @@ namespace Parser
         }
         
         public FunctionDeclarationNode FunctionDeclaration(
-            TokenNode token,
+            TokenNode functionKeyword,
             FunctionOutputDescriptionNode outputDescription,
-            TokenNode equalitySign,
             TokenNode name,
             FunctionInputDescriptionNode inputDescription,
             StatementListNode body,
             TokenNode end,
             TokenNode semicolonOrComma = null)
         {
-            var children = new List<SyntaxNode>
+            var children = new List<SyntaxNode> {functionKeyword};
+            if (outputDescription != null)
             {
-                token,
-                outputDescription,
-                equalitySign,
-                name,
-                inputDescription,
-                body
-            };
+                children.Add(outputDescription);
+            }
+            children.Add(name);
+            children.Add(inputDescription);
+            children.Add(body);
             if (end != null)
             {
                 children.Add(end);
@@ -46,28 +44,31 @@ namespace Parser
             }
             var result =
                 new FunctionDeclarationNode(
-                children,
-                token,
-                outputDescription,
-                equalitySign,
-                name,
-                inputDescription,
-                body,
-                end,
-                semicolonOrComma);
+                    children,
+                    functionKeyword,
+                    outputDescription,
+                    name,
+                    inputDescription,
+                    body,
+                    end,
+                    semicolonOrComma);
             SetParent(result);
             return result;
         }
 
         public FunctionOutputDescriptionNode FunctionOutputDescription(
-            List<SyntaxNode> nodes)
+            List<SyntaxNode> nodes,
+            TokenNode equalitySign)
         {
+            var children = new List<SyntaxNode>(nodes);
+            nodes.Add(equalitySign);
             var result = new FunctionOutputDescriptionNode(
                 nodes,
                 nodes
                     .Where(node => node is TokenNode && ((TokenNode) node).Token.Kind == TokenKind.Identifier)
                     .Select(node => node as TokenNode)
-                    .ToList()
+                    .ToList(),
+                equalitySign
                 );
             SetParent(result);
             return result;
diff --git a/Parser/SyntaxNode.cs b/Parser/SyntaxNode.cs
index 19f1610..628c960 100644
--- a/Parser/SyntaxNode.cs
+++ b/Parser/SyntaxNode.cs
@@ -41,10 +41,15 @@ namespace Parser
     public class FunctionOutputDescriptionNode : SyntaxNode
     {
         public List<TokenNode> Outputs { get; }
+        public TokenNode EqualitySign { get;  }
         
-        public FunctionOutputDescriptionNode(List<SyntaxNode> children, List<TokenNode> outputs) : base(children)
+        public FunctionOutputDescriptionNode(
+            List<SyntaxNode> children,
+            List<TokenNode> outputs,
+            TokenNode equalitySign) : base(children)
         {
             Outputs = outputs;
+            EqualitySign = equalitySign;
         }
     }
 
@@ -69,7 +74,6 @@ namespace Parser
     {
         public TokenNode Token { get; }
         public FunctionOutputDescriptionNode OutputDescription { get; }
-        public TokenNode EqualitySign { get;  }
         public TokenNode Name { get; }
         public FunctionInputDescriptionNode InputDescription { get; }
         public StatementListNode Body { get; }
@@ -79,7 +83,6 @@ namespace Parser
             List<SyntaxNode> children,
             TokenNode token,
             FunctionOutputDescriptionNode outputDescription,
-            TokenNode equalitySign,
             TokenNode name,
             FunctionInputDescriptionNode inputDescription,
             StatementListNode body,
@@ -89,7 +92,6 @@ namespace Parser
         {
             Token = token;
             OutputDescription = outputDescription;
-            EqualitySign = equalitySign;
             Name = name;
             InputDescription = inputDescription;
             Body = body;