diff --git a/src/lib/cli.cpp b/src/lib/cli.cpp
index fd10870..32047f7 100644
--- a/src/lib/cli.cpp
+++ b/src/lib/cli.cpp
@@ -32,10 +32,10 @@ namespace CLI {
         this->present = false;
     }
 
-    UnpositionalArgument::UnpositionalArgument() {
+    Option::Option() {
         this->present = false;
     }
-    UnpositionalArgument::UnpositionalArgument(char shortName, std::string longName, std::string placeholder, std::string description) {
+    Option::Option(char shortName, std::string longName, std::string placeholder, std::string description) {
         this->shortName = shortName;
         this->longName = longName;
         this->description = description;
@@ -43,23 +43,22 @@ namespace CLI {
         this->present = false;
     }
 
-    PositionalArgument::PositionalArgument() {
+    Argument::Argument() {
         this->present = false;
     }
-    PositionalArgument::PositionalArgument(std::string placeholder, std::string description) {
+    Argument::Argument(std::string placeholder, std::string description) {
         this->description = description;
         this->placeholder = placeholder;
         this->present = false;
     }
 
     // using int here bc that's how main() is defined
-    ArgumentsParser::ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<UnpositionalArgument> unpositionalArguments, std::vector<PositionalArgument> positionalArguments) {
+    ArgumentsParser::ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<Option> options, std::vector<Argument> arguments) {
         this->wrongUsage = false;
         this->wrongUsageMessages = std::vector<std::string>();
         this->programName = std::string(argv[0]);
-        this->positionalArguments = positionalArguments;
-        // create lookup tables for all flags and unpositional arguments
-        // by their names
+        this->arguments = arguments;
+        // create lookup tables for all flags and options by their names
         this->flagsByShortName = std::map<char, Flag*>();
         this->flagsByLongName  = std::map<std::string, Flag*>();
         for (Flag flag: flags) {
@@ -68,25 +67,25 @@ namespace CLI {
             this->flagsByShortName[flag.shortName] = flagPointer;
             this->flagsByLongName[flag.longName]   = flagPointer;
         }
-        this->argumentsByShortName = std::map<char, UnpositionalArgument*>();
-        this->argumentsByLongName = std::map<std::string, UnpositionalArgument*>();
-        for (UnpositionalArgument unpositionalArgument: unpositionalArguments) {
-            UnpositionalArgument* argumentPointer = new UnpositionalArgument();
-            *argumentPointer = unpositionalArgument;
-            this->argumentsByShortName[unpositionalArgument.shortName] = argumentPointer;
-            this->argumentsByLongName[unpositionalArgument.longName]   = argumentPointer;
+        this->optionsByShortName = std::map<char, Option*>();
+        this->optionsByLongName = std::map<std::string, Option*>();
+        for (Option option: options) {
+            Option* optionPointer = new Option();
+            *optionPointer = option;
+            this->optionsByShortName[option.shortName] = optionPointer;
+            this->optionsByLongName[option.longName]   = optionPointer;
         }
 
-        UnpositionalArgument* argumentWaitingForValue = nullptr;
-        std::vector<CLI::PositionalArgument>::size_type positionalArgumentCounter = 0;
+        Option* optionWaitingForValue = nullptr;
+        std::vector<CLI::Argument>::size_type argumentCounter = 0;
         for (int i=1; i<argc; i++) {
             std::string argument(argv[i]);
             if (argument[0]=='-') {
                 // do we have unfinished business?
-                if (argumentWaitingForValue!=nullptr) {
+                if (optionWaitingForValue!=nullptr) {
                     this->wrongUsage = true;
-                    this->wrongUsageMessages.push_back(std::string("Argument expects value but has none: ")+argumentWaitingForValue->longName);
-                    argumentWaitingForValue = nullptr;
+                    this->wrongUsageMessages.push_back(std::string("Argument expects value but has none: ")+optionWaitingForValue->longName);
+                    optionWaitingForValue = nullptr;
                 }
                 // long name or short name?
                 if (argument[1]=='-') {
@@ -98,15 +97,15 @@ namespace CLI {
                     auto position = argument.find("=");
                     if (position==std::string::npos) {
                         // no =value
-                        //is argument or flag?
+                        //is option or flag?
                         std::string argumentName = argument.substr(2,argument.length()-2);
                         if (flagsByLongName.contains(argumentName)) {
                             // flag
                             flagsByLongName[argumentName]->present = true;
-                        } else if (argumentsByLongName.contains(argumentName)) {
-                            // unpositional argument
-                            argumentsByLongName[argumentName]->present = true;
-                            argumentWaitingForValue = argumentsByLongName[argumentName];
+                        } else if (optionsByLongName.contains(argumentName)) {
+                            // option
+                            optionsByLongName[argumentName]->present = true;
+                            optionWaitingForValue = optionsByLongName[argumentName];
                             if (i+1 == argc) {
                                 this->wrongUsage = true;
                                 this->wrongUsageMessages.push_back(std::string("Argument expects value but has none: ")+argumentName);
@@ -119,9 +118,9 @@ namespace CLI {
                         // has =value
                         std::string value = argument.substr(position+1, argument.length()-position-1);
                         std::string argumentName = argument.substr(2, position-2);
-                        if (argumentsByLongName.contains(argumentName)) {
-                            argumentsByLongName[argumentName]->present = true;
-                            argumentsByLongName[argumentName]->value = value;
+                        if (optionsByLongName.contains(argumentName)) {
+                            optionsByLongName[argumentName]->present = true;
+                            optionsByLongName[argumentName]->value = value;
                         } else {
                             this->wrongUsage = true;
                             this->wrongUsageMessages.push_back(std::string("Unknown argument (or it's a flag that doesn't take a value): ")+argument);
@@ -134,21 +133,23 @@ namespace CLI {
                     // (std::__cxx11::basic_string<char>::size_type ?)
                     // starting at 1 because 0 is '-'
                     for (int j=1; j<(int) argument.length(); j++) {
-                        //is argument or flag?
+                        // is option or flag?
                         if (flagsByShortName.contains(argument[j])) {
+                            // flag
                             flagsByShortName[argument[j]]->present = true;
-                        } else if (argumentsByShortName.contains(argument[j])) {
-                            argumentsByShortName[argument[j]]->present = true;
+                        } else if (optionsByShortName.contains(argument[j])) {
+                            // option
+                            optionsByShortName[argument[j]]->present = true;
                             //FIXME: see above
                             if (j+1==(int) argument.length()) {
-                                argumentWaitingForValue = argumentsByShortName[argument[j]];
+                                optionWaitingForValue = optionsByShortName[argument[j]];
                                 if (i+1 == argc) {
                                     this->wrongUsage = true;
-                                    this->wrongUsageMessages.push_back(std::string("Argument expects value but has none: ")+this->argumentsByShortName[argument[j]]->longName);
+                                    this->wrongUsageMessages.push_back(std::string("Argument expects value but has none: ")+this->optionsByShortName[argument[j]]->longName);
                                 }
                             } else {
                                 //assume the rest of the argv is a concatenated argument value
-                                argumentsByShortName[argument[j]]->value = argument.substr(j+1, argument.length()-j-1);
+                                optionsByShortName[argument[j]]->value = argument.substr(j+1, argument.length()-j-1);
                                 break;
                             }
                         } else {
@@ -163,37 +164,37 @@ namespace CLI {
                     }
                 }
             } else {
-                // positional argument or value for unpositional arg?
-                if (argumentWaitingForValue==nullptr) {
-                    // positional argument
-                    if (positionalArgumentCounter < this->positionalArguments.size()) {
-                        this->positionalArguments.at(positionalArgumentCounter).present = true;
-                        this->positionalArguments.at(positionalArgumentCounter).value = argument;
+                // argument or value for option?
+                if (optionWaitingForValue==nullptr) {
+                    // argument
+                    if (argumentCounter < this->arguments.size()) {
+                        this->arguments.at(argumentCounter).present = true;
+                        this->arguments.at(argumentCounter).value = argument;
                     } else {
                         this->wrongUsage = true;
-                        this->wrongUsageMessages.push_back(std::string("Too many positional arguments! Unexpected encounter of: ")+argument);
+                        this->wrongUsageMessages.push_back(std::string("Too many arguments! Unexpected encounter of: ")+argument);
                     }
-                    positionalArgumentCounter++;
+                    argumentCounter++;
                 } else {
-                    // value for unpositional argument
-                    argumentWaitingForValue->value = argument;
-                    argumentWaitingForValue = nullptr;
+                    // value for option
+                    optionWaitingForValue->value = argument;
+                    optionWaitingForValue = nullptr;
                 }
             }
         }
-        for (PositionalArgument const& positionalArgument: this->positionalArguments) {
-            if (!positionalArgument.present) {
+        for (Argument const& argument: this->arguments) {
+            if (!argument.present) {
                 this->wrongUsage = true;
-                this->wrongUsageMessages.push_back(std::string("Too few positional arguments! Missing: ")+positionalArgument.placeholder);
+                this->wrongUsageMessages.push_back(std::string("Too few arguments! Missing: ")+argument.placeholder);
             }
         }
     }
 
-    ArgumentsParser::ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<UnpositionalArgument> unpositionalArguments, std::vector<PositionalArgument> positionalArguments, std::string description): ArgumentsParser::ArgumentsParser(argc, argv, flags, unpositionalArguments, positionalArguments) {
+    ArgumentsParser::ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<Option> options, std::vector<Argument> arguments, std::string description): ArgumentsParser::ArgumentsParser(argc, argv, flags, options, arguments) {
         this->description = description;
     }
 
-    ArgumentsParser::ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<UnpositionalArgument> unpositionalArguments, std::vector<PositionalArgument> positionalArguments, std::string description, std::string additionalInfo): ArgumentsParser::ArgumentsParser(argc, argv, flags, unpositionalArguments, positionalArguments) {
+    ArgumentsParser::ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<Option> options, std::vector<Argument> arguments, std::string description, std::string additionalInfo): ArgumentsParser::ArgumentsParser(argc, argv, flags, options, arguments) {
         this->description = description;
         this->additionalInfo = additionalInfo;
     }
@@ -203,8 +204,8 @@ namespace CLI {
         for (auto const& [shortName, flag]: this->flagsByShortName) {
             delete flag;
         }
-        for (auto const& [shortName, unpositionalArgument]: this->argumentsByShortName) {
-            delete unpositionalArgument;
+        for (auto const& [shortName, option]: this->optionsByShortName) {
+            delete option;
         }
     }
 
@@ -228,33 +229,33 @@ namespace CLI {
         else return ErrorOr<bool> (false, ErrorCodes::NOT_PRESENT, false);
     }
 
-    ErrorOr<std::string> ArgumentsParser::getPositionalArgument(std::vector<CLI::PositionalArgument>::size_type position){
-        if (position >= this->positionalArguments.size()) return ErrorOr<std::string>(true, ErrorCodes::OUT_OF_RANGE, std::string(""));
+    ErrorOr<std::string> ArgumentsParser::getArgument(std::vector<CLI::Argument>::size_type position){
+        if (position >= this->arguments.size()) return ErrorOr<std::string>(true, ErrorCodes::OUT_OF_RANGE, std::string(""));
         if (this->wrongUsage) {
-            if (this->positionalArguments.at(position).present) return ErrorOr<std::string>(true, ErrorCodes::WRONG_USAGE, this->positionalArguments.at(position).value);
+            if (this->arguments.at(position).present) return ErrorOr<std::string>(true, ErrorCodes::WRONG_USAGE, this->arguments.at(position).value);
             else return ErrorOr<std::string>(true, ErrorCodes::NOT_PRESENT, std::string(""));
         }
-        return ErrorOr<std::string>(this->positionalArguments.at(position).value);
+        return ErrorOr<std::string>(this->arguments.at(position).value);
     }
 
-    ErrorOr<std::string> ArgumentsParser::getUnpositionalArgument(char shortName) {
-        if (!this->argumentsByShortName.contains(shortName)) return ErrorOr<std::string>(true, ErrorCodes::UNKNOWN_KEY, std::string(""));
+    ErrorOr<std::string> ArgumentsParser::getOption(char shortName) {
+        if (!this->optionsByShortName.contains(shortName)) return ErrorOr<std::string>(true, ErrorCodes::UNKNOWN_KEY, std::string(""));
         if (this->wrongUsage) {
-            if (this->argumentsByShortName[shortName]->present) return ErrorOr<std::string>(true, ErrorCodes::WRONG_USAGE, this->argumentsByShortName[shortName]->value);
+            if (this->optionsByShortName[shortName]->present) return ErrorOr<std::string>(true, ErrorCodes::WRONG_USAGE, this->optionsByShortName[shortName]->value);
             else return ErrorOr<std::string>(true, ErrorCodes::NOT_PRESENT, std::string(""));
         }
-        if (this->argumentsByShortName[shortName]->present) return ErrorOr<std::string>(this->argumentsByShortName[shortName]->value);
+        if (this->optionsByShortName[shortName]->present) return ErrorOr<std::string>(this->optionsByShortName[shortName]->value);
         // argument is not present, but this is not an error -> false, NOT_PRESENT, ""
         else return ErrorOr<std::string>(false, ErrorCodes::NOT_PRESENT, std::string(""));
     }
 
-    ErrorOr<std::string> ArgumentsParser::getUnpositionalArgument(std::string longName) {
-        if (!this->argumentsByLongName.contains(longName)) return ErrorOr<std::string>(true, ErrorCodes::UNKNOWN_KEY, std::string(""));
+    ErrorOr<std::string> ArgumentsParser::getOption(std::string longName) {
+        if (!this->optionsByLongName.contains(longName)) return ErrorOr<std::string>(true, ErrorCodes::UNKNOWN_KEY, std::string(""));
         if (this->wrongUsage) {
-            if (this->argumentsByLongName[longName]->present) return ErrorOr<std::string>(true, ErrorCodes::WRONG_USAGE, this->argumentsByLongName[longName]->value);
+            if (this->optionsByLongName[longName]->present) return ErrorOr<std::string>(true, ErrorCodes::WRONG_USAGE, this->optionsByLongName[longName]->value);
             else return ErrorOr<std::string>(true, ErrorCodes::NOT_PRESENT, std::string(""));
         }
-        if (this->argumentsByLongName[longName]->present) return ErrorOr<std::string>(this->argumentsByLongName[longName]->value);
+        if (this->optionsByLongName[longName]->present) return ErrorOr<std::string>(this->optionsByLongName[longName]->value);
         // argument is not present, but this is not an error -> false, NOT_PRESENT, ""
         else return ErrorOr<std::string>(false, ErrorCodes::NOT_PRESENT, std::string(""));
     }
diff --git a/src/lib/cli.h++ b/src/lib/cli.h++
index c306edc..93f3ee9 100644
--- a/src/lib/cli.h++
+++ b/src/lib/cli.h++
@@ -35,7 +35,7 @@ namespace CLI {
         Flag(char shortName, std::string longName, std::string description);
     };
 
-    struct UnpositionalArgument {
+    struct Option {
         char shortName;
         std::string longName;
         // used for automatic usage generation
@@ -45,11 +45,11 @@ namespace CLI {
         bool present;
         std::string value;
 
-        UnpositionalArgument();
-        UnpositionalArgument(char shortName, std::string longName, std::string placeholder, std::string description);
+        Option();
+        Option(char shortName, std::string longName, std::string placeholder, std::string description);
     };
 
-    struct PositionalArgument {
+    struct Argument {
         // used for automatic usage generation
         std::string description;
         std::string placeholder; // the "HOST" in "ping [-c <COUNT>] <HOST>"
@@ -57,17 +57,17 @@ namespace CLI {
         bool present;
         std::string value;
 
-        PositionalArgument();
-        PositionalArgument(std::string placeholder, std::string description);
+        Argument();
+        Argument(std::string placeholder, std::string description);
     };
 
     class ArgumentsParser {
         private:
             std::map<char, Flag*> flagsByShortName;
             std::map<std::string, Flag*> flagsByLongName;
-            std::map<char, UnpositionalArgument*> argumentsByShortName;
-            std::map<std::string, UnpositionalArgument*> argumentsByLongName;
-            std::vector<PositionalArgument> positionalArguments;
+            std::map<char, Option*> optionsByShortName;
+            std::map<std::string, Option*> optionsByLongName;
+            std::vector<Argument> arguments;
             std::string description;
             std::string additionalInfo;
 
@@ -77,16 +77,16 @@ namespace CLI {
             std::vector<std::string> wrongUsageMessages;
 
             // using int here bc that's how main() is defined
-            ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<UnpositionalArgument> unpositionalArguments, std::vector<PositionalArgument> positionalArguments);
-            ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<UnpositionalArgument> unpositionalArguments, std::vector<PositionalArgument> positionalArguments, std::string description);
-            ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<UnpositionalArgument> unpositionalArguments, std::vector<PositionalArgument> positionalArguments, std::string description, std::string additionalInfo);
+            ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<Option> options, std::vector<Argument> arguments);
+            ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<Option> options, std::vector<Argument> arguments, std::string description);
+            ArgumentsParser(int argc, const char* const argv[], std::vector<Flag> flags, std::vector<Option> options, std::vector<Argument> arguments, std::string description, std::string additionalInfo);
             ~ArgumentsParser();
 
             ErrorOr<bool> getFlag(char shortName);
             ErrorOr<bool> getFlag(std::string longName);
-            ErrorOr<std::string> getPositionalArgument(std::vector<CLI::PositionalArgument>::size_type position);
-            ErrorOr<std::string> getUnpositionalArgument(char shortName);
-            ErrorOr<std::string> getUnpositionalArgument(std::string longName);
+            ErrorOr<std::string> getArgument(std::vector<CLI::Argument>::size_type position);
+            ErrorOr<std::string> getOption(char shortName);
+            ErrorOr<std::string> getOption(std::string longName);
 
             std::string getUsage();
     };
diff --git a/src/test/cli_argument_parser.cpp b/src/test/cli_argument_parser.cpp
index 61406e2..e4cd3fc 100644
--- a/src/test/cli_argument_parser.cpp
+++ b/src/test/cli_argument_parser.cpp
@@ -31,7 +31,7 @@ int main() {
     // with many variations of valid input on a single command line.
     //
     // simulated command line:
-    // test -0 -ab -12345 --long-flag -cconcatenated -d separate-value -efdouble-concatenated "positional argument 0" -gh concatenated-separate-value --long-argument-with-value-included="included value" --long-argument-with-value-separated "separate value" "positional argument 1" "positional argument 2"
+    // test -0 -ab -12345 --long-flag -cconcatenated -d separate-value -efdouble-concatenated "argument 0" -gh concatenated-separate-value --long-argument-with-value-included="included value" --long-argument-with-value-separated "separate value" "argument 1" "argument 2"
 
     std::vector<CLI::Flag> validTestFlags;
     validTestFlags.push_back(CLI::Flag('0', "00000", "a short flag on its own"));
@@ -47,19 +47,19 @@ int main() {
     validTestFlags.push_back(CLI::Flag('g', "ggggg", "short flags concatenated with an argument that has a separate value"));
     validTestFlags.push_back(CLI::Flag('6', "66666", "unused flag"));
 
-    std::vector<CLI::UnpositionalArgument> validTestUnpositionalArguments;
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('c', "ccccc", "VALUE", "short argument concatenated with its value"));
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('d', "ddddd", " VALUE", "short argument with separate value"));
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('f', "fffff", "VALUE", "short argument concatenated with a flag and its value"));
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('h', "hhhhh", " VALUE", "short argument concatenated with a flag with separate value"));
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('x', "long-argument-with-value-included", "VALUE", "long argument with its value included using ="));
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('y', "long-argument-with-value-separated", " VALUE", "long argument with separate value"));
-    validTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('z', "zzzzz", "NOPE", "unused argument"));
+    std::vector<CLI::Option> validTestOptions;
+    validTestOptions.push_back(CLI::Option('c', "ccccc", "VALUE", "short argument concatenated with its value"));
+    validTestOptions.push_back(CLI::Option('d', "ddddd", " VALUE", "short argument with separate value"));
+    validTestOptions.push_back(CLI::Option('f', "fffff", "VALUE", "short argument concatenated with a flag and its value"));
+    validTestOptions.push_back(CLI::Option('h', "hhhhh", " VALUE", "short argument concatenated with a flag with separate value"));
+    validTestOptions.push_back(CLI::Option('x', "long-argument-with-value-included", "VALUE", "long argument with its value included using ="));
+    validTestOptions.push_back(CLI::Option('y', "long-argument-with-value-separated", " VALUE", "long argument with separate value"));
+    validTestOptions.push_back(CLI::Option('z', "zzzzz", "NOPE", "unused argument"));
 
-    std::vector<CLI::PositionalArgument> validTestPositionalArguments;
-    validTestPositionalArguments.push_back(CLI::PositionalArgument("argument0", "positional argument between optional parameters"));
-    validTestPositionalArguments.push_back(CLI::PositionalArgument("argument1", "positional argument"));
-    validTestPositionalArguments.push_back(CLI::PositionalArgument("argument2", "positional argument"));
+    std::vector<CLI::Argument> validTestArguments;
+    validTestArguments.push_back(CLI::Argument("argument0", "argument between optional parameters"));
+    validTestArguments.push_back(CLI::Argument("argument1", "argument"));
+    validTestArguments.push_back(CLI::Argument("argument2", "argument"));
 
     const char** validTestParameterList = new const char*[17];
     validTestParameterList[ 0] = "test";
@@ -71,17 +71,17 @@ int main() {
     validTestParameterList[ 6] = "-d";
     validTestParameterList[ 7] = "separate-value";
     validTestParameterList[ 8] = "-efdouble-concatenated";
-    validTestParameterList[ 9] = "positional argument 0";
+    validTestParameterList[ 9] = "argument 0";
     validTestParameterList[10] = "-gh";
     validTestParameterList[11] = "concatenated-separate-value";
     validTestParameterList[12] = "--long-argument-with-value-included=included value";
     validTestParameterList[13] = "--long-argument-with-value-separated";
     validTestParameterList[14] = "separate value";
-    validTestParameterList[15] = "positional argument 1";
-    validTestParameterList[16] = "positional argument 2";
+    validTestParameterList[15] = "argument 1";
+    validTestParameterList[16] = "argument 2";
     int validTestParameterCount = 17;
 
-    CLI::ArgumentsParser validTestParameterParser = CLI::ArgumentsParser(validTestParameterCount, validTestParameterList, validTestFlags, validTestUnpositionalArguments, validTestPositionalArguments);
+    CLI::ArgumentsParser validTestParameterParser = CLI::ArgumentsParser(validTestParameterCount, validTestParameterList, validTestFlags, validTestOptions, validTestArguments);
 
     ASSERT(!validTestParameterParser.wrongUsage);
     ASSERT(validTestParameterParser.programName == std::string("test"));
@@ -115,50 +115,50 @@ int main() {
     ASSERT(!validTestParameterParser.getFlag('6').isError);
     ASSERT(!validTestParameterParser.getFlag('6').value);
     ASSERT(!validTestParameterParser.getFlag(std::string("66666")).value);
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('c').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('c').value==std::string("concatenated"));
-    ASSERT(validTestParameterParser.getUnpositionalArgument(std::string("ccccc")).value==std::string("concatenated"));
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('d').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('d').value==std::string("separate-value"));
-    ASSERT(validTestParameterParser.getUnpositionalArgument(std::string("ddddd")).value==std::string("separate-value"));
+    ASSERT(!validTestParameterParser.getOption('c').isError);
+    ASSERT(validTestParameterParser.getOption('c').value==std::string("concatenated"));
+    ASSERT(validTestParameterParser.getOption(std::string("ccccc")).value==std::string("concatenated"));
+    ASSERT(!validTestParameterParser.getOption('d').isError);
+    ASSERT(validTestParameterParser.getOption('d').value==std::string("separate-value"));
+    ASSERT(validTestParameterParser.getOption(std::string("ddddd")).value==std::string("separate-value"));
     ASSERT(!validTestParameterParser.getFlag('e').isError);
     ASSERT(validTestParameterParser.getFlag('e').value);
     ASSERT(validTestParameterParser.getFlag(std::string("eeeee")).value);
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('f').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('f').value==std::string("double-concatenated"));
-    ASSERT(validTestParameterParser.getUnpositionalArgument(std::string("fffff")).value==std::string("double-concatenated"));
-    ASSERT(!validTestParameterParser.getPositionalArgument(0).isError);
-    ASSERT(validTestParameterParser.getPositionalArgument(0).value=="positional argument 0");
+    ASSERT(!validTestParameterParser.getOption('f').isError);
+    ASSERT(validTestParameterParser.getOption('f').value==std::string("double-concatenated"));
+    ASSERT(validTestParameterParser.getOption(std::string("fffff")).value==std::string("double-concatenated"));
+    ASSERT(!validTestParameterParser.getArgument(0).isError);
+    ASSERT(validTestParameterParser.getArgument(0).value=="argument 0");
     ASSERT(!validTestParameterParser.getFlag('g').isError);
     ASSERT(validTestParameterParser.getFlag('g').value);
     ASSERT(validTestParameterParser.getFlag(std::string("ggggg")).value);
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('h').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('h').value==std::string("concatenated-separate-value"));
-    ASSERT(validTestParameterParser.getUnpositionalArgument(std::string("hhhhh")).value==std::string("concatenated-separate-value"));
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('x').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('x').value==std::string("included value"));
-    ASSERT(validTestParameterParser.getUnpositionalArgument(std::string("long-argument-with-value-included")).value==std::string("included value"));
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('y').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('y').value==std::string("separate value"));
-    ASSERT(validTestParameterParser.getUnpositionalArgument(std::string("long-argument-with-value-separated")).value==std::string("separate value"));
-    ASSERT(!validTestParameterParser.getPositionalArgument(1).isError);
-    ASSERT(validTestParameterParser.getPositionalArgument(1).value=="positional argument 1");
-    ASSERT(!validTestParameterParser.getPositionalArgument(2).isError);
-    ASSERT(validTestParameterParser.getPositionalArgument(2).value=="positional argument 2");
-    ASSERT(!validTestParameterParser.getUnpositionalArgument('z').isError);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('z').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(validTestParameterParser.getUnpositionalArgument('z').value == std::string(""));
+    ASSERT(!validTestParameterParser.getOption('h').isError);
+    ASSERT(validTestParameterParser.getOption('h').value==std::string("concatenated-separate-value"));
+    ASSERT(validTestParameterParser.getOption(std::string("hhhhh")).value==std::string("concatenated-separate-value"));
+    ASSERT(!validTestParameterParser.getOption('x').isError);
+    ASSERT(validTestParameterParser.getOption('x').value==std::string("included value"));
+    ASSERT(validTestParameterParser.getOption(std::string("long-argument-with-value-included")).value==std::string("included value"));
+    ASSERT(!validTestParameterParser.getOption('y').isError);
+    ASSERT(validTestParameterParser.getOption('y').value==std::string("separate value"));
+    ASSERT(validTestParameterParser.getOption(std::string("long-argument-with-value-separated")).value==std::string("separate value"));
+    ASSERT(!validTestParameterParser.getArgument(1).isError);
+    ASSERT(validTestParameterParser.getArgument(1).value=="argument 1");
+    ASSERT(!validTestParameterParser.getArgument(2).isError);
+    ASSERT(validTestParameterParser.getArgument(2).value=="argument 2");
+    ASSERT(!validTestParameterParser.getOption('z').isError);
+    ASSERT(validTestParameterParser.getOption('z').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(validTestParameterParser.getOption('z').value == std::string(""));
     ASSERT(validTestParameterParser.wrongUsageMessages.size() == 0);
 
     delete[] validTestParameterList;
-    std::cout << "Passed valid input test." << std::endl;
+    std::cout << "Passed valid command line test." << std::endl;
 
     // empty input (valid and invalid) #################################
     std::vector<CLI::Flag> emptyTestFlags;
 
-    std::vector<CLI::UnpositionalArgument> emptyTestUnpositionalArguments;
+    std::vector<CLI::Option> emptyTestOptions;
 
-    std::vector<CLI::PositionalArgument> emptyTestPositionalArguments;
+    std::vector<CLI::Argument> emptyTestArguments;
 
     const char** emptyTestParameterList = new const char*[1];
     // The command is always a part of a command line, even if it is empty
@@ -168,24 +168,24 @@ int main() {
     int emptyTestParameterCount = 1;
 
     // valid
-    CLI::ArgumentsParser validEmptyTestParameterParser = CLI::ArgumentsParser(emptyTestParameterCount, emptyTestParameterList, emptyTestFlags, emptyTestUnpositionalArguments, emptyTestPositionalArguments);
+    CLI::ArgumentsParser validEmptyTestParameterParser = CLI::ArgumentsParser(emptyTestParameterCount, emptyTestParameterList, emptyTestFlags, emptyTestOptions, emptyTestArguments);
     ASSERT(!validEmptyTestParameterParser.wrongUsage);
     ASSERT(validEmptyTestParameterParser.programName == std::string("test"));
     ASSERT(validEmptyTestParameterParser.wrongUsageMessages.size() == 0);
 
     //invalid
-    emptyTestPositionalArguments.push_back(CLI::PositionalArgument("argument", "positional argument"));
+    emptyTestArguments.push_back(CLI::Argument("argument", "argument"));
 
-    CLI::ArgumentsParser invalidEmptyTestParameterParser = CLI::ArgumentsParser(emptyTestParameterCount, emptyTestParameterList, emptyTestFlags, emptyTestUnpositionalArguments, emptyTestPositionalArguments);
+    CLI::ArgumentsParser invalidEmptyTestParameterParser = CLI::ArgumentsParser(emptyTestParameterCount, emptyTestParameterList, emptyTestFlags, emptyTestOptions, emptyTestArguments);
     ASSERT(invalidEmptyTestParameterParser.wrongUsage);
     ASSERT(invalidEmptyTestParameterParser.programName == std::string("test"));
-    ASSERT(invalidEmptyTestParameterParser.getPositionalArgument(0).isError);
-    ASSERT(invalidEmptyTestParameterParser.getPositionalArgument(0).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(invalidEmptyTestParameterParser.getArgument(0).isError);
+    ASSERT(invalidEmptyTestParameterParser.getArgument(0).errorCode == ErrorCodes::NOT_PRESENT);
     ASSERT(invalidEmptyTestParameterParser.wrongUsageMessages.size() == 1);
-    ASSERT(invalidEmptyTestParameterParser.wrongUsageMessages.at(0) == "Too few positional arguments! Missing: argument");
+    ASSERT(invalidEmptyTestParameterParser.wrongUsageMessages.at(0) == "Too few arguments! Missing: argument");
 
     delete[] emptyTestParameterList;
-    std::cout << "Passed empty input test." << std::endl;
+    std::cout << "Passed empty command line test." << std::endl;
 
     // unknown flag ####################################################
 
@@ -197,9 +197,9 @@ int main() {
     unknownFlagTestFlags.push_back(CLI::Flag('4', "four", "test flag"));
     unknownFlagTestFlags.push_back(CLI::Flag('5', "five", "test flag"));
 
-    std::vector<CLI::UnpositionalArgument> unknownFlagTestUnpositionalArguments;
+    std::vector<CLI::Option> unknownFlagTestOptions;
 
-    std::vector<CLI::PositionalArgument> unknownFlagTestPositionalArguments;
+    std::vector<CLI::Argument> unknownFlagTestArguments;
 
     const char** unknownFlagTestParameterList = new const char*[7];
     unknownFlagTestParameterList[0] = "test";
@@ -211,7 +211,7 @@ int main() {
     unknownFlagTestParameterList[6] = "-5";
     int unknownFlagStandaloneTestParameterCount = 2;
 
-    CLI::ArgumentsParser unknownFlagStandaloneTestParser = CLI::ArgumentsParser(unknownFlagStandaloneTestParameterCount, unknownFlagTestParameterList, unknownFlagTestFlags, unknownFlagTestUnpositionalArguments, unknownFlagTestPositionalArguments);
+    CLI::ArgumentsParser unknownFlagStandaloneTestParser = CLI::ArgumentsParser(unknownFlagStandaloneTestParameterCount, unknownFlagTestParameterList, unknownFlagTestFlags, unknownFlagTestOptions, unknownFlagTestArguments);
     ASSERT(unknownFlagStandaloneTestParser.getFlag('1').isError);
     ASSERT(unknownFlagStandaloneTestParser.getFlag('1').errorCode == ErrorCodes::NOT_PRESENT);
     ASSERT(!unknownFlagStandaloneTestParser.getFlag('1').value);
@@ -223,7 +223,7 @@ int main() {
 
     int unknownFlagMixedTestParameterCount = 7;
 
-    CLI::ArgumentsParser unknownFlagMixedTestParser = CLI::ArgumentsParser(unknownFlagMixedTestParameterCount, unknownFlagTestParameterList, unknownFlagTestFlags, unknownFlagTestUnpositionalArguments, unknownFlagTestPositionalArguments);
+    CLI::ArgumentsParser unknownFlagMixedTestParser = CLI::ArgumentsParser(unknownFlagMixedTestParameterCount, unknownFlagTestParameterList, unknownFlagTestFlags, unknownFlagTestOptions, unknownFlagTestArguments);
     ASSERT(unknownFlagMixedTestParser.getFlag('1').isError);
     ASSERT(unknownFlagMixedTestParser.getFlag('1').errorCode == ErrorCodes::WRONG_USAGE);
     ASSERT(unknownFlagMixedTestParser.getFlag('1').value);
@@ -243,9 +243,9 @@ int main() {
     unknownLongFlagTestFlags.push_back(CLI::Flag('4', "four", "test flag"));
     unknownLongFlagTestFlags.push_back(CLI::Flag('5', "five", "test flag"));
 
-    std::vector<CLI::UnpositionalArgument> unknownLongFlagTestUnpositionalArguments;
+    std::vector<CLI::Option> unknownLongFlagTestOptions;
 
-    std::vector<CLI::PositionalArgument> unknownLongFlagTestPositionalArguments;
+    std::vector<CLI::Argument> unknownLongFlagTestArguments;
 
     const char** unknownLongFlagTestParameterList = new const char*[7];
     unknownLongFlagTestParameterList[0] = "test";
@@ -257,7 +257,7 @@ int main() {
     unknownLongFlagTestParameterList[6] = "-5";
     int unknownLongFlagStandaloneTestParameterCount = 2;
 
-    CLI::ArgumentsParser unknownLongFlagStandaloneTestParser = CLI::ArgumentsParser(unknownLongFlagStandaloneTestParameterCount, unknownLongFlagTestParameterList, unknownLongFlagTestFlags, unknownLongFlagTestUnpositionalArguments, unknownLongFlagTestPositionalArguments);
+    CLI::ArgumentsParser unknownLongFlagStandaloneTestParser = CLI::ArgumentsParser(unknownLongFlagStandaloneTestParameterCount, unknownLongFlagTestParameterList, unknownLongFlagTestFlags, unknownLongFlagTestOptions, unknownLongFlagTestArguments);
     ASSERT(unknownLongFlagStandaloneTestParser.getFlag('1').isError);
     ASSERT(unknownLongFlagStandaloneTestParser.getFlag('1').errorCode == ErrorCodes::NOT_PRESENT);
     ASSERT(!unknownLongFlagStandaloneTestParser.getFlag('1').value);
@@ -269,7 +269,7 @@ int main() {
 
     int unknownLongFlagMixedTestParameterCount = 7;
 
-    CLI::ArgumentsParser unknownLongFlagMixedTestParser = CLI::ArgumentsParser(unknownLongFlagMixedTestParameterCount, unknownLongFlagTestParameterList, unknownLongFlagTestFlags, unknownLongFlagTestUnpositionalArguments, unknownLongFlagTestPositionalArguments);
+    CLI::ArgumentsParser unknownLongFlagMixedTestParser = CLI::ArgumentsParser(unknownLongFlagMixedTestParameterCount, unknownLongFlagTestParameterList, unknownLongFlagTestFlags, unknownLongFlagTestOptions, unknownLongFlagTestArguments);
     ASSERT(unknownLongFlagMixedTestParser.getFlag('1').isError);
     ASSERT(unknownLongFlagMixedTestParser.getFlag('1').errorCode == ErrorCodes::WRONG_USAGE);
     ASSERT(unknownLongFlagMixedTestParser.getFlag('1').value);
@@ -282,359 +282,359 @@ int main() {
     delete[] unknownLongFlagTestParameterList;
     std::cout << "Passed unknown flag test." << std::endl;
 
-    // unknown unpositional argument ###################################
+    // unknown argument ################################################
 
-    std::vector<CLI::Flag> unknownArgumentTestFlags;
+    std::vector<CLI::Flag> unknownOptionTestFlags;
 
-    std::vector<CLI::UnpositionalArgument> unknownArgumentTestUnpositionalArguments;
-    unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument"));
-    unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one",  "one",  "test argument"));
-    unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two",  "two",  "test argument"));
-    unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument"));
-    unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument"));
-    unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument"));
+    std::vector<CLI::Option> unknownOptionTestOptions;
+    unknownOptionTestOptions.push_back(CLI::Option('0', "zero", "zero", "test argument"));
+    unknownOptionTestOptions.push_back(CLI::Option('1', "one",  "one",  "test argument"));
+    unknownOptionTestOptions.push_back(CLI::Option('2', "two",  "two",  "test argument"));
+    unknownOptionTestOptions.push_back(CLI::Option('3', "three","three","test argument"));
+    unknownOptionTestOptions.push_back(CLI::Option('4', "four", "four", "test argument"));
+    unknownOptionTestOptions.push_back(CLI::Option('5', "five", "five", "test argument"));
 
-    std::vector<CLI::PositionalArgument> unknownArgumentTestPositionalArguments;
+    std::vector<CLI::Argument> unknownOptionTestArguments;
 
-    const char** unknownArgumentTestParameterList = new const char*[7];
-    unknownArgumentTestParameterList[0] = "test";
-    unknownArgumentTestParameterList[1] = "-a123";
-    unknownArgumentTestParameterList[2] = "-1a";
-    unknownArgumentTestParameterList[3] = "-2b";
-    unknownArgumentTestParameterList[4] = "-3c";
-    unknownArgumentTestParameterList[5] = "-4d";
-    unknownArgumentTestParameterList[6] = "-5e";
-    int unknownArgumentStandaloneTestParameterCount = 2;
+    const char** unknownOptionTestParameterList = new const char*[7];
+    unknownOptionTestParameterList[0] = "test";
+    unknownOptionTestParameterList[1] = "-a123";
+    unknownOptionTestParameterList[2] = "-1a";
+    unknownOptionTestParameterList[3] = "-2b";
+    unknownOptionTestParameterList[4] = "-3c";
+    unknownOptionTestParameterList[5] = "-4d";
+    unknownOptionTestParameterList[6] = "-5e";
+    int unknownOptionStandaloneTestParameterCount = 2;
 
-    CLI::ArgumentsParser unknownArgumentStandaloneTestParser = CLI::ArgumentsParser(unknownArgumentStandaloneTestParameterCount, unknownArgumentTestParameterList, unknownArgumentTestFlags, unknownArgumentTestUnpositionalArguments, unknownArgumentTestPositionalArguments);
-    ASSERT(unknownArgumentStandaloneTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(unknownArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(unknownArgumentStandaloneTestParser.getUnpositionalArgument('1').value == "");
-    ASSERT(unknownArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(unknownArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(unknownArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == "");
-    ASSERT(unknownArgumentStandaloneTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(unknownArgumentStandaloneTestParser.wrongUsageMessages.at(0) == "Unknown argument or flag(s): a123");
+    CLI::ArgumentsParser unknownOptionStandaloneTestParser = CLI::ArgumentsParser(unknownOptionStandaloneTestParameterCount, unknownOptionTestParameterList, unknownOptionTestFlags, unknownOptionTestOptions, unknownOptionTestArguments);
+    ASSERT(unknownOptionStandaloneTestParser.getOption('1').isError);
+    ASSERT(unknownOptionStandaloneTestParser.getOption('1').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(unknownOptionStandaloneTestParser.getOption('1').value == "");
+    ASSERT(unknownOptionStandaloneTestParser.getOption(std::string("four")).isError);
+    ASSERT(unknownOptionStandaloneTestParser.getOption(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(unknownOptionStandaloneTestParser.getOption(std::string("four")).value == "");
+    ASSERT(unknownOptionStandaloneTestParser.wrongUsageMessages.size() == 1);
+    ASSERT(unknownOptionStandaloneTestParser.wrongUsageMessages.at(0) == "Unknown argument or flag(s): a123");
 
-    int unknownArgumentMixedTestParameterCount = 7;
+    int unknownOptionMixedTestParameterCount = 7;
 
-    CLI::ArgumentsParser unknownArgumentMixedTestParser = CLI::ArgumentsParser(unknownArgumentMixedTestParameterCount, unknownArgumentTestParameterList, unknownArgumentTestFlags, unknownArgumentTestUnpositionalArguments, unknownArgumentTestPositionalArguments);
-    ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument('1').value == "a");
-    ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == "d");
-    ASSERT(unknownArgumentMixedTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(unknownArgumentMixedTestParser.wrongUsageMessages.at(0) == "Unknown argument or flag(s): a123");
+    CLI::ArgumentsParser unknownOptionMixedTestParser = CLI::ArgumentsParser(unknownOptionMixedTestParameterCount, unknownOptionTestParameterList, unknownOptionTestFlags, unknownOptionTestOptions, unknownOptionTestArguments);
+    ASSERT(unknownOptionMixedTestParser.getOption('1').isError);
+    ASSERT(unknownOptionMixedTestParser.getOption('1').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(unknownOptionMixedTestParser.getOption('1').value == "a");
+    ASSERT(unknownOptionMixedTestParser.getOption(std::string("four")).isError);
+    ASSERT(unknownOptionMixedTestParser.getOption(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(unknownOptionMixedTestParser.getOption(std::string("four")).value == "d");
+    ASSERT(unknownOptionMixedTestParser.wrongUsageMessages.size() == 1);
+    ASSERT(unknownOptionMixedTestParser.wrongUsageMessages.at(0) == "Unknown argument or flag(s): a123");
 
-    delete[] unknownArgumentTestParameterList;
+    delete[] unknownOptionTestParameterList;
 
-    std::vector<CLI::Flag> unknownLongArgumentTestFlags;
+    std::vector<CLI::Flag> unknownLongOptionTestFlags;
 
-    std::vector<CLI::UnpositionalArgument> unknownLongArgumentTestUnpositionalArguments;
-    unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument"));
-    unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one",  "one",  "test argument"));
-    unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two",  "two",  "test argument"));
-    unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument"));
-    unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument"));
-    unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument"));
+    std::vector<CLI::Option> unknownLongOptionTestOptions;
+    unknownLongOptionTestOptions.push_back(CLI::Option('0', "zero", "zero", "test argument"));
+    unknownLongOptionTestOptions.push_back(CLI::Option('1', "one",  "one",  "test argument"));
+    unknownLongOptionTestOptions.push_back(CLI::Option('2', "two",  "two",  "test argument"));
+    unknownLongOptionTestOptions.push_back(CLI::Option('3', "three","three","test argument"));
+    unknownLongOptionTestOptions.push_back(CLI::Option('4', "four", "four", "test argument"));
+    unknownLongOptionTestOptions.push_back(CLI::Option('5', "five", "five", "test argument"));
 
-    std::vector<CLI::PositionalArgument> unknownLongArgumentTestPositionalArguments;
+    std::vector<CLI::Argument> unknownLongOptionTestArguments;
 
-    const char** unknownLongArgumentTestParameterList = new const char*[7];
-    unknownLongArgumentTestParameterList[0] = "test";
-    unknownLongArgumentTestParameterList[1] = "--a=123";
-    unknownLongArgumentTestParameterList[2] = "-1a";
-    unknownLongArgumentTestParameterList[3] = "-2b";
-    unknownLongArgumentTestParameterList[4] = "-3c";
-    unknownLongArgumentTestParameterList[5] = "-4d";
-    unknownLongArgumentTestParameterList[6] = "-5e";
-    int unknownLongArgumentStandaloneTestParameterCount = 2;
+    const char** unknownLongOptionTestParameterList = new const char*[7];
+    unknownLongOptionTestParameterList[0] = "test";
+    unknownLongOptionTestParameterList[1] = "--a=123";
+    unknownLongOptionTestParameterList[2] = "-1a";
+    unknownLongOptionTestParameterList[3] = "-2b";
+    unknownLongOptionTestParameterList[4] = "-3c";
+    unknownLongOptionTestParameterList[5] = "-4d";
+    unknownLongOptionTestParameterList[6] = "-5e";
+    int unknownLongOptionStandaloneTestParameterCount = 2;
 
-    CLI::ArgumentsParser unknownLongArgumentStandaloneTestParser = CLI::ArgumentsParser(unknownLongArgumentStandaloneTestParameterCount, unknownLongArgumentTestParameterList, unknownLongArgumentTestFlags, unknownLongArgumentTestUnpositionalArguments, unknownLongArgumentTestPositionalArguments);
-    ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument('1').value == "");
-    ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == "");
-    ASSERT(unknownLongArgumentStandaloneTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(unknownLongArgumentStandaloneTestParser.wrongUsageMessages.at(0) == "Unknown argument (or it's a flag that doesn't take a value): --a=123");
+    CLI::ArgumentsParser unknownLongOptionStandaloneTestParser = CLI::ArgumentsParser(unknownLongOptionStandaloneTestParameterCount, unknownLongOptionTestParameterList, unknownLongOptionTestFlags, unknownLongOptionTestOptions, unknownLongOptionTestArguments);
+    ASSERT(unknownLongOptionStandaloneTestParser.getOption('1').isError);
+    ASSERT(unknownLongOptionStandaloneTestParser.getOption('1').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(unknownLongOptionStandaloneTestParser.getOption('1').value == "");
+    ASSERT(unknownLongOptionStandaloneTestParser.getOption(std::string("four")).isError);
+    ASSERT(unknownLongOptionStandaloneTestParser.getOption(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(unknownLongOptionStandaloneTestParser.getOption(std::string("four")).value == "");
+    ASSERT(unknownLongOptionStandaloneTestParser.wrongUsageMessages.size() == 1);
+    ASSERT(unknownLongOptionStandaloneTestParser.wrongUsageMessages.at(0) == "Unknown argument (or it's a flag that doesn't take a value): --a=123");
 
-    int unknownLongArgumentMixedTestParameterCount = 7;
+    int unknownLongOptionMixedTestParameterCount = 7;
 
-    CLI::ArgumentsParser unknownLongArgumentMixedTestParser = CLI::ArgumentsParser(unknownLongArgumentMixedTestParameterCount, unknownLongArgumentTestParameterList, unknownLongArgumentTestFlags, unknownLongArgumentTestUnpositionalArguments, unknownLongArgumentTestPositionalArguments);
-    ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument('1').value == "a");
-    ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == "d");
-    ASSERT(unknownLongArgumentMixedTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(unknownLongArgumentMixedTestParser.wrongUsageMessages.at(0) == "Unknown argument (or it's a flag that doesn't take a value): --a=123");
+    CLI::ArgumentsParser unknownLongOptionMixedTestParser = CLI::ArgumentsParser(unknownLongOptionMixedTestParameterCount, unknownLongOptionTestParameterList, unknownLongOptionTestFlags, unknownLongOptionTestOptions, unknownLongOptionTestArguments);
+    ASSERT(unknownLongOptionMixedTestParser.getOption('1').isError);
+    ASSERT(unknownLongOptionMixedTestParser.getOption('1').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(unknownLongOptionMixedTestParser.getOption('1').value == "a");
+    ASSERT(unknownLongOptionMixedTestParser.getOption(std::string("four")).isError);
+    ASSERT(unknownLongOptionMixedTestParser.getOption(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(unknownLongOptionMixedTestParser.getOption(std::string("four")).value == "d");
+    ASSERT(unknownLongOptionMixedTestParser.wrongUsageMessages.size() == 1);
+    ASSERT(unknownLongOptionMixedTestParser.wrongUsageMessages.at(0) == "Unknown argument (or it's a flag that doesn't take a value): --a=123");
 
-    delete[] unknownLongArgumentTestParameterList;
-    std::cout << "Passed unknown unpositional argument test." << std::endl;
+    delete[] unknownLongOptionTestParameterList;
+    std::cout << "Passed unknown option test." << std::endl;
 
-    // incomplete unpositional argument ###################################
+    // incomplete option ###############################################
 
-    std::vector<CLI::Flag> incompleteArgumentTestFlags;
+    std::vector<CLI::Flag> incompleteOptionTestFlags;
 
-    std::vector<CLI::UnpositionalArgument> incompleteArgumentTestUnpositionalArguments;
-    incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument"));
-    incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one",  "one",  "test argument"));
-    incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two",  "two",  "test argument"));
-    incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument"));
-    incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument"));
-    incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument"));
+    std::vector<CLI::Option> incompleteOptionTestOptions;
+    incompleteOptionTestOptions.push_back(CLI::Option('0', "zero", "zero", "test option"));
+    incompleteOptionTestOptions.push_back(CLI::Option('1', "one",  "one",  "test option"));
+    incompleteOptionTestOptions.push_back(CLI::Option('2', "two",  "two",  "test option"));
+    incompleteOptionTestOptions.push_back(CLI::Option('3', "three","three","test option"));
+    incompleteOptionTestOptions.push_back(CLI::Option('4', "four", "four", "test option"));
+    incompleteOptionTestOptions.push_back(CLI::Option('5', "five", "five", "test option"));
 
-    std::vector<CLI::PositionalArgument> incompleteArgumentTestPositionalArguments;
+    std::vector<CLI::Argument> incompleteOptionTestArguments;
 
-    const char** incompleteArgumentTestParameterList = new const char*[6];
-    incompleteArgumentTestParameterList[0] = "test";
-    incompleteArgumentTestParameterList[1] = "-1";
-    incompleteArgumentTestParameterList[2] = "--two="; // value ""
-    incompleteArgumentTestParameterList[3] = "-3c";
-    incompleteArgumentTestParameterList[4] = "-4";
-    incompleteArgumentTestParameterList[5] = "-5e";
-    int incompleteArgumentStandaloneTestParameterCount = 2;
+    const char** incompleteOptionTestParameterList = new const char*[6];
+    incompleteOptionTestParameterList[0] = "test";
+    incompleteOptionTestParameterList[1] = "-1";
+    incompleteOptionTestParameterList[2] = "--two="; // value ""
+    incompleteOptionTestParameterList[3] = "-3c";
+    incompleteOptionTestParameterList[4] = "-4";
+    incompleteOptionTestParameterList[5] = "-5e";
+    int incompleteOptionStandaloneTestParameterCount = 2;
 
-    CLI::ArgumentsParser incompleteArgumentStandaloneTestParser = CLI::ArgumentsParser(incompleteArgumentStandaloneTestParameterCount, incompleteArgumentTestParameterList, incompleteArgumentTestFlags, incompleteArgumentTestUnpositionalArguments, incompleteArgumentTestPositionalArguments);
-    ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument('1').value == "");
-    ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == "");
-    ASSERT(incompleteArgumentStandaloneTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(incompleteArgumentStandaloneTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
+    CLI::ArgumentsParser incompleteOptionStandaloneTestParser = CLI::ArgumentsParser(incompleteOptionStandaloneTestParameterCount, incompleteOptionTestParameterList, incompleteOptionTestFlags, incompleteOptionTestOptions, incompleteOptionTestArguments);
+    ASSERT(incompleteOptionStandaloneTestParser.getOption('1').isError);
+    ASSERT(incompleteOptionStandaloneTestParser.getOption('1').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteOptionStandaloneTestParser.getOption('1').value == "");
+    ASSERT(incompleteOptionStandaloneTestParser.getOption(std::string("four")).isError);
+    ASSERT(incompleteOptionStandaloneTestParser.getOption(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(incompleteOptionStandaloneTestParser.getOption(std::string("four")).value == "");
+    ASSERT(incompleteOptionStandaloneTestParser.wrongUsageMessages.size() == 1);
+    ASSERT(incompleteOptionStandaloneTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
 
-    int incompleteArgumentMixedTestParameterCount = 6;
+    int incompleteOptionMixedTestParameterCount = 6;
 
-    CLI::ArgumentsParser incompleteArgumentMixedTestParser = CLI::ArgumentsParser(incompleteArgumentMixedTestParameterCount, incompleteArgumentTestParameterList, incompleteArgumentTestFlags, incompleteArgumentTestUnpositionalArguments, incompleteArgumentTestPositionalArguments);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('1').value == "");
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == "");
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('5').isError);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('5').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('5').value == "e");
-    ASSERT(incompleteArgumentMixedTestParser.wrongUsageMessages.size() == 2);
-    ASSERT(incompleteArgumentMixedTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
-    ASSERT(incompleteArgumentMixedTestParser.wrongUsageMessages.at(1) == "Argument expects value but has none: four");
+    CLI::ArgumentsParser incompleteOptionMixedTestParser = CLI::ArgumentsParser(incompleteOptionMixedTestParameterCount, incompleteOptionTestParameterList, incompleteOptionTestFlags, incompleteOptionTestOptions, incompleteOptionTestArguments);
+    ASSERT(incompleteOptionMixedTestParser.getOption('1').isError);
+    ASSERT(incompleteOptionMixedTestParser.getOption('1').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteOptionMixedTestParser.getOption('1').value == "");
+    ASSERT(incompleteOptionMixedTestParser.getOption(std::string("four")).isError);
+    ASSERT(incompleteOptionMixedTestParser.getOption(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteOptionMixedTestParser.getOption(std::string("four")).value == "");
+    ASSERT(incompleteOptionMixedTestParser.getOption('5').isError);
+    ASSERT(incompleteOptionMixedTestParser.getOption('5').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteOptionMixedTestParser.getOption('5').value == "e");
+    ASSERT(incompleteOptionMixedTestParser.wrongUsageMessages.size() == 2);
+    ASSERT(incompleteOptionMixedTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
+    ASSERT(incompleteOptionMixedTestParser.wrongUsageMessages.at(1) == "Argument expects value but has none: four");
 
-    delete[] incompleteArgumentTestParameterList;
+    delete[] incompleteOptionTestParameterList;
 
-    std::vector<CLI::Flag> incompleteLongArgumentTestFlags;
+    std::vector<CLI::Flag> incompleteLongOptionTestFlags;
 
-    std::vector<CLI::UnpositionalArgument> incompleteLongArgumentTestUnpositionalArguments;
-    incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument"));
-    incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one",  "one",  "test argument"));
-    incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two",  "two",  "test argument"));
-    incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument"));
-    incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument"));
-    incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument"));
+    std::vector<CLI::Option> incompleteLongOptionTestOptions;
+    incompleteLongOptionTestOptions.push_back(CLI::Option('0', "zero", "zero", "test argument"));
+    incompleteLongOptionTestOptions.push_back(CLI::Option('1', "one",  "one",  "test argument"));
+    incompleteLongOptionTestOptions.push_back(CLI::Option('2', "two",  "two",  "test argument"));
+    incompleteLongOptionTestOptions.push_back(CLI::Option('3', "three","three","test argument"));
+    incompleteLongOptionTestOptions.push_back(CLI::Option('4', "four", "four", "test argument"));
+    incompleteLongOptionTestOptions.push_back(CLI::Option('5', "five", "five", "test argument"));
 
-    std::vector<CLI::PositionalArgument> incompleteLongArgumentTestPositionalArguments;
+    std::vector<CLI::Argument> incompleteLongOptionTestArguments;
 
-    const char** incompleteLongArgumentTestParameterList = new const char*[8];
-    incompleteLongArgumentTestParameterList[0] = "test";
-    incompleteLongArgumentTestParameterList[1] = "--one";
-    incompleteLongArgumentTestParameterList[2] = "--two";
-    incompleteLongArgumentTestParameterList[3] = "b";
-    incompleteLongArgumentTestParameterList[4] = "-3c";
-    incompleteLongArgumentTestParameterList[5] = "positional_arg";
-    incompleteLongArgumentTestParameterList[6] = "--four";
-    incompleteLongArgumentTestParameterList[7] = "--five=e";
-    int incompleteLongArgumentStandaloneTestParameterCount = 2;
+    const char** incompleteLongOptionTestParameterList = new const char*[8];
+    incompleteLongOptionTestParameterList[0] = "test";
+    incompleteLongOptionTestParameterList[1] = "--one";
+    incompleteLongOptionTestParameterList[2] = "--two";
+    incompleteLongOptionTestParameterList[3] = "b";
+    incompleteLongOptionTestParameterList[4] = "-3c";
+    incompleteLongOptionTestParameterList[5] = "arg";
+    incompleteLongOptionTestParameterList[6] = "--four";
+    incompleteLongOptionTestParameterList[7] = "--five=e";
+    int incompleteLongOptionStandaloneTestParameterCount = 2;
 
-    CLI::ArgumentsParser incompleteLongArgumentStandaloneTestParser = CLI::ArgumentsParser(incompleteLongArgumentStandaloneTestParameterCount, incompleteLongArgumentTestParameterList, incompleteLongArgumentTestFlags, incompleteLongArgumentTestUnpositionalArguments, incompleteLongArgumentTestPositionalArguments);
-    ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument('1').value == "");
-    ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == "");
-    ASSERT(incompleteLongArgumentStandaloneTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(incompleteLongArgumentStandaloneTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
+    CLI::ArgumentsParser incompleteLongOptionStandaloneTestParser = CLI::ArgumentsParser(incompleteLongOptionStandaloneTestParameterCount, incompleteLongOptionTestParameterList, incompleteLongOptionTestFlags, incompleteLongOptionTestOptions, incompleteLongOptionTestArguments);
+    ASSERT(incompleteLongOptionStandaloneTestParser.getOption('1').isError);
+    ASSERT(incompleteLongOptionStandaloneTestParser.getOption('1').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteLongOptionStandaloneTestParser.getOption('1').value == "");
+    ASSERT(incompleteLongOptionStandaloneTestParser.getOption(std::string("four")).isError);
+    ASSERT(incompleteLongOptionStandaloneTestParser.getOption(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(incompleteLongOptionStandaloneTestParser.getOption(std::string("four")).value == "");
+    ASSERT(incompleteLongOptionStandaloneTestParser.wrongUsageMessages.size() == 1);
+    ASSERT(incompleteLongOptionStandaloneTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
 
-    int incompleteLongArgumentMixedTestParameterCount = 8;
-    incompleteLongArgumentTestPositionalArguments.push_back(CLI::PositionalArgument("arg", "argument"));
+    int incompleteLongOptionMixedTestParameterCount = 8;
+    incompleteLongOptionTestArguments.push_back(CLI::Argument("arg", "argument"));
 
-    CLI::ArgumentsParser incompleteLongArgumentMixedTestParser = CLI::ArgumentsParser(incompleteLongArgumentMixedTestParameterCount, incompleteLongArgumentTestParameterList, incompleteLongArgumentTestFlags, incompleteLongArgumentTestUnpositionalArguments, incompleteLongArgumentTestPositionalArguments);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('1').isError);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('1').value == "");
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('2').isError);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('2').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('2').value == "b");
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == "");
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('5').isError);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('5').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('5').value == "e");
-    ASSERT(incompleteLongArgumentMixedTestParser.wrongUsageMessages.size() == 2);
-    ASSERT(incompleteLongArgumentMixedTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
-    ASSERT(incompleteLongArgumentMixedTestParser.wrongUsageMessages.at(1) == "Argument expects value but has none: four");
+    CLI::ArgumentsParser incompleteLongOptionMixedTestParser = CLI::ArgumentsParser(incompleteLongOptionMixedTestParameterCount, incompleteLongOptionTestParameterList, incompleteLongOptionTestFlags, incompleteLongOptionTestOptions, incompleteLongOptionTestArguments);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('1').isError);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('1').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('1').value == "");
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('2').isError);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('2').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('2').value == "b");
+    ASSERT(incompleteLongOptionMixedTestParser.getOption(std::string("four")).isError);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption(std::string("four")).value == "");
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('5').isError);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('5').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(incompleteLongOptionMixedTestParser.getOption('5').value == "e");
+    ASSERT(incompleteLongOptionMixedTestParser.wrongUsageMessages.size() == 2);
+    ASSERT(incompleteLongOptionMixedTestParser.wrongUsageMessages.at(0) == "Argument expects value but has none: one");
+    ASSERT(incompleteLongOptionMixedTestParser.wrongUsageMessages.at(1) == "Argument expects value but has none: four");
 
-    delete[] incompleteLongArgumentTestParameterList;
-    std::cout << "Passed incomplete unpositional argument test." << std::endl;
+    delete[] incompleteLongOptionTestParameterList;
+    std::cout << "Passed incomplete option test." << std::endl;
 
-    // too few positional arguments
+    // too few arguments ###############################################
 
     std::vector<CLI::Flag> tooFewArgumentsTestFlags;
     tooFewArgumentsTestFlags.push_back(CLI::Flag('a', "aaaaa", "test flag"));
 
-    std::vector<CLI::UnpositionalArgument> tooFewArgumentsTestUnpositionalArguments;
-    tooFewArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('b', "bbbbb", "b", "test argument"));
-    tooFewArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('c', "ccccc", "c", "test argument"));
-    tooFewArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('d', "ddddd", "d", "test argument"));
+    std::vector<CLI::Option> tooFewArgumentsTestOptions;
+    tooFewArgumentsTestOptions.push_back(CLI::Option('b', "bbbbb", "b", "test argument"));
+    tooFewArgumentsTestOptions.push_back(CLI::Option('c', "ccccc", "c", "test argument"));
+    tooFewArgumentsTestOptions.push_back(CLI::Option('d', "ddddd", "d", "test argument"));
 
-    std::vector<CLI::PositionalArgument> tooFewArgumentsTestPositionalArguments;
-    tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument0", "test argument"));
-    tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument1", "test argument"));
-    tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument2", "test argument"));
-    tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument3", "test argument"));
-    tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument4", "test argument"));
+    std::vector<CLI::Argument> tooFewArgumentsTestArguments;
+    tooFewArgumentsTestArguments.push_back(CLI::Argument("argument0", "test argument"));
+    tooFewArgumentsTestArguments.push_back(CLI::Argument("argument1", "test argument"));
+    tooFewArgumentsTestArguments.push_back(CLI::Argument("argument2", "test argument"));
+    tooFewArgumentsTestArguments.push_back(CLI::Argument("argument3", "test argument"));
+    tooFewArgumentsTestArguments.push_back(CLI::Argument("argument4", "test argument"));
 
     const char** tooFewArgumentsTestParameterList = new const char*[10];
     tooFewArgumentsTestParameterList[0] = "test";
-    tooFewArgumentsTestParameterList[1] = "positional_arg_0";
+    tooFewArgumentsTestParameterList[1] = "arg_0";
     tooFewArgumentsTestParameterList[2] = "-a";//
     tooFewArgumentsTestParameterList[3] = "-b";
     tooFewArgumentsTestParameterList[4] = "1";
     tooFewArgumentsTestParameterList[5] = "-c5";
-    tooFewArgumentsTestParameterList[6] = "positional_arg_1";
+    tooFewArgumentsTestParameterList[6] = "arg_1";
     tooFewArgumentsTestParameterList[7] = "--ddddd";
     tooFewArgumentsTestParameterList[8] = "ddd";
-    tooFewArgumentsTestParameterList[9] = "positional_arg_2";
+    tooFewArgumentsTestParameterList[9] = "arg_2";
 
     int tooFewArgumentsStandaloneTestParameterCount = 2;
-    CLI::ArgumentsParser tooFewArgumentsStandaloneTestParser = CLI::ArgumentsParser(tooFewArgumentsStandaloneTestParameterCount, tooFewArgumentsTestParameterList, tooFewArgumentsTestFlags, tooFewArgumentsTestUnpositionalArguments, tooFewArgumentsTestPositionalArguments);
+    CLI::ArgumentsParser tooFewArgumentsStandaloneTestParser = CLI::ArgumentsParser(tooFewArgumentsStandaloneTestParameterCount, tooFewArgumentsTestParameterList, tooFewArgumentsTestFlags, tooFewArgumentsTestOptions, tooFewArgumentsTestArguments);
 
-    ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(0).isError);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(0).value == "positional_arg_0");
-    ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(1).isError);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(1).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(1).value == "");
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('b').isError);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('b').value == "");
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('c').isError);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('c').value == "");
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('d').isError);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('d').value == "");
+    ASSERT(tooFewArgumentsStandaloneTestParser.getArgument(0).isError);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getArgument(0).value == "arg_0");
+    ASSERT(tooFewArgumentsStandaloneTestParser.getArgument(1).isError);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getArgument(1).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getArgument(1).value == "");
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('b').isError);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('b').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('b').value == "");
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('c').isError);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('c').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('c').value == "");
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('d').isError);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('d').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooFewArgumentsStandaloneTestParser.getOption('d').value == "");
     ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.size() == 4);
-    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(0) == "Too few positional arguments! Missing: argument1");
-    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(1) == "Too few positional arguments! Missing: argument2");
-    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(2) == "Too few positional arguments! Missing: argument3");
-    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(3) == "Too few positional arguments! Missing: argument4");
+    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(0) == "Too few arguments! Missing: argument1");
+    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(1) == "Too few arguments! Missing: argument2");
+    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(2) == "Too few arguments! Missing: argument3");
+    ASSERT(tooFewArgumentsStandaloneTestParser.wrongUsageMessages.at(3) == "Too few arguments! Missing: argument4");
 
     int tooFewArgumentsMixedTestParameterCount = 10;
-    CLI::ArgumentsParser tooFewArgumentsMixedTestParser = CLI::ArgumentsParser(tooFewArgumentsMixedTestParameterCount, tooFewArgumentsTestParameterList, tooFewArgumentsTestFlags, tooFewArgumentsTestUnpositionalArguments, tooFewArgumentsTestPositionalArguments);
+    CLI::ArgumentsParser tooFewArgumentsMixedTestParser = CLI::ArgumentsParser(tooFewArgumentsMixedTestParameterCount, tooFewArgumentsTestParameterList, tooFewArgumentsTestFlags, tooFewArgumentsTestOptions, tooFewArgumentsTestArguments);
 
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(0).isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(0).value == "positional_arg_0");
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(1).isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(1).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(1).value == "positional_arg_1");
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(2).isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(2).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(2).value == "positional_arg_2");
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(3).isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(3).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(3).value == "");
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(4).isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(4).errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(4).value == "");
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('b').isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('b').value == "1");
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('c').isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('c').value == "5");
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('d').isError);
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('d').value == "ddd");
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(0).isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(0).value == "arg_0");
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(1).isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(1).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(1).value == "arg_1");
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(2).isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(2).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(2).value == "arg_2");
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(3).isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(3).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(3).value == "");
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(4).isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(4).errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooFewArgumentsMixedTestParser.getArgument(4).value == "");
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('b').isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('b').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('b').value == "1");
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('c').isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('c').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('c').value == "5");
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('d').isError);
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('d').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooFewArgumentsMixedTestParser.getOption('d').value == "ddd");
     ASSERT(tooFewArgumentsMixedTestParser.wrongUsageMessages.size() == 2);
-    ASSERT(tooFewArgumentsMixedTestParser.wrongUsageMessages.at(0) == "Too few positional arguments! Missing: argument3");
-    ASSERT(tooFewArgumentsMixedTestParser.wrongUsageMessages.at(1) == "Too few positional arguments! Missing: argument4");
+    ASSERT(tooFewArgumentsMixedTestParser.wrongUsageMessages.at(0) == "Too few arguments! Missing: argument3");
+    ASSERT(tooFewArgumentsMixedTestParser.wrongUsageMessages.at(1) == "Too few arguments! Missing: argument4");
 
     delete[] tooFewArgumentsTestParameterList;
-    std::cout << "Passed too few positional arguments test." << std::endl;
+    std::cout << "Passed too few arguments test." << std::endl;
 
-    // too many positional arguments
+    // too many arguments ##############################################
 
     std::vector<CLI::Flag> tooManyArgumentsTestFlags;
     tooManyArgumentsTestFlags.push_back(CLI::Flag('a', "aaaaa", "test flag"));
 
-    std::vector<CLI::UnpositionalArgument> tooManyArgumentsTestUnpositionalArguments;
-    tooManyArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('b', "bbbbb", "b", "test argument"));
-    tooManyArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('c', "ccccc", "c", "test argument"));
-    tooManyArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('d', "ddddd", "d", "test argument"));
+    std::vector<CLI::Option> tooManyArgumentsTestOptions;
+    tooManyArgumentsTestOptions.push_back(CLI::Option('b', "bbbbb", "b", "test argument"));
+    tooManyArgumentsTestOptions.push_back(CLI::Option('c', "ccccc", "c", "test argument"));
+    tooManyArgumentsTestOptions.push_back(CLI::Option('d', "ddddd", "d", "test argument"));
 
-    std::vector<CLI::PositionalArgument> tooManyArgumentsTestPositionalArguments;
-    tooManyArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument0", "test argument"));
+    std::vector<CLI::Argument> tooManyArgumentsTestArguments;
+    tooManyArgumentsTestArguments.push_back(CLI::Argument("argument0", "test argument"));
 
     const char** tooManyArgumentsTestParameterList = new const char*[10];
     tooManyArgumentsTestParameterList[0] = "test";
-    tooManyArgumentsTestParameterList[1] = "positional_arg_0";
-    tooManyArgumentsTestParameterList[2] = "positional_arg_1";
+    tooManyArgumentsTestParameterList[1] = "arg_0";
+    tooManyArgumentsTestParameterList[2] = "arg_1";
     tooManyArgumentsTestParameterList[3] = "-a";//
     tooManyArgumentsTestParameterList[4] = "-b";
     tooManyArgumentsTestParameterList[5] = "1";
     tooManyArgumentsTestParameterList[6] = "-c5";
     tooManyArgumentsTestParameterList[7] = "--ddddd";
     tooManyArgumentsTestParameterList[8] = "ddd";
-    tooManyArgumentsTestParameterList[9] = "positional_arg_2";
+    tooManyArgumentsTestParameterList[9] = "arg_2";
 
     int tooManyArgumentsStandaloneTestParameterCount = 3;
-    CLI::ArgumentsParser tooManyArgumentsStandaloneTestParser = CLI::ArgumentsParser(tooManyArgumentsStandaloneTestParameterCount, tooManyArgumentsTestParameterList, tooManyArgumentsTestFlags, tooManyArgumentsTestUnpositionalArguments, tooManyArgumentsTestPositionalArguments);
+    CLI::ArgumentsParser tooManyArgumentsStandaloneTestParser = CLI::ArgumentsParser(tooManyArgumentsStandaloneTestParameterCount, tooManyArgumentsTestParameterList, tooManyArgumentsTestFlags, tooManyArgumentsTestOptions, tooManyArgumentsTestArguments);
 
-    ASSERT(tooManyArgumentsStandaloneTestParser.getPositionalArgument(0).isError);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getPositionalArgument(0).value == "positional_arg_0");
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('b').isError);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('b').value == "");
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('c').isError);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('c').value == "");
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('d').isError);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::NOT_PRESENT);
-    ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('d').value == "");
+    ASSERT(tooManyArgumentsStandaloneTestParser.getArgument(0).isError);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getArgument(0).value == "arg_0");
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('b').isError);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('b').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('b').value == "");
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('c').isError);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('c').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('c').value == "");
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('d').isError);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('d').errorCode == ErrorCodes::NOT_PRESENT);
+    ASSERT(tooManyArgumentsStandaloneTestParser.getOption('d').value == "");
     ASSERT(tooManyArgumentsStandaloneTestParser.wrongUsageMessages.size() == 1);
-    ASSERT(tooManyArgumentsStandaloneTestParser.wrongUsageMessages.at(0) == "Too many positional arguments! Unexpected encounter of: positional_arg_1");
+    ASSERT(tooManyArgumentsStandaloneTestParser.wrongUsageMessages.at(0) == "Too many arguments! Unexpected encounter of: arg_1");
 
     int tooManyArgumentsMixedTestParameterCount = 10;
-    CLI::ArgumentsParser tooManyArgumentsMixedTestParser = CLI::ArgumentsParser(tooManyArgumentsMixedTestParameterCount, tooManyArgumentsTestParameterList, tooManyArgumentsTestFlags, tooManyArgumentsTestUnpositionalArguments, tooManyArgumentsTestPositionalArguments);
+    CLI::ArgumentsParser tooManyArgumentsMixedTestParser = CLI::ArgumentsParser(tooManyArgumentsMixedTestParameterCount, tooManyArgumentsTestParameterList, tooManyArgumentsTestFlags, tooManyArgumentsTestOptions, tooManyArgumentsTestArguments);
 
-    ASSERT(tooManyArgumentsMixedTestParser.getPositionalArgument(0).isError);
-    ASSERT(tooManyArgumentsMixedTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooManyArgumentsMixedTestParser.getPositionalArgument(0).value == "positional_arg_0");
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('b').isError);
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('b').value == "1");
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('c').isError);
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('c').value == "5");
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('d').isError);
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::WRONG_USAGE);
-    ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('d').value == "ddd");
+    ASSERT(tooManyArgumentsMixedTestParser.getArgument(0).isError);
+    ASSERT(tooManyArgumentsMixedTestParser.getArgument(0).errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooManyArgumentsMixedTestParser.getArgument(0).value == "arg_0");
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('b').isError);
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('b').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('b').value == "1");
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('c').isError);
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('c').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('c').value == "5");
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('d').isError);
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('d').errorCode == ErrorCodes::WRONG_USAGE);
+    ASSERT(tooManyArgumentsMixedTestParser.getOption('d').value == "ddd");
     ASSERT(tooManyArgumentsMixedTestParser.wrongUsageMessages.size() == 2);
-    ASSERT(tooManyArgumentsMixedTestParser.wrongUsageMessages.at(0) == "Too many positional arguments! Unexpected encounter of: positional_arg_1");
-    ASSERT(tooManyArgumentsMixedTestParser.wrongUsageMessages.at(1) == "Too many positional arguments! Unexpected encounter of: positional_arg_2");
+    ASSERT(tooManyArgumentsMixedTestParser.wrongUsageMessages.at(0) == "Too many arguments! Unexpected encounter of: arg_1");
+    ASSERT(tooManyArgumentsMixedTestParser.wrongUsageMessages.at(1) == "Too many arguments! Unexpected encounter of: arg_2");
 
     delete[] tooManyArgumentsTestParameterList;
-    std::cout << "Passed too many positional arguments test." << std::endl;
+    std::cout << "Passed too many arguments test." << std::endl;
 
     return 0;
 }
diff --git a/src/tools/hexnet.cpp b/src/tools/hexnet.cpp
index d322416..3676841 100644
--- a/src/tools/hexnet.cpp
+++ b/src/tools/hexnet.cpp
@@ -97,14 +97,14 @@ int main(int argc, char* argv[]){
     flags.push_back(CLI::Flag('t', "tcp", "use TCP, defaults to both when -t and -u are omitted, otherwise uses what is specified"));
     flags.push_back(CLI::Flag('u', "udp", "use UDP, defaults to both when -t and -u are omitted, otherwise uses what is specified"));
 
-    std::vector<CLI::UnpositionalArgument> unpositionalArguments;
-    unpositionalArguments.push_back(CLI::UnpositionalArgument('c', "connect", "HOST", "connect to HOST, listen for incoming connections if omitted"));
-    unpositionalArguments.push_back(CLI::UnpositionalArgument('m', "mtu-optimize", "MTU", "Optimize for a specific maximum transfer unit by reading MTU bytes at a time."));
+    std::vector<CLI::Option> options;
+    options.push_back(CLI::Option('c', "connect", "HOST", "connect to HOST, listen for incoming connections if omitted"));
+    options.push_back(CLI::Option('m', "mtu-optimize", "MTU", "Optimize for a specific maximum transfer unit by reading MTU bytes at a time."));
 
-    std::vector<CLI::PositionalArgument> positionalArguments;
-    positionalArguments.push_back(CLI::PositionalArgument("PORT", "the port to use"));
+    std::vector<CLI::Argument> arguments;
+    arguments.push_back(CLI::Argument("PORT", "the port to use"));
 
-    CLI::ArgumentsParser cliParser = CLI::ArgumentsParser(argc, argv, flags, unpositionalArguments, positionalArguments);
+    CLI::ArgumentsParser cliParser = CLI::ArgumentsParser(argc, argv, flags, options, arguments);
 
     if (cliParser.wrongUsage) {
         //TODO: spit out usage information generated by the parser
@@ -118,16 +118,16 @@ int main(int argc, char* argv[]){
         tcp = cliParser.getFlag('t').value;
         udp = cliParser.getFlag('u').value;
     }
-    if (cliParser.getUnpositionalArgument('c').errorCode == ErrorCodes::NOT_PRESENT) {
+    if (cliParser.getOption('c').errorCode == ErrorCodes::NOT_PRESENT) {
         listenMode = true;
     }
-    if (cliParser.getUnpositionalArgument('m').errorCode == ErrorCodes::SUCCESS) {
-        mtu = std::stol(cliParser.getUnpositionalArgument('m').value);
+    if (cliParser.getOption('m').errorCode == ErrorCodes::SUCCESS) {
+        mtu = std::stol(cliParser.getOption('m').value);
     }
-    host = cliParser.getUnpositionalArgument('c').value;
+    host = cliParser.getOption('c').value;
     //FIXME: use a function that returns a fixed-width data type instead,
     //       ensure that the given value is a valid port
-    port = (in_port_t) std::stoi(cliParser.getPositionalArgument(0).value);
+    port = (in_port_t) std::stoi(cliParser.getArgument(0).value);
 
     if (listenMode) {
         if (ipv6) {