Using the groupParsee

samples/test.brc

@@ -1,10 +1,19 @@
+@extern putchar fun: character u32 -> u32
+
 User blob
     num1 s32
     num2 u8
 ;
 
+rawAdd raw<"=r,r,r">: num1 u32, num2 u32 -> u32
+    add $1, $2
+    mov $0, $1
+;
+
 main fun -> u32
-    user User <- 0
+    n1 u32 <- 5
+    n2 u32 <- 4
+    n3 u32 <- rawAdd(n1, n2)
 
     ret 0
 ;

src/Logger.cpp

@@ -326,7 +326,10 @@ string Logger::toString(shared_ptr<StatementBlock> statement) {
 }
 
 string Logger::toString(shared_ptr<StatementAssignment> statement) {
-    return format("{} <- {}", statement->getName(), toString(statement->getExpression()));
+    if (statement->getIndexExpression() != nullptr)
+        return format("{}[{}] <- {}", statement->getName(), toString(statement->getIndexExpression()), toString(statement->getExpression()));
+    else
+        return format("{} <- {}", statement->getName(), toString(statement->getExpression()));
 }
 
 string Logger::toString(shared_ptr<StatementReturn> statement) {

src/Parser/Parsee/Parsee.cpp

@@ -2,6 +2,16 @@
 
 #include "ParseeGroup.h"
 
+Parsee Parsee::groupParsee(ParseeGroup group, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
+    Parsee parsee;
+    parsee.kind = ParseeKind::GROUP;
+    parsee.group = group;
+    parsee.isRequired = isRequired;
+    parsee.shouldReturn = shouldReturn;
+    parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
+    return parsee;
+}
+
 Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
     Parsee parsee;
     parsee.kind = ParseeKind::REPEATED_GROUP;
@@ -12,33 +22,40 @@ Parsee Parsee::repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, b
     return parsee;
 }
 
-Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn) {
+Parsee Parsee::tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
     Parsee  parsee;
     parsee.kind = ParseeKind::TOKEN;
     parsee.tokenKind = tokenKind;
     parsee.isRequired = isRequired;
     parsee.shouldReturn = shouldReturn;
+    parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
     return parsee;
 }
 
-Parsee Parsee::valueTypeParsee(bool isRequired) {
+Parsee Parsee::valueTypeParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
     Parsee parsee;
     parsee.kind = ParseeKind::VALUE_TYPE;
     parsee.isRequired = isRequired;
-    parsee.shouldReturn = true;
+    parsee.shouldReturn = shouldReturn;
+    parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
     return parsee;
 }
 
-Parsee Parsee::expressionParsee(bool isRequired) {
+Parsee Parsee::expressionParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch) {
     Parsee parsee;
     parsee.kind = ParseeKind::EXPRESSION;
     parsee.isRequired = isRequired;
-    parsee.shouldReturn = true;
+    parsee.shouldReturn = shouldReturn;
+    parsee.shouldFailOnNoMatch = shouldFailOnNoMatch;
     return parsee;
 }
 
 Parsee::Parsee() { }
 
+optional<ParseeGroup> Parsee::getGroup() {
+    return group;
+}
+
 optional<ParseeGroup> Parsee::getRepeatedGroup() {
     return repeatedGroup;
 }

src/Parser/Parsee/Parsee.h

@@ -7,11 +7,11 @@
 #include "ParseeGroup.h"
 
 enum class TokenKind;
-//class ParseeGroup;
 
 using namespace std;
 
 enum class ParseeKind {
+    GROUP,
     REPEATED_GROUP,
     TOKEN,
     VALUE_TYPE,
@@ -21,6 +21,7 @@ enum class ParseeKind {
 class Parsee {
 private:
     ParseeKind kind;
+    optional<ParseeGroup> group;
     optional<ParseeGroup> repeatedGroup;
     TokenKind tokenKind;
     bool isRequired;
@@ -29,12 +30,14 @@ private:
     Parsee();
 
 public:
+    static Parsee groupParsee(ParseeGroup group, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
     static Parsee repeatedGroupParsee(ParseeGroup repeatedGroup, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
-    static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn);
+    static Parsee tokenParsee(TokenKind tokenKind, bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
-    static Parsee valueTypeParsee(bool isRequired); 
+    static Parsee valueTypeParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch); 
-    static Parsee expressionParsee(bool isRequired);
+    static Parsee expressionParsee(bool isRequired, bool shouldReturn, bool shouldFailOnNoMatch);
 
     ParseeKind getKind();
+    optional<ParseeGroup> getGroup();
     optional<ParseeGroup> getRepeatedGroup();
     TokenKind getTokenKind();
     bool getIsRequired();

src/Parser/Parsee/ParseeGroup.cpp

@@ -2,19 +2,9 @@
 
 #include "Parsee.h"
 
-ParseeGroup::ParseeGroup(vector<Parsee> parsees)://, optional<ParseeGroup> repeatedGroup):
+ParseeGroup::ParseeGroup(vector<Parsee> parsees):
-parsees(parsees) {
+parsees(parsees) { }
-    /*if (repeatedGroup) {
-        this->repeatedGroup = *repeatedGroup;
-    } else {
-        this->repeatedGroup = {};
-    }*/
- }
 
 vector<Parsee> ParseeGroup::getParsees() {
     return parsees;
 }
-
-/*optional<reference_wrapper<ParseeGroup>> ParseeGroup::getRepeatedGroup() {
-    return repeatedGroup;
-}*/

src/Parser/Parsee/ParseeGroup.h

@@ -2,7 +2,6 @@
 #define PARSEE_GROUP_H
 
 #include <vector>
-#include <optional>
 
 class Parsee;
 
@@ -11,12 +10,10 @@ using namespace std;
 class ParseeGroup {
 private:
     vector<Parsee> parsees;
-    //optional<reference_wrapper<ParseeGroup>> repeatedGroup;
 
 public:
-    ParseeGroup(vector<Parsee> parsees);//, optional<ParseeGroup> repeatedGroup);
+    ParseeGroup(vector<Parsee> parsees);
     vector<Parsee> getParsees();
-    //optional<reference_wrapper<ParseeGroup>> getRepeatedGroup();
 };
 
 #endif

src/Parser/Parser.cpp

@@ -118,89 +118,70 @@ shared_ptr<Statement> Parser::nextInBlockStatement() {
 }
 
 shared_ptr<Statement> Parser::matchStatementMetaExternFunction() {
-    ParseeResultsGroup resultsGroup;
-
     string identifier;
     vector<pair<string, shared_ptr<ValueType>>> arguments;
     shared_ptr<ValueType> returnType = ValueType::NONE;
 
-    // identifier
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
-    resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::M_EXTERN, true, false),
+                // identifier
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::M_EXTERN, true, false, false),
-                Parsee::tokenParsee(TokenKind::FUNCTION, true, false)
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-            }/*,
+                Parsee::tokenParsee(TokenKind::FUNCTION, true, false, false),
-            {}*/
+                // arguments
-        )
+                Parsee::groupParsee(
-    );
+                    ParseeGroup(
-
+                        {
-    switch (resultsGroup.getKind()) {
+                            // first argument
-        case ParseeResultsGroupKind::SUCCESS:
+                            Parsee::tokenParsee(TokenKind::COLON, true, false, false),
-            identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
-            break;
+                            Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
-        case ParseeResultsGroupKind::NO_MATCH:
+                            Parsee::valueTypeParsee(true, true, true),
-        case ParseeResultsGroupKind::FAILURE:
+                            // additional arguments
-            return nullptr;
+                            Parsee::repeatedGroupParsee(
-    }
+                                ParseeGroup(
-
+                                    {
-    // arguments
+                                        Parsee::tokenParsee(TokenKind::COMMA, true, false, false),
-    resultsGroup = parseeResultsGroupForParseeGroup(
+                                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
-        ParseeGroup(
+                                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
-            {
+                                        Parsee::valueTypeParsee(true, true, true)
-                Parsee::tokenParsee(TokenKind::COLON, true, false),
+                                    }
-                Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                                ), false, true, false
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                            )
-                Parsee::valueTypeParsee(true)
+                        }
-            }/*,
+                    ), false, true, false
-            ParseeGroup(
+                ),
-                {
+                // return type
-                    Parsee::tokenParsee(TokenKind::COMMA, true, false),
+                Parsee::groupParsee(
-                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
+                    ParseeGroup(
-                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                        {
-                    Parsee::valueTypeParsee(true)
+                            Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false),
-                },
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
-                {}
+                            Parsee::valueTypeParsee(true, true, true)
-            )*/
+                        }
-        )
+                    ), false, true, false
-    );
+                )
-    switch (resultsGroup.getKind()) {
-        case ParseeResultsGroupKind::SUCCESS:
-            for (int i=0; i<resultsGroup.getResults().size(); i+=2) {
-                pair<string, shared_ptr<ValueType>> arg;
-                arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
-                arg.second = resultsGroup.getResults().at(i+1).getValueType();
-                arguments.push_back(arg);
             }
-            break;
-        case ParseeResultsGroupKind::NO_MATCH:
-            break;
-        case ParseeResultsGroupKind::FAILURE:
-            return nullptr;
-    }
-
-    // return type 
-    resultsGroup = parseeResultsGroupForParseeGroup(
-        ParseeGroup(
-            {
-                Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
-                Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                Parsee::valueTypeParsee(true)
-            }/*,
-            {}*/
         )
     );
 
-    switch (resultsGroup.getKind()) {
+    if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
-        case ParseeResultsGroupKind::SUCCESS:
+        return nullptr;
-            returnType = resultsGroup.getResults().at(0).getValueType();
+
-            break;
+    int i = 0;
-        case ParseeResultsGroupKind::NO_MATCH:
+    // identifier
-            break;
+    identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
-        case ParseeResultsGroupKind::FAILURE:
+    // arguments
-            return nullptr;
+    while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) {
+            pair<string, shared_ptr<ValueType>> argument;
+            argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme();
+            argument.second = resultsGroup.getResults().at(i++).getValueType();
+            arguments.push_back(argument);
     }
+    // return type
+    if (i < resultsGroup.getResults().size())
+        returnType = resultsGroup.getResults().at(i).getValueType();
 
     return make_shared<StatementMetaExternFunction>(identifier, arguments, returnType);
 }
@@ -209,12 +190,11 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
     ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-                Parsee::valueTypeParsee(true),
+                Parsee::valueTypeParsee(true, true, false),
-                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false),
+                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, true),
-                Parsee::expressionParsee(true)
+                Parsee::expressionParsee(true, true, true)
-            }/*,
+            }
-            {}*/
         )
     );
 
@@ -229,106 +209,79 @@ shared_ptr<Statement> Parser::matchStatementVariable() {
 }
 
 shared_ptr<Statement> Parser::matchStatementFunction() {
-    bool hasError = false;
+    string identifier;
-    ParseeResultsGroup resultsGroup;
-
-    string name;
     vector<pair<string, shared_ptr<ValueType>>> arguments;
     shared_ptr<ValueType> returnType = ValueType::NONE;
     shared_ptr<Statement> statementBlock;
 
-    // identifier
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
-    resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                // identifier
-                Parsee::tokenParsee(TokenKind::FUNCTION, true, false)
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-            }/*,
+                Parsee::tokenParsee(TokenKind::FUNCTION, true, false, false),
-            {}*/
+                // arguments
+                Parsee::groupParsee(
+                    ParseeGroup(
+                        {
+                            // first argument
+                            Parsee::tokenParsee(TokenKind::COLON, true, false, false),
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
+                            Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
+                            Parsee::valueTypeParsee(true, true, true),
+                            // additional arguments
+                            Parsee::repeatedGroupParsee(
+                                ParseeGroup(
+                                    {
+                                        Parsee::tokenParsee(TokenKind::COMMA, true, false, false),
+                                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
+                                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
+                                        Parsee::valueTypeParsee(true, true, true)
+                                    }
+                                ), false, true, false
+                            )
+                        }
+                    ), false, true, false
+                ),
+                // return type
+                Parsee::groupParsee(
+                    ParseeGroup(
+                        {
+                            Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false),
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
+                            Parsee::valueTypeParsee(true, true, true)
+                        }
+                    ), false, true, false
+                ),
+                // new line
+                Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true)
+            }
         )
     );
 
     switch (resultsGroup.getKind()) {
-        case ParseeResultsGroupKind::SUCCESS:
+        case ParseeResultsGroupKind::SUCCESS: {
-            name = resultsGroup.getResults().at(0).getToken()->getLexme();
+            int i = 0;
+            // identifier
+            identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
+            // arguments
+            while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) {
+                    pair<string, shared_ptr<ValueType>> argument;
+                    argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme();
+                    argument.second = resultsGroup.getResults().at(i++).getValueType();
+                    arguments.push_back(argument);
+            }
+            // return type
+            if (i < resultsGroup.getResults().size())
+                returnType = resultsGroup.getResults().at(i).getValueType();
+        }
             break;
         case ParseeResultsGroupKind::NO_MATCH:
             return nullptr;
         case ParseeResultsGroupKind::FAILURE:
-            hasError = true;
             break;
     }
 
-    // arguments
-    if (!hasError) {
-        resultsGroup = parseeResultsGroupForParseeGroup(
-            ParseeGroup(
-                {
-                    Parsee::tokenParsee(TokenKind::COLON, true, false),
-                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                    Parsee::valueTypeParsee(true)
-                }/*,
-                {}
-                ParseeGroup(
-                    {
-                        Parsee::tokenParsee(TokenKind::COMMA, true, false),
-                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                        Parsee::valueTypeParsee(true)
-                    },
-                    {}
-                )*/
-            )
-        );
-        switch (resultsGroup.getKind()) {
-            case ParseeResultsGroupKind::SUCCESS:
-                for (int i=0; i<resultsGroup.getResults().size(); i+=2) {
-                    pair<string, shared_ptr<ValueType>> arg;
-                    arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
-                    arg.second = resultsGroup.getResults().at(i+1).getValueType();
-                    arguments.push_back(arg);
-                }
-                break;
-            case ParseeResultsGroupKind::NO_MATCH:
-                break;
-            case ParseeResultsGroupKind::FAILURE:
-                hasError = true;
-                break;
-        }
-    }
-
-    // return type 
-    if (!hasError) {
-        resultsGroup = parseeResultsGroupForParseeGroup(
-            ParseeGroup(
-                {
-                    Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
-                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    Parsee::valueTypeParsee(true)
-                }/*,
-                {}*/
-            )
-        );
-
-        switch (resultsGroup.getKind()) {
-            case ParseeResultsGroupKind::SUCCESS:
-                returnType = resultsGroup.getResults().at(0).getValueType();
-                break;
-            case ParseeResultsGroupKind::NO_MATCH:
-                break;
-            case ParseeResultsGroupKind::FAILURE:
-                hasError = true;
-                break;
-        }
-    }
-
-    // consume new line
-    if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
-        markError(TokenKind::NEW_LINE, {});
-        return nullptr;
-    }
-
     // block
     statementBlock = matchStatementBlock({TokenKind::SEMICOLON, TokenKind::END});
     if (statementBlock == nullptr)
@@ -340,140 +293,99 @@ shared_ptr<Statement> Parser::matchStatementFunction() {
         return nullptr;
     }
 
-    return make_shared<StatementFunction>(name, arguments, returnType, dynamic_pointer_cast<StatementBlock>(statementBlock));
+    return make_shared<StatementFunction>(identifier, arguments, returnType, dynamic_pointer_cast<StatementBlock>(statementBlock));
 }
 
 shared_ptr<Statement> Parser::matchStatementRawFunction() {
-    bool hasError = false;
+    string identifier;
-    ParseeResultsGroup resultsGroup;
-
-    string name;
     string constraints;
     vector<pair<string, shared_ptr<ValueType>>> arguments;
     shared_ptr<ValueType> returnType = ValueType::NONE;
     string rawSource;
 
-    // identifier
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
-    resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                // identifier
-                Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false)
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-            }/*,
+                Parsee::tokenParsee(TokenKind::RAW_FUNCTION, true, false, false),
-            {}*/
+                // constraints
+                Parsee::groupParsee(
+                    ParseeGroup(
+                        {
+                            Parsee::tokenParsee(TokenKind::LESS, true, false, true),
+                            Parsee::tokenParsee(TokenKind::STRING, true, true, true),
+                            Parsee::tokenParsee(TokenKind::GREATER, true, false, true)
+                        }
+                    ), true, true, true
+                ),
+                // arguments
+                Parsee::groupParsee(
+                    ParseeGroup(
+                        {
+                            // first argument
+                            Parsee::tokenParsee(TokenKind::COLON, true, false, false),
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
+                            Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
+                            Parsee::valueTypeParsee(true, true, true),
+                            // additional arguments
+                            Parsee::repeatedGroupParsee(
+                                ParseeGroup(
+                                    {
+                                        Parsee::tokenParsee(TokenKind::COMMA, true, false, false),
+                                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
+                                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, true),
+                                        Parsee::valueTypeParsee(true, true, true)
+                                    }
+                                ), false, true, false
+                            )
+                        }
+                    ), false, true, false
+                ),
+                // return type
+                Parsee::groupParsee(
+                    ParseeGroup(
+                        {
+                            Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false, false),
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, false, false, false),
+                            Parsee::valueTypeParsee(true, true, true)
+                        }
+                    ), false, true, false
+                ),
+                // new line
+                Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true)
+            }
         )
     );
 
     switch (resultsGroup.getKind()) {
-        case ParseeResultsGroupKind::SUCCESS:
+        case ParseeResultsGroupKind::SUCCESS: {
-            name = resultsGroup.getResults().at(0).getToken()->getLexme();
+            int i = 0;
+            // identifier
+            identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
+            // constraints
+            constraints = resultsGroup.getResults().at(i++).getToken()->getLexme();
+            // remove enclosing quotes
+                if (constraints.length() >= 2)
+                    constraints = constraints.substr(1, constraints.length() - 2);
+            // arguments
+            while (i < resultsGroup.getResults().size()-1 && resultsGroup.getResults().at(i).getKind() == ParseeResultKind::TOKEN) {
+                    pair<string, shared_ptr<ValueType>> argument;
+                    argument.first = resultsGroup.getResults().at(i++).getToken()->getLexme();
+                    argument.second = resultsGroup.getResults().at(i++).getValueType();
+                    arguments.push_back(argument);
+            }
+            // return type
+            if (i < resultsGroup.getResults().size())
+                returnType = resultsGroup.getResults().at(i).getValueType();
+        }
             break;
         case ParseeResultsGroupKind::NO_MATCH:
             return nullptr;
-            break;
         case ParseeResultsGroupKind::FAILURE:
-            hasError = true;
             break;
     }
 
-    // constraints
-    if (!hasError) {
-        resultsGroup = parseeResultsGroupForParseeGroup(
-            ParseeGroup(
-                {
-                    Parsee::tokenParsee(TokenKind::LESS, true, false),
-                    Parsee::tokenParsee(TokenKind::STRING, true, true),
-                    Parsee::tokenParsee(TokenKind::GREATER, true, false)
-                }/*,
-                {}*/
-            )
-        );
-
-        switch (resultsGroup.getKind()) {
-            case ParseeResultsGroupKind::SUCCESS:
-                constraints = resultsGroup.getResults().at(0).getToken()->getLexme();
-                // remove enclosing quotes
-                if (constraints.length() >= 2)
-                    constraints = constraints.substr(1, constraints.length() - 2);
-                break;
-            case ParseeResultsGroupKind::NO_MATCH:
-                return nullptr;
-                break;
-            case ParseeResultsGroupKind::FAILURE:
-                hasError = true;
-                break;
-        }
-    }
-
-    // arguments
-    if (!hasError) {
-        resultsGroup = parseeResultsGroupForParseeGroup(
-            ParseeGroup(
-                {
-                    Parsee::tokenParsee(TokenKind::COLON, true, false),
-                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                    Parsee::valueTypeParsee(true)
-                }/*,
-                ParseeGroup(
-                    {
-                        Parsee::tokenParsee(TokenKind::COMMA, true, false),
-                        Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                        Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
-                        Parsee::valueTypeParsee(true)
-                    },
-                    {}
-                )*/
-            )
-        );
-        switch (resultsGroup.getKind()) {
-            case ParseeResultsGroupKind::SUCCESS:
-                for (int i=0; i<resultsGroup.getResults().size(); i+=2) {
-                    pair<string, shared_ptr<ValueType>> arg;
-                    arg.first = resultsGroup.getResults().at(i).getToken()->getLexme();
-                    arg.second = resultsGroup.getResults().at(i+1).getValueType();
-                    arguments.push_back(arg);
-                }
-                break;
-            case ParseeResultsGroupKind::NO_MATCH:
-                break;
-            case ParseeResultsGroupKind::FAILURE:
-                hasError = true;
-                break;
-        }
-    }
-
-    // return type 
-    if (!hasError) {
-        resultsGroup = parseeResultsGroupForParseeGroup(
-            ParseeGroup(
-                {
-                    Parsee::tokenParsee(TokenKind::RIGHT_ARROW, true, false),
-                    Parsee::tokenParsee(TokenKind::NEW_LINE, false, false),
-                    Parsee::valueTypeParsee(true)
-                }/*,
-                {}*/
-            )
-        );
-
-        switch (resultsGroup.getKind()) {
-            case ParseeResultsGroupKind::SUCCESS:
-                returnType = resultsGroup.getResults().at(0).getValueType();
-                break;
-            case ParseeResultsGroupKind::NO_MATCH:
-                break;
-            case ParseeResultsGroupKind::FAILURE:
-                hasError = true;
-                break;
-        }
-    }
-
-    // consume new line
-    if (!tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true)) {
-        markError(TokenKind::NEW_LINE, {});
-        return nullptr;
-    }
-
     // source
     while (tryMatchingTokenKinds({TokenKind::RAW_SOURCE_LINE}, true, false)) {
         if (!rawSource.empty())
@@ -484,12 +396,13 @@ shared_ptr<Statement> Parser::matchStatementRawFunction() {
         tryMatchingTokenKinds({TokenKind::NEW_LINE}, true, true);
     }
 
+    // closing semicolon
     if(!tryMatchingTokenKinds({TokenKind::SEMICOLON}, false, true)) {
         markError(TokenKind::SEMICOLON, {});
         return nullptr;
     }
 
-    return make_shared<StatementRawFunction>(name, constraints, arguments, returnType, rawSource);
+    return make_shared<StatementRawFunction>(identifier, constraints, arguments, returnType, rawSource);
 }
 
 shared_ptr<Statement> Parser::matchStatementBlob() {
@@ -501,22 +414,19 @@ shared_ptr<Statement> Parser::matchStatementBlob() {
     resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-                Parsee::tokenParsee(TokenKind::BLOB, true, false),
+                Parsee::tokenParsee(TokenKind::BLOB, true, false, false),
-                Parsee::tokenParsee(TokenKind::NEW_LINE, true, false),
+                Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true),
                 Parsee::repeatedGroupParsee(
                     ParseeGroup(
                         {
-                            Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                            Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-                            Parsee::valueTypeParsee(true),
+                            Parsee::valueTypeParsee(true, true, true),
-                            Parsee::tokenParsee(TokenKind::NEW_LINE, true, false)
+                            Parsee::tokenParsee(TokenKind::NEW_LINE, true, false, true)
                         }
-                    ),
+                    ), false, true, false
-                    false,
-                    true,
-                    false
                 ),
-                Parsee::tokenParsee(TokenKind::SEMICOLON, true, false)
+                Parsee::tokenParsee(TokenKind::SEMICOLON, true, false, true)
             }
         )
     );
@@ -560,71 +470,43 @@ shared_ptr<Statement> Parser::matchStatementBlock(vector<TokenKind> terminalToke
 }
 
 shared_ptr<Statement> Parser::matchStatementAssignment() {
-    int startIndex = currentIndex;
-    ParseeResultsGroup resultsGroup;
-
     string identifier;
     shared_ptr<Expression> indexExpression;
     shared_ptr<Expression> expression;
 
-    // identifier
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
-    resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true),
+                // identifier
-            }/*,
+                Parsee::tokenParsee(TokenKind::IDENTIFIER, true, true, false),
-            {}*/
+                // index expression
+                Parsee::groupParsee(
+                    ParseeGroup(
+                        {
+                            Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false, false),
+                            Parsee::expressionParsee(true, true, true),
+                            Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false, true)
+                        }
+                    ), false, true, false
+                ),
+                // expression
+                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false, false),
+                Parsee::expressionParsee(true, true, true)
+            }
         )
     );
 
     if (resultsGroup.getKind() != ParseeResultsGroupKind::SUCCESS)
         return nullptr;
 
-    identifier = resultsGroup.getResults().at(0).getToken()->getLexme();
+    int i = 0;
-
+    // identifier
+    identifier = resultsGroup.getResults().at(i++).getToken()->getLexme();
     // index expression
-    resultsGroup = parseeResultsGroupForParseeGroup(
+    if (i < resultsGroup.getResults().size()-1)
-        ParseeGroup(
+        indexExpression = resultsGroup.getResults().at(i++).getExpression();
-            {
-                Parsee::tokenParsee(TokenKind::LEFT_SQUARE_BRACKET, true, false),
-                Parsee::expressionParsee(true),
-                Parsee::tokenParsee(TokenKind::RIGHT_SQUARE_BRACKET, true, false),
-            }/*,
-            {}*/
-        )
-    );
-
-    switch (resultsGroup.getKind()) {
-        case ParseeResultsGroupKind::SUCCESS:
-            indexExpression = resultsGroup.getResults().at(0).getExpression();
-            break;
-        case ParseeResultsGroupKind::NO_MATCH:
-            break;
-        case ParseeResultsGroupKind::FAILURE:
-            return nullptr;
-    }
-
     // expression
-    resultsGroup = parseeResultsGroupForParseeGroup(
+        expression = resultsGroup.getResults().at(i).getExpression();
-        ParseeGroup(
-            {
-                Parsee::tokenParsee(TokenKind::LEFT_ARROW, true, false),
-                Parsee::expressionParsee(true)
-            }/*,
-            {}*/
-        )
-    );
-
-    switch (resultsGroup.getKind()) {
-        case ParseeResultsGroupKind::SUCCESS:
-            expression = resultsGroup.getResults().at(0).getExpression();
-            break;
-        case ParseeResultsGroupKind::NO_MATCH:
-            currentIndex = startIndex;
-            return nullptr;
-        case ParseeResultsGroupKind::FAILURE:
-            return nullptr;
-    }
 
     return make_shared<StatementAssignment>(identifier, indexExpression, expression);
 }
@@ -633,10 +515,9 @@ shared_ptr<Statement> Parser::matchStatementReturn() {
     ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(
         ParseeGroup(
             {
-                Parsee::tokenParsee(TokenKind::RETURN, true, false),
+                Parsee::tokenParsee(TokenKind::RETURN, true, false, false),
-                Parsee::expressionParsee(false)
+                Parsee::expressionParsee(false, true, false)
-            }/*,
+            }
-            {}*/
         )
     );
 
@@ -1024,11 +905,13 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
     int errorsCount = errors.size();
     int startIndex = currentIndex;
     vector<ParseeResult> parseeResults;
-    bool mustFulfill = false;
 
     for (Parsee &parsee : group.getParsees()) {
         optional<pair<vector<ParseeResult>, int>> subResults;
         switch (parsee.getKind()) {
+            case ParseeKind::GROUP:
+                subResults = groupParseeResults(*parsee.getGroup());
+                break;
             case ParseeKind::REPEATED_GROUP:
                 subResults = repeatedGroupParseeResults(*parsee.getRepeatedGroup());
                 break;
@@ -1047,24 +930,20 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
         if (errors.size() > errorsCount)
             return ParseeResultsGroup::failure();
 
-        // if doesn't match on optional group
+        // if doesn't match a required but non-failing parsee
-        if (!subResults && parsee.getIsRequired() && !mustFulfill) {
+        if (!subResults && parsee.getIsRequired() && !parsee.getShouldFailOnNoMatch()) {
             currentIndex = startIndex;
             return ParseeResultsGroup::noMatch();
         }
 
-        // return matching token?
+        // should return a matching result?
         if (subResults && parsee.getShouldReturn()) {
             for (ParseeResult &subResult : (*subResults).first)
                 parseeResults.push_back(subResult);
         }
 
-        // decide if we're decoding the expected sequence
-        if (!parsee.getIsRequired() && currentIndex > startIndex)
-            mustFulfill = true;
-
         // invalid sequence detected?
-        if (!subResults && parsee.getIsRequired() && mustFulfill) {
+        if (!subResults && parsee.getShouldFailOnNoMatch()) {
             markError(parsee.getTokenKind(), {});
             return ParseeResultsGroup::failure();
         }
@@ -1077,6 +956,22 @@ ParseeResultsGroup Parser::parseeResultsGroupForParseeGroup(ParseeGroup group) {
     return ParseeResultsGroup::success(parseeResults);
 }
 
+optional<pair<vector<ParseeResult>, int>> Parser::groupParseeResults(ParseeGroup group) {
+    int startIndex = currentIndex;
+    vector<ParseeResult> results;
+    
+    ParseeResultsGroup resultsGroup = parseeResultsGroupForParseeGroup(group);
+    if (resultsGroup.getKind() == ParseeResultsGroupKind::FAILURE)
+        return {};
+
+    for (ParseeResult &result : resultsGroup.getResults())
+        results.push_back(result);
+    
+    int tokensCount = currentIndex - startIndex;
+    currentIndex = startIndex;
+    return pair(results, tokensCount);
+}
+
 optional<pair<vector<ParseeResult>, int>> Parser::repeatedGroupParseeResults(ParseeGroup group) {
     int startIndex = currentIndex;
     vector<ParseeResult> results;

src/Parser/Parser.h

@@ -57,6 +57,7 @@ private:
     shared_ptr<Expression> matchExpressionBlock(vector<TokenKind> terminalTokenKinds);
 
     ParseeResultsGroup parseeResultsGroupForParseeGroup(ParseeGroup group);
+    optional<pair<vector<ParseeResult>, int>> groupParseeResults(ParseeGroup group);
     optional<pair<vector<ParseeResult>, int>> repeatedGroupParseeResults(ParseeGroup group);
     optional<pair<vector<ParseeResult>, int>> tokenParseeResults(int index, TokenKind tokenKind);
     optional<pair<vector<ParseeResult>, int>> valueTypeParseeResults(int index);