From 2fb95d72fcef0ebd1183c2ade398a481e8f8d2da Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Tue, 16 Sep 2025 17:32:20 +0200
Subject: [PATCH 01/10] manually rebase cli rework branch on new main

---
 cpp/examples/cli.cpp                |  110 ++-
 cpp/memilio/CMakeLists.txt          |    1 +
 cpp/memilio/io/cli.cpp              |  225 ++++++
 cpp/memilio/io/cli.h                | 1026 +++++++++++++++------------
 cpp/memilio/utils/string_literal.h  |   19 +
 cpp/tests/distributions_helpers.cpp |   16 +-
 cpp/tests/distributions_helpers.h   |    3 +
 cpp/tests/test_io_cli.cpp           |  409 +++++++----
 8 files changed, 1165 insertions(+), 644 deletions(-)
 create mode 100644 cpp/memilio/io/cli.cpp

diff --git a/cpp/examples/cli.cpp b/cpp/examples/cli.cpp
index 6dcfe55bcd..5df8ada063 100644
--- a/cpp/examples/cli.cpp
+++ b/cpp/examples/cli.cpp
@@ -19,85 +19,57 @@
 */
 #include "memilio/io/cli.h"
 
-#include <vector>
-
-struct Name {
-    using Type = std::vector<std::string>;
-
-    static Type get_default()
-    {
-        return Type{"FirstName", "LastName"};
-    }
-    const static std::string name()
-    {
-        return "Name";
-    }
-    const static std::string alias()
-    {
-        return "n";
-    }
-    const static std::string description()
-    {
-        return "Enter your name as list of strings.";
-    }
-};
-
-struct Age {
-    using Type = int;
-    const static std::string name()
-    {
-        return "Age";
-    }
-    const static std::string alias()
-    {
-        return "a";
-    }
-    const static std::string description()
-    {
-        return "Enter your age.";
-    }
-};
-
-struct Greeting {
-    using Type = std::string;
-
-    static Type get_default()
-    {
-        return Type{"Hello World!"};
-    }
-    const static std::string name()
-    {
-        return "Greeting";
-    }
-    const static std::string description()
-    {
-        return "Enter a custom greeting.";
-    }
-};
-
 int main(int argc, char** argv)
 {
-    if (argc == 1) { // Print this if no arguments were given
+    // Print a message if no arguments were given.
+    if (argc == 1) {
         std::cout << "This is a small example on how to use the command line interface. "
                      "Use \"-h\" to show the help dialogue.\n";
     }
-    // create parameter set
-    auto parameters = mio::ParameterSet<Name, Age, Greeting>{};
-    // get command line options
-    auto result = mio::command_line_interface("cli_example", argc, argv, parameters);
-    // catch errors
+    // Create a parameter set for the CLI using the builder. This defines the (parameter) options that the user can set
+    // through the command line.
+    //
+    // To add a parameter, you need to specify the name and type and pass an initial value. The type can sometimes be
+    // deduced from the initial value, so it can sometimes be omitted.
+    // After the initial value you can set some optional fields of the parameter:
+    // - alias, which allows you to add a shorthand for setting values
+    // - description, which contains details on, e.g., what the parameter does and what values are accepted.
+    // - is_required, which makes the CLI check whether the parameter was set. If not, it exits with an error.
+    //
+    // As a general rule, use simple types! The more complicated the type, the more complex is the Json representation
+    // that the user has to input.
+    //
+    // Instead of using the builder, you can also define and pass a mio::ParameterSet as paraneters.
+    // The main difference (for the CLI) is that the mio::ParameterSet uses struct names to "get" parameters, while
+    // the mio::cli::ParameterSet uses StringLiteral%s.
+    auto parameters = mio::cli::ParameterSetBuilder()
+                          .add<"Name", std::vector<std::string>>({"FirstName", "LastName"},
+                                                                 {"n", "Enter your name as list of strings.", true})
+                          .add<"Age">(0, {"a", "Enter your age."})
+                          .add<"Greeting">(std::string("Hello World!"),
+                                           {.description = "Enter a custom greeting.", .is_required = false})
+                          .build();
+    // Define some default options. This is an optional feature, that allows users to set some options in the given
+    // order as the first arguments, without specifying their name or alias.
+    auto default_options = std::vector<std::string>{"Name", "Age"};
+    // Parse command line arguments and/or set parameters. This next line as well as the following check on its result
+    // are required to use the CLI.
+    auto result = mio::command_line_interface(argv[0], argc, argv, parameters, default_options);
+    // Catch and print help output, printed options, and errors.
     if (!result) {
-        std::cout << result.error().formatted_message();
-        return result.error().code().value();
+        std::cout << result.error().message(); // Do not use formatted_message().
+        return result.error().code().value(); // Use exit here when not used in main().
     }
-    // do something with the parameters
-    std::cout << parameters.get<Greeting>() << "\n"
+    // Now, do something with the parameters!
+    // Note that the CLI only verifies that the user input is parsable, not plausible. If a parameter has certain value
+    // requirements, like "Age > 0", you must check this
+    std::cout << parameters.get<"Greeting">() << "\n"
               << "Name: ";
-    for (auto& name : parameters.get<Name>()) {
+    for (auto& name : parameters.get<"Name">()) {
         std::cout << name << " ";
     }
     std::cout << "\n";
-    if (parameters.get<Age>() > 0) {
-        std::cout << "Age: " << parameters.get<Age>() << "\n";
+    if (parameters.get<"Age">() > 0) {
+        std::cout << "Age: " << parameters.get<"Age">() << "\n";
     }
 }
diff --git a/cpp/memilio/CMakeLists.txt b/cpp/memilio/CMakeLists.txt
index 5079672695..ed21478da6 100644
--- a/cpp/memilio/CMakeLists.txt
+++ b/cpp/memilio/CMakeLists.txt
@@ -50,6 +50,7 @@ add_library(memilio
     io/result_io.cpp
     io/epi_data.h
     io/epi_data.cpp
+    io/cli.cpp
     io/cli.h
     math/euler.cpp
     math/euler.h
diff --git a/cpp/memilio/io/cli.cpp b/cpp/memilio/io/cli.cpp
new file mode 100644
index 0000000000..82fb63c36b
--- /dev/null
+++ b/cpp/memilio/io/cli.cpp
@@ -0,0 +1,225 @@
+/*
+* Copyright (C) 2020-2025 MEmilio
+*
+* Authors: René Schmieding
+*
+* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*     http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+#include "memilio/io/cli.h"
+
+#include <sstream>
+
+/// @brief Part of write_help implementation. Writes the header with usage information and default options.
+void write_help_preamble(const std::string& executable_name, const std::vector<std::string>& default_options,
+                         std::ostream& os)
+{
+    os << "Usage: " << executable_name;
+    if (default_options.size() > 0) {
+        os << " [";
+        size_t i = 0;
+        for (; i < default_options.size() - 1; i++) {
+            os << default_options[i] << " ";
+        }
+        os << default_options[i] << "]";
+    }
+    os << " <option> <value> ...\n";
+    if (default_options.size() > 0) {
+        os << "Values of parameter options listed in [brackets] can be optionally entered in that order.\n";
+    }
+    os << "All values must be entered as json values, i.e. the expression to the right of \"Name : \".\n"
+       << "Note that, when entering values, quotation marks may have to be escaped (\\\").\n";
+}
+
+/// @brief Part of write_help implementation. Writes out a singular parameter option.
+void write_help_parameter(const mio::cli::details::DatalessParameter& parameter, std::ostream& os)
+{
+    // Max. space and offsets used to print everything nicely.
+    constexpr size_t name_space         = 16; // reserved space for name
+    constexpr size_t alias_space        = 4; // reserved space for alias
+    constexpr size_t name_indent        = 4; // size of "  --"
+    constexpr size_t alias_indent       = 3; // size of "  -"
+    constexpr size_t description_indent = 2; // size of "  "
+    // Write name with "--" prefix and "  " indent
+    os << "  --" << parameter.name;
+    if (parameter.description.size() > 0 || parameter.alias.size() > 0) {
+        if (parameter.name.size() <= name_space) {
+            os << std::string(name_space - parameter.name.size(), ' ');
+        }
+        else {
+            os << "\n" << std::string(name_space + name_indent, ' ');
+        }
+    }
+    // Write alias (if available) with "-" prefix and "  " indent
+    size_t space = std::max<size_t>(alias_space - parameter.alias.size(), 0);
+    if (parameter.alias.size() > 0) {
+        os << "  -" << parameter.alias;
+    }
+    else {
+        space += alias_indent;
+    }
+    // Write description (if available) and end line indentation
+    if (parameter.description.size() > 0) {
+        os << std::string(space + description_indent, ' ') << parameter.description;
+    }
+    os << "\n";
+}
+
+void mio::cli::details::write_help(const std::string& executable_name, const AbstractSet& set,
+                                   const std::vector<std::string>& default_options, std::ostream& os)
+{
+    write_help_preamble(executable_name, default_options, os);
+    os << "Options:\n";
+    for (const auto& parameter : PresetOptions::all_presets) {
+        write_help_parameter(parameter, os);
+    }
+    os << "Parameter options:\n";
+    for (const auto& parameter : set.parameters()) {
+        write_help_parameter(parameter, os);
+    }
+}
+
+mio::IOResult<void> mio::cli::details::write_abstract_set_to_file(mio::cli::details::AbstractSet& set,
+                                                                  const std::string& filepath)
+{
+    Json::Value output;
+    for (auto& parameter : set.parameters()) {
+        BOOST_OUTCOME_TRY(output[parameter.name()], parameter.get());
+    }
+    return mio::write_json(filepath, output);
+}
+
+mio::IOResult<void> mio::cli::details::read_abstract_set_from_file(mio::cli::details::AbstractSet& set,
+                                                                   const std::string& filepath)
+{
+    // read file into json value
+    auto json_result = mio::read_json(filepath);
+    if (!json_result) {
+        return mio::failure(json_result.error());
+    }
+    // set each parameter manually
+    for (auto itr = json_result.value().begin(); itr != json_result.value().end(); itr++) {
+        BOOST_OUTCOME_TRY(set.set_param(mio::cli::details::Identifier::make_raw(itr.name()), *itr));
+    }
+    return mio::success();
+}
+
+mio::IOResult<void> mio::cli::details::command_line_interface(const std::string& executable_name, const int argc,
+                                                              char** argv, cli::details::AbstractSet& set,
+                                                              const std::vector<std::string>& default_options)
+{
+    assert(set.parameters().size() > 0 && "At least one parameter is required!");
+    // this function glues all functionalities of the cli together. it may repeatedly iterate through all values of
+    // argv (starting at 1).
+    using namespace mio::cli;
+    using namespace mio::cli::details;
+    // verify that all default_options are parameter names
+    for (const auto& option : default_options) {
+        if (!set.contains(Identifier::make_raw(option))) {
+            return failure(mio::StatusCode::KeyNotFound, "Default option \"" + option + "\" is not a parameter name.");
+        }
+    }
+    // pre-scan all argumemts before doing anything with them to deal with help and print_option
+    // this avoids returning e.g. parsing errors instead of the help dialogue
+    for (int i = 1; i < argc; i++) {
+        auto id_result = Identifier::parse(argv[i]);
+        // skip non-option arguments
+        if (!id_result) {
+            continue;
+        }
+        const auto& id = id_result.value();
+        // handle help option
+        if (id.matches_parameter(PresetOptions::help)) {
+            // print the help dialogue and exit
+            std::stringstream ss;
+            write_help(executable_name, set, default_options, ss);
+            return mio::failure(StatusCode::OK, std::move(ss.str()));
+        }
+        // handle print_option option
+        else if (id.matches_parameter(PresetOptions::print_option)) {
+            i++; // skip the PrintOption argument
+            std::stringstream ss;
+            for (; i < argc && !Identifier::is_option(argv[i]); i++) {
+                // try to get the parameter's json value
+                BOOST_OUTCOME_TRY(auto&& value, set.get_param(Identifier::make_raw(argv[i])));
+                // print the name (or alias) and value
+                ss << "Option " << argv[i] << ":\n" << value << "\n";
+            }
+            // return after all values are printed
+            return mio::failure(StatusCode::OK, ss.str());
+        }
+    }
+    // main pass over all args to set options
+    int i = 1;
+    // handle parameter options that require values iteratively. assign given values or return an error
+    while (i < argc) {
+        const auto id_result = Identifier::parse(argv[i]);
+        // try to parse the first default_options.size() as arguments; afterwards, require an identifier
+        if (!id_result) {
+            // checking #defaults suffices, as non-option arguments are greedily collected into "arguments" below
+            if (i - 1 < static_cast<int>(default_options.size())) {
+                const auto& param_name = Identifier::make_raw(default_options[i - 1]);
+                BOOST_OUTCOME_TRY(set.set_param(param_name, std::string(argv[i])));
+
+                i++;
+                continue;
+            }
+            else {
+                return id_result.error();
+            }
+        }
+        const Identifier current_option(id_result.value());
+        i++; // go to first argument
+        // assert that the first argument is not an identifier (i.e. name or alias)
+        if (i == argc || Identifier::is_option(argv[i])) {
+            return mio::failure(mio::StatusCode::OutOfRange,
+                                "Missing value for option \"" + current_option.string + "\".");
+        }
+        // collect all argv's that are not identifiers and set i to the position of the next identifier
+        std::string arguments(argv[i]);
+        i++;
+        for (; (i < argc) && !Identifier::is_option(argv[i]); i++) {
+            // here space separated args are joined together. maybe a better way is to make users use 'ticks' to group
+            // their input.
+            arguments.append(" ").append(argv[i]);
+        }
+        // handle built-in options
+        if (current_option.matches_parameter(PresetOptions::read_from_json)) {
+            BOOST_OUTCOME_TRY(read_abstract_set_from_file(set, arguments));
+        }
+        else if (current_option.matches_parameter(PresetOptions::write_to_json)) {
+            BOOST_OUTCOME_TRY(write_abstract_set_to_file(set, arguments));
+        }
+        // (try to) set the parameter, to the value given by arguments
+        else {
+            BOOST_OUTCOME_TRY(set.set_param(current_option, arguments));
+        }
+    }
+    // check if required parameters were set, return an error if not
+    if (std::ranges::any_of(set.parameters(), [](auto&& p) {
+            return p.is_required();
+        })) {
+        std::stringstream ss;
+        ss << "Missing values for required parameter(s):\n";
+        for (const auto& p : set.parameters()) {
+            if (p.is_required() == true) {
+                ss << "  " << p.name();
+            }
+        }
+        ss << "\n"
+           << "Use \"" << executable_name << " --help\" for more info.\n";
+        return mio::failure(mio::StatusCode::InvalidValue, ss.str());
+    }
+    return mio::success();
+}
diff --git a/cpp/memilio/io/cli.h b/cpp/memilio/io/cli.h
index 5f6e17aeb9..f01713bb8e 100644
--- a/cpp/memilio/io/cli.h
+++ b/cpp/memilio/io/cli.h
@@ -17,10 +17,10 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-#ifndef IO_CLI_H_
-#define IO_CLI_H_
+#ifndef MIO_IO_CLI_H
+#define MIO_IO_CLI_H
 
-#include "memilio/config.h"
+#include "memilio/config.h" // needed for defining MEMILIO_HAS_JSONCPP
 
 #ifdef MEMILIO_HAS_JSONCPP
 
@@ -28,111 +28,47 @@
 #include "memilio/io/json_serializer.h"
 #include "memilio/utils/metaprogramming.h"
 #include "memilio/utils/parameter_set.h"
+#include "memilio/utils/string_literal.h"
+#include "memilio/utils/type_list.h"
 
+#include <iostream>
 #include <memory>
 #include <string>
-#include <sstream>
-#include <fstream>
-#include <iostream>
-#include <functional>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
 
 namespace mio
 {
 
-namespace details
-{
-
 namespace cli
 {
 
-// an empty struct used to pass and iterate through types
-template <class...>
-struct typelist {
-};
-
-/// @brief a "parameter" (no Type) for the help option
-struct Help {
-    static const std::string name()
-    {
-        return "help";
-    }
-    static const std::string alias()
-    {
-        return "h";
-    }
-    static const std::string description()
-    {
-        return "Show this dialogue and exit.";
-    }
-};
-
-/// @brief a "parameter" (no Type) for the print option option
-struct PrintOption {
-    static const std::string name()
-    {
-        return "print_option";
-    }
-    static const std::string description()
-    {
-        return "Use with parameter option name(s) without \"--\" as value(s). "
-               "Prints the current values of specified options in their correct json format, "
-               "then exits. Note that quotation marks may have to be escaped (\\\")";
-    }
-};
-
-/// @brief a "parameter" (no Type) for the json import option
-struct ReadFromJson {
-    static const std::string name()
-    {
-        return "read_from_json";
-    }
-    static const std::string description()
-    {
-        return "Takes a filepath as value. Reads and assigns parameter option values from the specified json file.";
-    }
-};
-
-/// @brief a "parameter" (no Type) for the json export option
-struct WriteToJson {
-    static const std::string name()
-    {
-        return "write_to_json";
-    }
-    static const std::string description()
-    {
-        return "Takes a filepath as value. Writes current values of all parameter options to the specified json file.";
-    }
-};
-
-/// @brief Type list of options included by default (i.e. non-parameter options).
-template <class... Others>
-struct PresetOptions : public typelist<Help, PrintOption, ReadFromJson, WriteToJson, Others...> {
-};
+namespace details
+{
 
-/// @brief A Field that gets the name of a Parameter
-template <class Parameter>
+/// @brief A Field that gets the name of a Parameter.
 struct Name {
-    template <class T = Parameter>
-    static const std::string get()
+    template <class Parameter>
+    static const std::string get(const Parameter& p)
     {
-        return T::name();
+        return p.name();
     }
 };
 
-/// @brief A Field that gets the alias of a Parameter, or an empty string if there is none
-template <class Parameter>
+/// @brief A Field that gets the alias of a Parameter, or an empty string if there is none.
 struct Alias {
     template <class T>
-    using alias_expr = decltype(T::alias());
+    using alias_expr = decltype(std::declval<T>().alias());
 
     template <class T>
     constexpr static bool has_alias_v = mio::is_expression_valid<alias_expr, T>::value;
 
-    template <class T = Parameter>
-    static const std::string get()
+    template <class Parameter>
+    static const std::string get(const Parameter& p)
     {
-        if constexpr (has_alias_v<T>) {
-            return T::alias();
+        if constexpr (has_alias_v<Parameter>) {
+            return p.alias();
         }
         else {
             return "";
@@ -140,20 +76,19 @@ struct Alias {
     }
 };
 
-/// @brief A Field that gets the description of a Parameter, or an empty string if there is none
-template <class Parameter>
+/// @brief A Field that gets the description of a Parameter, or an empty string if there is none.
 struct Description {
     template <class T>
-    using description_expr = decltype(T::description());
+    using description_expr = decltype(std::declval<T>().description());
 
     template <class T>
     constexpr static bool has_description_v = mio::is_expression_valid<description_expr, T>::value;
 
-    template <class T = Parameter>
-    static const std::string get()
+    template <class Parameter>
+    static const std::string get(const Parameter& p)
     {
-        if constexpr (has_description_v<T>) {
-            return T::description();
+        if constexpr (has_description_v<Parameter>) {
+            return p.description();
         }
         else {
             return "";
@@ -161,349 +96,602 @@ struct Description {
     }
 };
 
-/// @brief A Field that matches either name or alias when used as `NameOrAliasMatcher<T>::get() == a_string`.
-template <class Parameter>
-struct NameOrAliasMatcher {
-    static NameOrAliasMatcher get()
-    {
-        return NameOrAliasMatcher<Parameter>{};
-    }
-    bool operator==(const std::string& other) const
-    {
-        return *this == other.data();
-    }
-    bool operator==(const char* other) const
+/// @brief A Field that gets the required flag of a Parameter, or false if there is none.
+struct IsRequired {
+    template <class T>
+    using is_required_expr = decltype(std::declval<T>().is_required());
+
+    template <class T>
+    constexpr static bool has_is_required_v = is_expression_valid<is_required_expr, T>::value;
+
+    template <class Parameter>
+    constexpr static bool get(const Parameter& p)
     {
-        return Name<Parameter>::get() == other || (Alias<Parameter>::get() != "" && Alias<Parameter>::get() == other);
+        if constexpr (has_is_required_v<Parameter>) {
+            return p.is_required();
+        }
+        else {
+            return false;
+        }
     }
 };
 
-/// @brief An Identifier is a string used to identify an option. Defines what is considered a name or alias.
-class Identifier : public std::string
+/// @brief Struct containing all non-data members of a parameter. Serves as base for AbstractParameter.
+struct DatalessParameter {
+    std::string name, alias = "", description = "";
+    bool is_required = false;
+};
+
+/// @brief Subset of DatalessParameter, used to get user input in ParameterSetBuilder::add.
+struct OptionalFields {
+    std::string alias = "", description = "";
+    bool is_required = false;
+};
+
+/// @brief Different types of identifiers, determines the content and handling of the Identifier's string.
+enum class IdentifierType
 {
-public:
-    using std::string::string;
+    Name, // e.g. "--help"
+    Alias, // e.g. "-h"
+    Raw // either a name or alias without dashes, e.g. "help"
+};
 
-    /// @brief check if the identifier is a name option
-    inline bool is_name() const
+/**
+ * @brief An Identifier is a string used to identify a parameter option.
+ * This class defines what strings are considered a name or alias.
+ * To create an Identifier, either parse a command line argument or make a raw identifier from a known-good string.
+ */
+class Identifier
+{
+private:
+    /// @brief Basic constructor. Use via parse or make_raw.
+    Identifier(std::string str, IdentifierType t)
+        : string(std::move(str))
+        , type(t)
     {
-        return (size() > 2) && (substr(0, 2) == "--");
     }
 
-    /// @brief view only the name of the identifier
-    inline const char* get_name() const
+public:
+    /**
+     * @brief Create an Identifier from a command line argument.
+     * @param[in] str A string that is excpected to be an option.
+     * @return An Identifier if str is a valid option, an error if not.
+     */
+    static IOResult<Identifier> parse(const std::string& str)
     {
-        assert(is_name());
-        return data() + 2;
+        if (is_name(str)) {
+            return mio::success(Identifier(str, IdentifierType::Name));
+        }
+        else if (is_alias(str)) {
+            return mio::success(Identifier(str, IdentifierType::Alias));
+        }
+        else {
+            return mio::failure(mio::StatusCode::InvalidValue, "Expected an option, got \"" + str + "\".");
+        }
     }
 
-    /// @brief check if the identifier is an alias option
-    inline bool is_alias() const
+    /**
+     * @brief Create an Identifier from a known-good option.
+     * @param[in] str A string that is either a name or alias.
+     * @return A raw Identifier of the given string.
+     */
+    static Identifier make_raw(const std::string& raw_name)
     {
-        return (size() > 1) && (data()[0] == '-') && (data()[1] != '-');
+        return Identifier(raw_name, IdentifierType::Raw);
     }
 
-    /// @brief view only the alias of the identifier
-    inline const char* get_alias() const
+    /// @brief Check if a string is a name option.
+    static bool is_name(std::string_view unverified_id)
     {
-        assert(is_alias());
-        return data() + 1;
+        // check for two dashes and at least one more character
+        return (unverified_id.size() > 2) && (unverified_id[0] == '-' && unverified_id[1] == '-');
     }
 
-    /// @brief check if the identifier is either a name or an alias
-    inline bool is_option() const
+    /// @brief Check if a string is an alias option.
+    static bool is_alias(std::string_view unverified_id)
     {
-        return is_name() || is_alias();
+        // check for exactly one dash and at least one more non-dash character
+        return (unverified_id.size() > 1) && (unverified_id[0] == '-') && (unverified_id[1] != '-');
     }
 
-    /// @brief check if the identifier matches the Parameter
-    template <class Parameter>
-    inline bool matches_parameter() const
+    /// @brief Check if a string is either a name or alias option.
+    static bool is_option(std::string_view unverified_id)
     {
-        if (is_name()) { // match name without "--"
-            return Name<Parameter>::get() == substr(2);
-        }
-        else if (is_alias()) { // match alias without "-"
-            return Alias<Parameter>::get() == substr(1);
+        return is_name(unverified_id) || is_alias(unverified_id);
+    }
+
+    /// @brief Get a view of the underlying string, skipping any dashes.
+    inline const std::string_view strip() const
+    {
+        switch (type) {
+        case IdentifierType::Name:
+            return std::string_view{string.data() + 2, string.size() - 2};
+        case IdentifierType::Alias:
+            return std::string_view{string.data() + 1, string.size() - 1};
+        case IdentifierType::Raw:
+            return std::string_view{string};
         }
-        else { // not an option
-            return false;
+        assert(false && "Invalid IdentifierType");
+        // this return is practically inaccessible, but needed to avoid a "reached end of non-void function" warning
+        return std::string_view{};
+    }
+
+    /// @brief Test whether the identifier matches a given parameter by name or alias.
+    inline bool matches_parameter(const DatalessParameter& p) const
+    {
+        switch (type) {
+        case IdentifierType::Name:
+            return p.name == strip();
+        case IdentifierType::Alias:
+            return p.alias == strip();
+        case IdentifierType::Raw:
+            return (p.name == string) || (string.size() > 0 && p.alias == string);
         }
+        assert(false && "Invalid IdentifierType");
+        // this return is practically inaccessible, but needed to avoid a "reached end of non-void function" warning
+        return false;
     }
+
+    std::string string; ///< The underlying string, usually containing a command line argument.
+    IdentifierType type; ///< The type set by parse or make_raw.
+};
+
+/// @brief Static container holding all preset options. Used for matching input arguments and writing help text.
+struct PresetOptions {
+    const inline static DatalessParameter help{"help", "h", "Show this dialogue and exit.", false};
+
+    const inline static DatalessParameter print_option{
+        "print_option", "",
+        "Use with parameter option name(s) without \"--\" as value(s). Prints the current values of specified "
+        "options in their correct json format, then exits.",
+        false};
+
+    const inline static DatalessParameter read_from_json{
+        "read_from_json", "",
+        "Takes a filepath as value. Reads and assigns parameter option values from the specified json file.", false};
+
+    const inline static DatalessParameter write_to_json{
+        "write_to_json", "",
+        "Takes a filepath as value. Writes current values of all parameter options to the specified json file.", false};
+
+    const inline static std::vector<DatalessParameter> all_presets{help, print_option, read_from_json, write_to_json};
 };
 
-/// @brief check if the given non-identifier string matches the Parameter by name or alias
-template <class Parameter>
-inline bool name_matches_parameter(const std::string& name)
+/**
+ * @brief A class to make both compile-time and run-time parameters usable in the CLI.
+ * Data ownership is defined at runtime, so that it can be used as an interface for external parameter sets or directly
+ * as a data class. 
+ * Uses type erasure, so type information must be stored elsewhere for direct data access. 
+ */
+class AbstractParameter : public DatalessParameter
 {
-    return (Name<Parameter>::get() == name) || (name.size() > 0 && Alias<Parameter>::get() == name);
-}
+public:
+    /**
+     * @brief Create a parameter with type-erased data.
+     * @tparam Type The original type of the pointer given by "value".
+     * @param p Defines name, alias, description and is_required members of the parameter.
+     * @param value A shared pointer to the parameter value. The deleter defines whether this is owning or non-owning.
+     * @
+     */
+    template <class Type>
+    AbstractParameter(mio::Tag<Type>, const DatalessParameter& p, std::shared_ptr<void>&& value)
+        : DatalessParameter(p)
+        , m_data(value)
+        , m_serialize([](const std::shared_ptr<void>& param) -> IOResult<Json::Value> {
+            return mio::serialize_json(*static_cast<Type*>(param.get()));
+        })
+        , m_set(*set_impl<Type>)
+    {
+    }
 
-/// @brief Helper struct to make write_help_impl write a seperator between presets and other options.
-struct Seperator {
-    static const std::string name()
+    /**
+     * @brief Create a parameter with non-owning data pointer.
+     * Used when building an AbstractSet from mio::ParameterSet.
+     */
+    template <class Param>
+    AbstractParameter(mio::Tag<Param>, typename Param::Type& value)
+        : AbstractParameter(mio::Tag<typename Param::Type>{},
+                            DatalessParameter(Name::get(Param{}), Alias::get(Param{}), Description::get(Param{}),
+                                              IsRequired::get(Param{})),
+                            std::shared_ptr<void>(static_cast<void*>(&value), [](void*) {}))
     {
-        return "\rParameter Options:";
     }
-};
 
-/// @brief End recursion
-inline void write_help_impl(const typelist<>, std::ostream&)
-{
-}
+    /**
+     * @brief Copy another AbstractParameter.
+     * Used when building an AbstractSet from mio::cli::ParameterSet.
+     */
+    template <class Param>
+    AbstractParameter(mio::Tag<Param>, AbstractParameter& other)
+        : AbstractParameter(other)
+    {
+    }
 
-/// @brief Recursively write a line of the --help output for Parameter T
-template <class T, class... Ts>
-void write_help_impl(const typelist<T, Ts...>, std::ostream& os)
-{
-    // Max. space and offsets used to print everything nicely.
-    const size_t name_space         = 16; // reserved space for name
-    const size_t alias_space        = 4; // reserved space for alias
-    const size_t name_indent        = 4; // size of "  --"
-    const size_t alias_indent       = 3; // size of "  -"
-    const size_t description_indent = 2; // size of "  "
-    // Get strings. Can assume name is not empty
-    const std::string name        = Name<T>::get();
-    const std::string description = Description<T>::get();
-    const std::string alias       = Alias<T>::get();
-    // Write name with "--" prefix and "  " indent
-    os << "  --" << name;
-    if (description.size() > 0 || alias.size() > 0) {
-        if (name.size() <= name_space) {
-            os << std::string(name_space - name.size(), ' ');
+    /**
+     * @brief Retrieve the value of the parameter.
+     * Note that this function only fails if serialization fails, which is very unlikely.
+     * @return A Json representation of the parameter's value if successful, an error otherwise.
+     */
+    IOResult<Json::Value> get() const
+    {
+        auto json_result = m_serialize(m_data);
+        if (json_result) {
+            return json_result;
         }
         else {
-            os << "\n" << std::string(name_space + name_indent, ' ');
+            std::string msg = "While getting \"" + name() + "\": " + json_result.error().message();
+            return mio::failure(json_result.error().code(), msg);
         }
     }
-    // Write alias (if available) with "-" prefix and "  " indent
-    size_t space = std::max<size_t>(alias_space - alias.size(), 0);
-    if (alias.size() > 0) {
-        os << "  -" << alias;
+
+    /**
+     * @brief Set the value of the parameter.
+     * @param[in] value A Json representation of the new value.
+     * @return Nothing if successful, an error otherwise.
+     */
+    IOResult<void> set(const Json::Value& value)
+    {
+        return m_set(m_data, name(), value);
     }
-    else {
-        space += alias_indent;
+
+    /**
+     * @brief Access to the DatalessParameter members mirroring a mio::ParameterSet parameter.
+     * @{
+     */
+    const std::string& name() const
+    {
+        return DatalessParameter::name;
     }
-    // Write description (if available) and end line indentation
-    if (description.size() > 0) {
-        os << std::string(space + description_indent, ' ') << description;
+    const std::string& alias() const
+    {
+        return DatalessParameter::alias;
     }
-    os << "\n";
-    // Write next entry
-    write_help_impl(typelist<Ts...>(), os);
-}
-
-/**
- * @brief Writes the output for the --help option.
- * @param[in] executable_name Name of the executable. Usually argv[0] is a good choice.
- * @param[in] parameters A set of parameters.
- * @param[in] os Any instance of std::ostream.
- * @tparam T List of all parameters
- * @tparam Set A parameter set.
- */
-template <class... T, template <class...> class Set>
-void write_help(const std::string& executable_name, const Set<T...>& /* parameters */, std::ostream& os)
-{
-    // help text preamble
-    os << "Usage: " << executable_name << " <option> <value> ...\n"
-       << "Values must be entered as json values, i.e. the expression to the right of \"Name : \".\n"
-       << "Options:\n";
-    // print options recursively
-    write_help_impl(PresetOptions<Seperator, T...>(), os);
-}
+    const std::string& description() const
+    {
+        return DatalessParameter::description;
+    }
+    bool is_required() const
+    {
+        return DatalessParameter::is_required;
+    }
+    /** @} */
 
-/// @brief End recursion
-template <template <class> /*Field */ class, class Set>
-mio::IOResult<void> set_param_impl(const typelist<>, Set&, const char* name, const Json::Value& /* args */)
-{
-    return mio::failure(mio::StatusCode::KeyNotFound, "No such option \"" + std::string(name) + "\".");
-    // end recusrion
-}
+    /// @brief Access the raw data. Must be casted to the original type for safe usage.
+    void* data()
+    {
+        return m_data.get();
+    }
 
-/// @brief Set the parameter given by name (or alias) to the json value given by args.
-template <template <class> class Field, class T, class... Ts, class Set>
-mio::IOResult<void> set_param_impl(const typelist<T, Ts...>, Set& parameters, const char* name, const Json::Value& args)
-{
-    if (Field<T>::get() == name) {
+private:
+    /// @brief Implementation for the set method, consisting of deserializing and assigning the Json value.
+    template <class Type>
+    static IOResult<void> set_impl(std::shared_ptr<void>& param, const std::string& name, const Json::Value& value)
+    {
+        mio::unused(param); // prevent a "set, but unused" compiler warning
         // deserialize the json value to the parameter's type, then assign it
-        auto result = mio::deserialize_json(args, mio::Tag<typename T::Type>());
-        if (result) {
-            // assign the result to the parameter
-            parameters.template get<T>() = result.value();
+        auto param_result = mio::deserialize_json(value, mio::Tag<Type>());
+        if (param_result) {
+            // assign the json to the parameter
+            *(static_cast<Type*>(param.get())) = std::move(param_result.value());
             return mio::success();
         }
         else { // deserialize failed
             // insert more information to the error message
-            std::string msg = "While setting \"" + std::string(name) + "\": " + result.error().message();
-            return mio::failure(result.error().code(), msg);
+            std::string msg = "While setting \"" + name + "\": " + param_result.error().message();
+            return mio::failure(param_result.error().code(), msg);
         }
     }
-    else {
-        // try next parameter
-        return set_param_impl<Field>(typelist<Ts...>(), parameters, name, args);
-    }
-}
 
-/**
- * @brief Set the parameter given by identifer to the json value given by args.
- *
- * The identifier must start with either "--" if it is a parameter's name, or with "-" if it is an alias.
- * The function then recursively tries to match each parameter by this Field, and sets it accordningly.
- *
- * @param[in, out] parameters The set containing the parameter to set.
- * @param[in] identifier The identifier of the parameter.
- * @param[in] args Json value to be convertet to the matching parameter's type.
- * @tparam T List of all parameters.
- * @tparam Set A parameter set.
- * @return Nothing if successfull, an error code otherwise.
- */
-template <class... T, template <class...> class Set>
-mio::IOResult<void> set_param(Set<T...>& parameters, const Identifier& identifier, const Json::Value& args)
+    std::shared_ptr<void> m_data; ///< An owning or non-owning pointer to the parameter value.
+    IOResult<Json::Value> (*m_serialize)(
+        const std::shared_ptr<void>&); ///< Function pointer with type info needed for get implementation.
+    IOResult<void> (*m_set)(std::shared_ptr<void>&, const std::string&,
+                            const Json::Value&); ///< Function pointer with type info needed for set implementation.
+};
+
+class AbstractSet
 {
-    // recursively match parameter either by name or alias and (try to) set it to args
-    if (identifier.is_name()) {
-        return set_param_impl<Name>(typelist<T...>(), parameters, identifier.get_name(), args);
-    }
-    else if (identifier.is_alias()) {
-        return set_param_impl<Alias>(typelist<T...>(), parameters, identifier.get_alias(), args);
+public:
+    using MapType = std::unordered_map<std::string_view, AbstractParameter&>;
+
+    /**
+     * @brief Create a new AbstractSet from a given set of parameters.
+     * Keep in mind that the AbstractSet usually uses the original set's storage, only acting as a type erased
+     * interface. Therefore the AbstractSet must not outlife the original set.
+     * This method verifies, that the set does not contain parameters with empty names, or duplicate names or aliases. 
+     * @tparam Set Either a class similar to mio::ParameterSet, or a vector of AbstractParameters.
+     * @param[in] parameter_set The original set of parameters. Mind its lifetime!
+     * @return A new AbstractSet if the parameters are valid, an error otherwise.
+     */
+    template <class Set>
+    static IOResult<AbstractSet> build(Set& parameter_set)
+    {
+        AbstractSet set(parameter_set);
+        BOOST_OUTCOME_TRY(fill_maps(set));
+        return mio::success(std::move(set));
     }
-    else {
-        return mio::failure(mio::StatusCode::KeyNotFound, "Expected an option, got \"" + identifier + "\".");
+
+    /**
+     * @brief Get a parameter's value.
+     * @param[in] id An Identifier matching the parameter to get.
+     * @return The parameter's value in Json representation if successful, an error otherwise.
+     */
+    IOResult<Json::Value> get_param(const Identifier& id)
+    {
+        auto param = find(id);
+        if (!param) {
+            return IOResult<Json::Value>(param.error().code(), "Could not get parameter: " + param.error().message());
+        }
+        else {
+            return param.value()->second.get();
+        }
     }
-}
 
-/**
- * @brief Set the parameter given by identifier to the json value given by args.
- *
- * The identifier must start with either "--" if it is a parameter's name, or with "-" if it is an alias.
- * The function then recursively tries to match each parameter by this Field, and sets it accordningly.
- *
- * @param[in, out] parameters The set containing the parameter to set.
- * @param[in] identifier The identifier of the parameter.
- * @param[in] args String containing a json value to be converted to the matching parameter's type.
- * @tparam T List of all parameters.
- * @tparam Set A parameter set.
- * @return Nothing if successfull, an error code otherwise.
- */
-template <class... T, template <class...> class Set>
-mio::IOResult<void> set_param(Set<T...>& parameters, const Identifier& identifier, const std::string& args)
-{
-    // read json value from args, then pass it to set_param(..., Json::Value)
-    Json::Value js;
-    std::string errors;
-    Json::CharReaderBuilder builder;
-    const std::unique_ptr<Json::CharReader> parser(builder.newCharReader());
-    parser->parse(args.c_str(), args.c_str() + args.size(), &js, &errors);
-    return set_param(parameters, identifier, js);
-}
+    /**
+     * @brief Set a parameter's value.
+     * @param[in] id An Identifier matching the parameter to be set.
+     * @param[in] args A string containing a Json representation of the new value.
+     * @return Nothing if successful, an error otherwise.
+     */
+    IOResult<void> set_param(const Identifier& id, const std::string& args)
+    {
+        Json::Value js;
+        std::string errors;
+        Json::CharReaderBuilder builder;
+        const std::unique_ptr<Json::CharReader> parser(builder.newCharReader());
+        parser->parse(args.c_str(), args.c_str() + args.size(), &js, &errors);
+        return set_param(id, js);
+    }
+
+    /**
+     * @brief Set a parameter's value.
+     * @param[in] id An Identifier matching the parameter to be set.
+     * @param[in] value The new value for the parameter in Json representation.
+     * @return Nothing if successful, an error otherwise.
+     */
+    IOResult<void> set_param(const Identifier& id, const Json::Value& value)
+    {
+        auto param = find(id);
+        if (!param) {
+            return IOResult<void>(param.error().code(), "Could not set parameter: " + param.error().message());
+        }
+        else {
+            param.value()->second.DatalessParameter::is_required = false; // mark as set
+            return param.value()->second.set(value);
+        }
+    }
 
-/// @brief End recursion.
-template <class Set>
-mio::IOResult<Json::Value> get_param_impl(typelist<>, Set&, const std::string& name)
-{
-    return mio::failure(mio::StatusCode::KeyNotFound, "No such option \"" + name + "\".");
-}
+    /// @brief Test if the set contains an item matching the given id.
+    bool contains(const Identifier& id)
+    {
+        return static_cast<bool>(find(id));
+    }
 
-/// @brief Get the value of the parameter specified by name.
-template <class T, class... Ts, class Set>
-mio::IOResult<Json::Value> get_param_impl(typelist<T, Ts...>, Set& parameters, const std::string& name)
-{
-    if (name_matches_parameter<T>(name)) {
-        return mio::serialize_json(parameters.template get<T>());
+    /**
+     * @brief Access all AbstractParameters.
+     * @{
+     */
+    std::vector<AbstractParameter>& parameters()
+    {
+        return m_parameters;
     }
-    else {
-        return get_param_impl(typelist<Ts...>(), parameters, name);
+    const std::vector<AbstractParameter>& parameters() const
+    {
+        return m_parameters;
     }
-}
+    /** @} */
 
-/**
- * @brief Get the parameter given by name.
- * @param[in] parameters The set containing the parameter to get.
- * @param[in] name The name (or alias) of the parameter.
- * @tparam T List of all parameters.
- * @tparam Set A parameter set.
- * @return The json value of the parameter if successfull, an error code otherwise.
- */
-template <class... T, template <class...> class Set>
-mio::IOResult<Json::Value> get_param(Set<T...>& parameters, const std::string& name)
-{
-    return get_param_impl(typelist<T...>(), parameters, name);
-}
+private:
+    /// @brief Do not allow creating sets without build method.
+    AbstractSet() = default;
+
+    /// @brief Construct AbstractSet with non-owning Parameters from mio::ParameterSet or similar.
+    template <class... T, template <class...> class Set>
+    AbstractSet(Set<T...>& parameter_set)
+        : m_parameters(std::vector{AbstractParameter(mio::Tag<T>{}, parameter_set.template get<T>())...})
+    {
+    }
 
-/// @brief Helper struct to provide the correct version of verify() at compile time.
-struct OptionVerifier {
-    template <template <class T> class Field, class T>
-    using is_required = std::is_same<Field<T>, Name<T>>;
+    /// @brief Construct a set directly from a vector of AbstractParameter%s.
+    AbstractSet(std::vector<AbstractParameter>& parameters)
+        : m_parameters(parameters)
+    {
+    }
 
-    template <template <class> class Field, class OptionA, class OptionB>
-    inline static void verify()
+    /**
+     * @brief Obtain a reference to a parameter matching the given Identifier.
+     * Uses maps instead of linear search. Checks the potentially smaller alias map first, then the name map.
+     * @param[in] id An Identifier.
+     * @return A map iterator if a matching parameter was found, an error otherwise.
+     */
+    IOResult<MapType::iterator> find(const Identifier& id)
     {
-        const auto field_a = Field<OptionA>::get();
-        const auto field_b = Field<OptionB>::get();
-        if constexpr (std::is_same<OptionA, OptionB>::value) {
-            assert((!is_required<Field, OptionA>::value || field_a != "") && "Option is missing required field.");
+        MapType::iterator param_itr = m_map_by_alias.find(id.strip());
+        if (param_itr != m_map_by_alias.end()) {
+            return mio::success(param_itr);
         }
-        else {
-            if constexpr (is_required<Field, OptionA>::value) {
-                assert((field_a != field_b) && "Options may not have duplicate fields. (field required)");
+        param_itr = m_map_by_name.find(id.strip());
+        if (param_itr != m_map_by_name.end()) {
+            return mio::success(param_itr);
+        }
+        return failure(mio::StatusCode::KeyNotFound, "No such option \"" + id.string + "\".");
+    }
+
+    /**
+     * @brief Initialize the maps of an abstract set used for finding parameters.
+     * Also verifies that there are no empty names, or duplicate names or aliases.
+     * @param[in] set A newly constructed set with all parameters and default-initialized (empty) maps.
+     * @return Nothing if parameters are good, error otherwise.
+     */
+    static IOResult<void> fill_maps(AbstractSet& set)
+    {
+        for (AbstractParameter& p : set.m_parameters) {
+            if (p.name().empty()) {
+                return mio::failure(mio::StatusCode::InvalidValue, "An option is missing a name.");
+            }
+            if (!set.m_map_by_name.insert({p.name(), p}).second) {
+                return mio::failure(mio::StatusCode::InvalidValue, "Options may not have duplicate names. "
+                                                                   "Found two instances of \"" +
+                                                                       p.name() + "\".");
             }
-            else {
-                assert((field_a == "" || field_b == "" || field_a != field_b) &&
-                       "Options may not have duplicate fields. (field optional)");
+            if (!p.alias().empty() && !set.m_map_by_alias.insert({p.alias(), p}).second) {
+                return mio::failure(mio::StatusCode::InvalidValue, "Options may not have duplicate aliases. "
+                                                                   "Found two instances of \"" +
+                                                                       p.alias() + "\".");
             }
         }
+        return mio::success();
     }
+
+    std::vector<AbstractParameter> m_parameters;
+    MapType m_map_by_name;
+    MapType m_map_by_alias;
 };
 
-/// @brief End recursion
-template <template <class> class Field, class... Ts>
-inline void verify_options_impl(typelist<Ts...>, typelist<>, typelist<Ts...>)
-{
-}
+/**
+ * @brief Writes the output for the --help option.
+ * @param[in] executable_name Name of the executable. Usually argv[0] is a good choice.
+ * @param[in] set A set of parameters.
+ * @param[in] os Any instance of std::ostream.
+ * @tparam T List of all parameters
+ * @tparam Set A parameter set.
+ */
+void write_help(const std::string& executable_name, const AbstractSet& set,
+                const std::vector<std::string>& default_options, std::ostream& os);
 
-/// @brief Restart recursion for the next A. Skips symmetric matches by reducing Ts.
-template <template <class> class Field, class T, class... Ts, class A, class... As>
-inline void verify_options_impl(typelist<T, Ts...>, typelist<A, As...>, typelist<>)
-{
-    // reduce both T- and A-list by the first element, reset B-list
-    verify_options_impl<Field>(typelist<Ts...>(), typelist<As...>(), typelist<Ts...>());
-}
+/// @brief Implementation of the CLI. See the main function below for details.
+mio::IOResult<void> command_line_interface(const std::string& executable_name, const int argc, char** argv,
+                                           cli::details::AbstractSet& parameters,
+                                           const std::vector<std::string>& default_options);
+
+/// @brief Helper to allow storing a StringLiteral in a TypeList.
+template <StringLiteral>
+struct NamedType;
 
 /**
- * @brief Recursively assert that the parameters do not contain duplicate or empty required Fields.
- * @tparam Field The field of the option to compare.
- * @tparam Ts List of options. Used to reset the list B, Bs if empty.
- * @tparam A Option to verify.
- * @tparam As Queue of options to be verified recursively.
- * @tparam B Second option to verify A against.
- * @tparam Bs Queue of other options to verify against.
+ * @brief A minimalistic class similar to mio::ParameterSet intended for use with the CLI.
+ * Uses StringLiteral%s to restore type information from AbstractParameter%s for outside access.
  */
-template <template <class> class Field, class... Ts, class A, class... As, class B, class... Bs>
-inline void verify_options_impl(typelist<Ts...>, typelist<A, As...>, typelist<B, Bs...>)
+template <class... Tags>
+class ParameterSet
 {
-    // TODO: make this a compile time check, e.g. with c++20's constexpr c_str
-    OptionVerifier::verify<Field, A, B>();
-    // reduce B-list by the first element
-    verify_options_impl<Field>(typelist<Ts...>(), typelist<A, As...>(), typelist<Bs...>());
-}
+    using Names = TypeList<type_at_index_t<0, Tags>...>;
+    using Types = TypeList<type_at_index_t<1, Tags>...>;
+
+public:
+    /**
+     * @brief Create a ParameterSet. Use the ParameterSetBuilder instead of calling this directly.
+     * @param[in] parameters A vector of AbstractParameter%s holding their own data.
+     */
+    ParameterSet(std::vector<details::AbstractParameter>&& parameters)
+        : m_parameters(parameters)
+    {
+    }
+
+    /**
+     * @brief Access a parameter value by its name.
+     * @tparam Name The name of the parameter.
+     * @return A reference to the parameter's value.
+     */
+    template <mio::StringLiteral Name>
+    inline auto& get()
+    {
+        constexpr size_t parameter_index = index_of_type_v<details::NamedType<Name>, Names>;
+        using ReturnType                 = type_at_index_t<parameter_index, Types>;
+        return *static_cast<ReturnType*>(m_parameters[parameter_index].data());
+    }
+
+    /**
+     * @brief Direct access to a parameter onject. Only intended for building an AbstractSet in the CLI.
+     * @tparam Tag The Tag corresponding to a parameter.
+     * @return A reference to a parameter.
+     */
+    template <class Tag>
+    inline details::AbstractParameter& get()
+    {
+        constexpr size_t parameter_index = index_of_type_v<Tag, Tags...>;
+        return m_parameters[parameter_index];
+    }
+
+private:
+    std::vector<details::AbstractParameter> m_parameters; ///< Vector of parameters with ownership over their values.
+};
 
 /**
- * @brief Assert that no two Names or Aliases in the Set are the same, and that no name is empty.
- * @param[in] parameters Parameter set to verify.
- * @tparam T Lsit of all parameters.
- * @tparam Set A parameter set.
+ * @brief Write a parameter set to the specified filepath.
+ * @param[in] parameters An instance of Set.
+ * @param[in] filepath The file to write the parameters into. 
  */
-template <class... T, template <class...> class Set>
-void verify_options(Set<T...> /* parameters */)
-{
-    verify_options_impl<Name>(PresetOptions<T...>(), PresetOptions<T...>(), PresetOptions<T...>());
-    verify_options_impl<Alias>(PresetOptions<T...>(), PresetOptions<T...>(), PresetOptions<T...>());
-}
+mio::IOResult<void> write_abstract_set_to_file(mio::cli::details::AbstractSet& set, const std::string& filepath);
 
-} // namespace cli
+/**
+ * @brief Read parameters from the specified file into the given parameter set.
+ * @param[in, out] parameters An instance of Set<Parameters...>.
+ * @param[in] filepath The file to read the parameters from.
+ */
+mio::IOResult<void> read_abstract_set_from_file(mio::cli::details::AbstractSet& set, const std::string& filepath);
 
 } // namespace details
 
+/// @brief A builder for a parameter set to be used with the CLI, as direct construction of such a set is inconvenient.
+template <class... Params>
+class ParameterSetBuilder
+{
+    // make private constructor accessible independent of template arguments
+    template <class...>
+    friend class ParameterSetBuilder;
+
+public:
+    /// @brief Set up a builder for a parameter set that can be used with the CLI.
+    ParameterSetBuilder() = default;
+
+    /**
+     * @brief Add a new parameter to the builder. 
+     * Call this directly on a new builder or another add() call. Finalize with the build() method.
+     * Do not store intermediate results.
+     * Usage example:
+     * ```
+     * auto parameters = ParameterSetBuilder().add<"A">(1).add<"B">(2).build();
+     * ```
+     * @tparam Name The name of the new parameter as a StringLiteral. Must be unique in this set.
+     * @tparam Type The type of the new parameter value. Use simple types for better CLI usage.
+     * @param[in] initial_value An initial value for the parameter.
+     * @param[in] optionals Can be used to set alias, description and is_required. 
+     * @return Returns a builder object. Use add() on it to add more parameters, or use build() to get a parameter set.
+     */
+    template <mio::StringLiteral Name, class Type>
+    [[nodiscard]] inline auto add(Type&& initial_value, details::OptionalFields&& optionals = {}) &&
+    {
+        // since we get *this as rvalue, we can move the parameters
+        auto new_params = std::move(m_parameters);
+        // create a new owning data pointer, stored as void*
+        std::shared_ptr<void> data(new Type(initial_value), std::default_delete<Type>{});
+        // create
+        new_params.emplace_back(Tag<Type>{},
+                                details::DatalessParameter{std::string(Name), optionals.alias, optionals.description,
+                                                           optionals.is_required},
+                                std::move(data));
+        return ParameterSetBuilder<Params..., TypeList<details::NamedType<Name>, Type>>{std::move(new_params)};
+    }
+
+    /// @brief Finalize the builder and create a parameter set.
+    [[nodiscard]] inline mio::cli::details::ParameterSet<Params...> build() &&
+    {
+        return mio::cli::details::ParameterSet<Params...>(std::move(m_parameters));
+    }
+
+private:
+    /// @brief Private constructor used by "add".
+    ParameterSetBuilder(std::vector<details::AbstractParameter>&& parameters)
+        : m_parameters(std::move(parameters))
+    {
+    }
+
+    std::vector<details::AbstractParameter> m_parameters; ///< Vector of parameters, holding initial values.
+};
+
+} // namespace cli
+
 /**
  * @brief Write a parameter set to the specified filepath.
  * @param[in] parameters An instance of Set.
@@ -511,9 +699,10 @@ void verify_options(Set<T...> /* parameters */)
  * @tparam Set A parameter set.
  */
 template <class Set>
-IOResult<void> write_parameters_to_file(const Set& parameters, const std::string& filepath)
+IOResult<void> write_parameters_to_file(Set& parameters, const std::string& filepath)
 {
-    return mio::write_json(filepath, parameters);
+    BOOST_OUTCOME_TRY(auto&& set, cli::details::AbstractSet::build(parameters));
+    return write_abstract_set_to_file(set, filepath);
 }
 
 /**
@@ -526,18 +715,8 @@ IOResult<void> write_parameters_to_file(const Set& parameters, const std::string
 template <class... Parameters, template <class...> class Set>
 IOResult<void> read_parameters_from_file(Set<Parameters...>& parameters, const std::string& filepath)
 {
-    using namespace details::cli;
-    // read file into json value
-    auto json_result = mio::read_json(filepath);
-    if (!json_result) {
-        return mio::failure(json_result.error());
-    }
-    // set each parameter manually
-    for (auto itr = json_result.value().begin(); itr != json_result.value().end(); itr++) {
-        BOOST_OUTCOME_TRY(set_param_impl<details::cli::NameOrAliasMatcher>(typelist<Parameters...>{}, parameters,
-                                                                           itr.name().c_str(), *itr));
-    }
-    return mio::success();
+    BOOST_OUTCOME_TRY(auto&& set, cli::details::AbstractSet::build(parameters));
+    return read_abstract_set_from_file(set, filepath);
 }
 
 /**
@@ -549,110 +728,63 @@ IOResult<void> read_parameters_from_file(Set<Parameters...>& parameters, const s
  * The Set template argument is expected to work like mio::ParameterSet.
  * In particular, if not using mio::ParameterSet, the Set is required to
  * a) have a list of (parameter) types as template arguments itself, e.g. ParameterSet<TypeA, TypeB,...>,
- * b) where each type has a member `Type` and `static const std::string name()`,
+ * b) where each type has a member `static const std::string name()`,
  * c) and Set has a member function `template <class T> T::Type& get()`.
- * d) Set has to implement a serialize function (see [README](cpp/memilio/io/README.md)).
- * Optionally, each type may have an "alias" or "description" member of the same type as "name".
- * Each name, alias or description should be ASCII only and not contain any control characters.
+ * d) Each member stored in Set must be serializable and deserializable (see documentation).
+ * Optionally, each parameter may have an "alias" or "description" member of the same type as "name".
+ * Each name, alias or description should be ASCII only and not contain any control characters. Names and aliases must
+ * be unique.
+ * Optionally, each parameter may have "is_required" boolean member function. If any required parameter is not set by
+ * the given arguments, an error is returned.
+ *
+ * Important: Always check the result as follows, since it is used for all CLI output:
+ * ```
+ * auto result = mio::command_line_interface( ... );
+ * if (!result) {
+ *     std::cout << result.error().message();
+ *     return result.error().code().value();
+ * }
+ * ```
  *
  * @param[in] executable_name Name of the executable. Usually argv[0] from the main is a good choice.
  * @param[in] argc Argument count, must be the length of argv. Can be directly passed from main.
  * @param[in] argv Argument list for the Programm. Can be directly passed from main.
  * @param[in,out] parameters An instance of the parameter set.
- * @param[in] os Output stream to write to. Default: std::cout.
+ * @param[in] default_options Parameter names that allow setting parameter values with leading non-option arguments.
  * @tparam Set A parameter set.
- * @return Nothing if no errors occured, the error code otherwise.
+ * @return Nothing if no errors occured, the error code and message (including the help dialogue!) otherwise.
  */
 template <class Set>
 mio::IOResult<void> command_line_interface(const std::string& executable_name, const int argc, char** argv,
-                                           Set& parameters, std::ostream& os = std::cout)
+                                           Set& parameters, const std::vector<std::string>& default_options = {})
 {
-    using namespace mio::details::cli;
-    // make sure there are no duplicate names or aliases
-    verify_options(parameters);
-    // handle help option, scanning all argumemts before doing anything with them
-    for (int i = 1; i < argc; i++) {
-        if (Identifier(argv[i]).matches_parameter<Help>()) {
-            // print the help dialogue and exit
-            write_help(executable_name, parameters, os);
-            std::exit(0);
-        }
-    }
-    // handle print_option option, scanning all argumemts before doing anything with them
-    for (int i = 1; i < argc; i++) {
-        if (Identifier(argv[i]).matches_parameter<PrintOption>()) {
-            i++; // skip the PrintOption argument
-            for (; i < argc && !Identifier(argv[i]).is_option(); i++) {
-                // try to get the parameter's json value
-                BOOST_OUTCOME_TRY(auto&& value, get_param(parameters, argv[i]));
-                // print the name (or alias) and value
-                os << "Option " << argv[i] << ":\n" << value << "\n";
-            }
-            // exit after all values are printed
-            std::exit(0);
-        }
-    }
-    // handle parameter options that require values iteratively. assign given values or return an error
-    int i = 1;
-    while (i < argc) {
-        const Identifier identifier(argv[i]);
-        i++; // go to first argument
-        // assert that the first argument is not an identifier (i.e. name or alias)
-        if (i == argc || Identifier(argv[i]).is_option()) {
-            return mio::failure(mio::StatusCode::OutOfRange, "Missing value for option \"" + identifier + "\".");
-        }
-        // collect all argv's that are not identifiers and set i to the position of the next identifier
-        std::string arguments(argv[i]);
-        i++;
-        for (; (i < argc) && !Identifier(argv[i]).is_option(); i++) {
-            arguments.append(" ").append(argv[i]);
-        }
-        // handle built-in options
-        if (identifier.matches_parameter<ReadFromJson>()) {
-            BOOST_OUTCOME_TRY(read_parameters_from_file(parameters, arguments));
-        }
-        else if (identifier.matches_parameter<WriteToJson>()) {
-            BOOST_OUTCOME_TRY(write_parameters_to_file(parameters, arguments));
-        }
-        // (try to) set the parameter, to the value given by arguments
-        else {
-            BOOST_OUTCOME_TRY(set_param(parameters, identifier, arguments));
-        }
-    }
-    return mio::success();
+    // parse the parameters into an iterable format
+    BOOST_OUTCOME_TRY(auto&& set, cli::details::AbstractSet::build(parameters));
+    return cli::details::command_line_interface(executable_name, argc, argv, set, default_options);
 }
 
 /**
  * @brief A cli that takes json values and stores them in a parameter set.
- *
- * Note that the first element of argv will always be skipped, assuming it is the name of the executable
- * as called from the command line. executable_name simply allows to "clean up" this name, as it may contain a path.
- *
- * The Set template argument is expected to work like mio::ParameterSet.
- * In particular, if not using mio::ParameterSet, the Set is required to
- * a) have a list of (parameter) types as template arguments itself, e.g. ParameterSet<TypeA, TypeB,...>,
- * b) where each type has a member `Type` and `static const std::string name()`,
- * c) and Set has a member function `template <class T> T::Type& get()`.
- * d) Set has to implement a serialize function (see [README](cpp/memilio/io/README.md)).
- * Optionally, each type may have an "alias" or "description" member of the same type as "name".
- * Each name, alias or description should be ASCII only and not contain any control characters.
+ * 
+ * This overload creates a new parameter set instead of using an existing one.
+ * See the other overload for more details.
  *
  * @param[in] executable_name Name of the executable. Usually argv[0] from the main is a good choice.
  * @param[in] argc Argument count, must be the length of argv. Can be directly passed from main.
  * @param[in] argv Argument list for the Programm. Can be directly passed from main.
- * @param[in] os Output stream to write to. Default: std::cout.
- * @tparam Parameters A list of parameter types.
+ * @tparam Parameters A list of parameter tags. 
  * @tparam Set A parameter set template. Will be used as Set<Parameters...>. Default: mio::ParameterSet.
- * @return An instance of Set<Parameters...> if no errors occured, the error code otherwise.
+ * @return An instance of Set<Parameters...> if no errors occured, the error code and message otherwise.
  */
-template <class... Parameters, template <class...> class Set = ParameterSet>
+template <class... Parameters, template <class...> class Set = mio::ParameterSet>
 mio::IOResult<Set<Parameters...>> command_line_interface(const std::string& executable_name, const int argc,
-                                                         char** argv, std::ostream& os = std::cout)
+                                                         char** argv,
+                                                         const std::vector<std::string>& default_options = {})
 {
     static_assert(sizeof...(Parameters) != 0, "At least one Parameter is required.");
     // create a new parameter set, and pass it and all other arguments to the main cli function
     Set<Parameters...> parameters{};
-    auto result = command_line_interface(executable_name, argc, argv, parameters, os);
+    auto result = command_line_interface(executable_name, argc, argv, parameters, default_options);
     // check the result, return parameters if appropriate
     if (result) {
         return mio::IOResult<Set<Parameters...>>(mio::success(std::move(parameters)));
@@ -666,4 +798,4 @@ mio::IOResult<Set<Parameters...>> command_line_interface(const std::string& exec
 
 #endif // MEMILIO_HAS_JSONCPP
 
-#endif // IO_CLI_H_
\ No newline at end of file
+#endif // MIO_IO_CLI_H
diff --git a/cpp/memilio/utils/string_literal.h b/cpp/memilio/utils/string_literal.h
index 457da79e3a..adcaaf452c 100644
--- a/cpp/memilio/utils/string_literal.h
+++ b/cpp/memilio/utils/string_literal.h
@@ -115,6 +115,25 @@ struct StringLiteral {
     }
     /** @} */
 
+    /**
+     * @brief Compare two literals.
+     * @param[in] left, right The strings to compare. Operands can be StringLiteral%s or regular string literals.
+     * @return Whether both strings are the same.
+     * @{
+     */
+    template <size_type N>
+    friend constexpr auto operator==(const StringLiteral& left, const StringLiteral<N>& right)
+    {
+        return left.string_view() == right.string_view();
+    }
+    template <size_type N>
+    friend constexpr auto operator==(const StringLiteral& left, const value_type (&right)[N])
+    {
+        auto r = StringLiteral<N - 1>(right);
+        return left == r;
+    }
+    /** @} */
+
     value_type value[size() + 1] = {}; ///< Contains the actual characters. Access this through data() or string_view().
 };
 
diff --git a/cpp/tests/distributions_helpers.cpp b/cpp/tests/distributions_helpers.cpp
index cc1821e299..4f1ffe2c05 100644
--- a/cpp/tests/distributions_helpers.cpp
+++ b/cpp/tests/distributions_helpers.cpp
@@ -17,12 +17,24 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
+#include "distributions_helpers.h"
+#include "matchers.h"
+
 #include "memilio/utils/parameter_distributions.h"
-#include <distributions_helpers.h>
-#include <matchers.h>
+
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
+// define ctor and dtor to help speed up compilation of mocks
+// see http://google.github.io/googletest/gmock_cook_book.html#making-the-compilation-faster
+
+MockParameterDistribution::MockParameterDistribution()
+{
+}
+MockParameterDistribution::~MockParameterDistribution()
+{
+}
+
 void check_distribution(const mio::ParameterDistribution& dist, const mio::ParameterDistribution& dist_read)
 {
 
diff --git a/cpp/tests/distributions_helpers.h b/cpp/tests/distributions_helpers.h
index eba2e97c79..aacd6adae0 100644
--- a/cpp/tests/distributions_helpers.h
+++ b/cpp/tests/distributions_helpers.h
@@ -33,6 +33,9 @@ void check_distribution(const mio::ParameterDistribution& dist, const mio::Param
 class MockParameterDistribution
 {
 public:
+    MockParameterDistribution();
+    ~MockParameterDistribution();
+
     MOCK_METHOD(double, get_rand_sample, (), ());
 };
 //the second class is clonable etc. and forwards calls to a stable instance of the first class
diff --git a/cpp/tests/test_io_cli.cpp b/cpp/tests/test_io_cli.cpp
index d5559b3842..9bceac1523 100644
--- a/cpp/tests/test_io_cli.cpp
+++ b/cpp/tests/test_io_cli.cpp
@@ -17,21 +17,70 @@
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
-#include "memilio/config.h"
+#include "matchers.h"
 #include "memilio/io/cli.h"
+#include "memilio/io/io.h"
+#include "memilio/io/json_serializer.h"
 #include "temp_file_register.h"
-#include "utils.h"
 
 #ifdef MEMILIO_HAS_JSONCPP
 
 #include "gtest/gtest.h"
 #include "gmock/gmock.h"
 
+#include <memory>
 #include <sstream>
 #include <string>
 #include <vector>
 #include <list>
 
+namespace
+{
+
+class TestCLI : public ::testing::Test
+{
+public:
+    // allocates a char** argv, filled with the given values. arrays are freed during TearDown
+    std::pair<int, char**> make_argv(const std::vector<std::string>& values)
+    {
+        const int argc = static_cast<int>(values.size());
+        char** argv    = new char*[argc];
+        // create and copy each string
+        for (int i = 0; i < argc; i++) {
+            const auto n = values[i].size() + 1;
+            argv[i]      = new char[n];
+            for (size_t j = 0; j < n; j++) {
+                // make a manual strcpy, since msvc marks the function as unsafe
+                // (this is not a concern as this function is only used for making test parameters)
+                argv[i][j] = values[i][j];
+            }
+        }
+        m_args.push_back({argc, argv});
+        return m_args.back();
+    }
+
+    void TearDown() override
+    {
+        for (auto [argc, argv] : m_args) {
+            free_argv(argc, argv);
+        }
+        m_args.clear();
+    }
+
+private:
+    // deletes the char** created by make_argv
+    void free_argv(int argc, char** argv)
+    {
+        for (int i = 0; i < argc; i++) {
+            delete[] argv[i];
+            argv[i] = nullptr;
+        }
+        delete[] argv;
+    }
+
+    std::vector<std::pair<int, char**>> m_args;
+};
+
 struct A {
     using Type = double;
 
@@ -86,173 +135,232 @@ struct D {
     // const static std::string description()
 };
 
-struct NameCollision {
-    using Type = std::list<std::string>;
+struct RequiredA {
+    using Type = int;
     const static std::string name()
     {
-        return "A";
+        return "RequiredA";
     }
     // const static std::string alias()
     // const static std::string description()
-};
-
-struct AliasCollision {
-    using Type = std::list<std::string>;
-    const static std::string name()
+    static bool is_required()
     {
-        return "nonempty";
+        return true;
     }
-    const static std::string alias()
-    {
-        return "a";
-    }
-    // const static std::string description()
 };
 
-struct NoName {
-    using Type = std::list<std::string>;
+struct RequiredB {
+    using Type = int;
     const static std::string name()
     {
-        return "";
+        return "RequiredB";
     }
     // const static std::string alias()
     // const static std::string description()
+    static bool is_required()
+    {
+        return true;
+    }
 };
 
-// allocates a char** argv, filled with the given values. use free_argv when done. do not use this outside testing!
-char** make_argv(const std::vector<std::string>& values)
+using Params = mio::ParameterSet<A, B, C, D>;
+
+template <class T = char>
+mio::cli::details::AbstractParameter test_param(const char* name, const char* alias, T* value = nullptr)
 {
-    char** argv = new char*[values.size()];
-    // create and copy each string
-    for (size_t i = 0; i < values.size(); i++) {
-        const auto n = values[i].size() + 1;
-        argv[i]      = new char[n];
-        for (size_t j = 0; j < n; j++) {
-            // make a manual strcpy, since msvc marks the function as unsafe
-            // (this is not a concern as this function is only used for making test parameters)
-            argv[i][j] = values[i][j];
-        }
-    }
-    return argv;
+    return mio::cli::details::AbstractParameter(mio::Tag<T>{}, {name, alias}, std::shared_ptr<void>(value));
 }
 
-// deletes the char** created by make_argv
-void free_argv(char** argv, int argc)
-{
-    for (int i = 0; i < argc; i++) {
-        delete[] argv[i];
-        argv[i] = nullptr;
+struct ErrorSerializable {
+    void serialize(mio::JsonContext& c) const
+    {
+        c.set_error({mio::StatusCode::UnknownError, "Test"});
+    }
+
+    static mio::IOResult<ErrorSerializable> deserialize(mio::JsonContext&)
+    {
+        return mio::failure({mio::StatusCode::UnknownError, "Test"});
     }
-    delete[] argv;
+};
+
+} // namespace
+
+TEST_F(TestCLI, test_identifier)
+{
+    // check that parsing, stripping and matching behave as intended
+    using mio::cli::details::Identifier;
+    using mio::cli::details::IdentifierType;
+    mio::cli::details::DatalessParameter reference_parameter = {"A", "a"};
+    // case: parse a name option; expect success, type set to Name, matching ref., strip to ref. name
+    auto name_result = Identifier::parse("--A");
+    ASSERT_THAT(name_result, IsSuccess());
+    auto& name = name_result.value();
+    EXPECT_EQ(name.type, IdentifierType::Name);
+    EXPECT_EQ(name.strip(), reference_parameter.name);
+    EXPECT_TRUE(name.matches_parameter(reference_parameter));
+    // case: parse a alias option; expect success, type set to Alias, matching ref., strip to ref. alias
+    auto alias_result = mio::cli::details::Identifier::parse("-a");
+    auto& alias       = alias_result.value();
+    EXPECT_EQ(alias.type, IdentifierType::Alias);
+    EXPECT_EQ(alias.strip(), reference_parameter.alias);
+    EXPECT_TRUE(alias.matches_parameter(reference_parameter));
+    // case: parse raw name; expect failure
+    auto raw_result = Identifier::parse("A");
+    EXPECT_THAT(raw_result, IsFailure(mio::StatusCode::InvalidValue));
+    // case: make raw name; expect type set to Raw, matching ref., strip to ref. name
+    auto raw = Identifier::make_raw("A");
+    EXPECT_EQ(raw.type, IdentifierType::Raw);
+    EXPECT_EQ(raw.strip(), reference_parameter.name);
+    EXPECT_TRUE(raw.matches_parameter(reference_parameter));
+    // case: parse "obviously" invalid strings; expect failures
+    EXPECT_THAT(Identifier::parse(""), IsFailure(mio::StatusCode::InvalidValue));
+    EXPECT_THAT(Identifier::parse(" "), IsFailure(mio::StatusCode::InvalidValue));
+    EXPECT_THAT(Identifier::parse("-"), IsFailure(mio::StatusCode::InvalidValue));
+    EXPECT_THAT(Identifier::parse("--"), IsFailure(mio::StatusCode::InvalidValue));
 }
 
-using Params = mio::ParameterSet<A, B, C, D>;
-// using BadParams = mio::ParameterSet<A, CollisionA>;
-TEST(TestCLI, test_option_verifier)
+TEST_F(TestCLI, test_option_verification)
 {
-    mio::set_death_test_mode();
-
-    EXPECT_DEBUG_DEATH(mio::details::cli::verify_options(mio::ParameterSet<A, NameCollision>()),
-                       ".*Options may not have duplicate fields\\. \\(field required\\)");
-    EXPECT_DEBUG_DEATH(mio::details::cli::verify_options(mio::ParameterSet<A, AliasCollision>()),
-                       ".*Options may not have duplicate fields\\. \\(field optional\\)");
-    EXPECT_DEBUG_DEATH(mio::details::cli::verify_options(mio::ParameterSet<NoName>()),
-                       ".*Option is missing required field\\..*");
-    EXPECT_DEBUG_DEATH(
-        {
-            mio::details::cli::verify_options(Params());
-            assert(false && "DeathTestMessage");
-        },
-        "DeathTestMessage");
+    // check that the option verification, i.e. checking for duplicates and empty names, works correctly
+    using mio::cli::details::AbstractSet;
+    using mio::cli::details::Identifier;
+    std::vector<mio::cli::details::AbstractParameter> params;
+    // case: trivial list; expect success
+    auto build_result = AbstractSet::build(params);
+    EXPECT_THAT(print_wrap(build_result), IsSuccess());
+    // case: good names and aliases; expect success and correctly filled maps
+    params       = {test_param("A", "a"), test_param("B", ""), test_param("C", "c"), test_param("D", "")};
+    build_result = AbstractSet::build(params);
+    ASSERT_THAT(print_wrap(build_result), IsSuccess());
+    auto set = build_result.value();
+    EXPECT_TRUE(set.contains(Identifier::make_raw("A")));
+    EXPECT_TRUE(set.contains(Identifier::make_raw("B")));
+    EXPECT_TRUE(set.contains(Identifier::make_raw("C")));
+    EXPECT_TRUE(set.contains(Identifier::make_raw("D")));
+    EXPECT_TRUE(set.contains(Identifier::make_raw("a")));
+    EXPECT_TRUE(set.contains(Identifier::make_raw("c")));
+    EXPECT_FALSE(set.contains(Identifier::make_raw("E")));
+    EXPECT_FALSE(set.contains(Identifier::make_raw("")));
+    // case: alias collision; expect failure
+    params.push_back(test_param("E", "a"));
+    build_result = AbstractSet::build(params);
+    EXPECT_THAT(print_wrap(build_result), IsFailure(mio::StatusCode::InvalidValue));
+    params.pop_back();
+    // case: name collision; expect failure
+    params.push_back(test_param("A", "e"));
+    build_result = AbstractSet::build(params);
+    EXPECT_THAT(print_wrap(build_result), IsFailure(mio::StatusCode::InvalidValue));
+    params.pop_back();
+    // case: name empty; expect failure
+    params.push_back(test_param("", "e"));
+    build_result = AbstractSet::build(params);
+    EXPECT_THAT(print_wrap(build_result), IsFailure(mio::StatusCode::InvalidValue));
 }
 
-TEST(TestCLI, test_get_param)
+TEST_F(TestCLI, test_get_param)
 {
+    // check that get_param works
     Params p;
+    auto set = mio::cli::details::AbstractSet::build(p).value();
     const double AV{3.14159};
     const std::string BV{"BTestString"};
     // set params
     p.get<A>() = AV;
     p.get<B>() = BV;
     // test get by value
-    // A (with alias)
-    ASSERT_TRUE(mio::details::cli::get_param(p, "A").has_value());
-    EXPECT_EQ(mio::details::cli::get_param(p, "A").value(), AV);
-    ASSERT_TRUE(mio::details::cli::get_param(p, "a").has_value());
-    EXPECT_EQ(mio::details::cli::get_param(p, "a").value(), AV);
-    // B (without alias)
-    ASSERT_TRUE(mio::details::cli::get_param(p, "B").has_value());
-    EXPECT_EQ(mio::details::cli::get_param(p, "B").value(), BV);
-    EXPECT_FALSE(mio::details::cli::get_param(p, "b").has_value());
-    // D (default value)
-    ASSERT_TRUE(mio::details::cli::get_param(p, "D").has_value());
-    EXPECT_EQ(mio::details::cli::get_param(p, "D").value().size(), Json::Value::ArrayIndex(0)); // empty vector
-    // Errors
-    EXPECT_EQ(mio::details::cli::get_param(p, "NoName").error().formatted_message(),
-              "Key not found: No such option \"NoName\".");
-    EXPECT_EQ(mio::details::cli::get_param(p, "NoName").error().code(), mio::StatusCode::KeyNotFound);
+    // case: A with alias, expect success + value from name and alias
+    auto a_by_name  = mio::cli::details::Identifier::parse("--A").value();
+    auto a_by_alias = mio::cli::details::Identifier::parse("-a").value();
+    ASSERT_TRUE(set.get_param(a_by_name).has_value());
+    EXPECT_EQ(set.get_param(a_by_name).value(), AV);
+    ASSERT_TRUE(set.get_param(a_by_alias).has_value());
+    EXPECT_EQ(set.get_param(a_by_alias).value(), AV);
+    // case: B without alias, expect success + value from name, error from alias
+    auto b_by_name  = mio::cli::details::Identifier::make_raw("B");
+    auto b_by_alias = mio::cli::details::Identifier::make_raw("b");
+    ASSERT_TRUE(set.get_param(b_by_name).has_value());
+    EXPECT_EQ(set.get_param(b_by_name).value(), BV);
+    EXPECT_FALSE(set.get_param(b_by_alias).has_value());
+    // case: D with default value, expect success + empty vector from name
+    auto get_d_result = set.get_param(mio::cli::details::Identifier::make_raw("D"));
+    ASSERT_TRUE(get_d_result.has_value());
+    EXPECT_EQ(get_d_result.value().size(), Json::Value::ArrayIndex(0)); // empty vector
+    // case: invalid name, expect error
+    auto get_noname_result = set.get_param(mio::cli::details::Identifier::make_raw("NoName"));
+    EXPECT_EQ(get_noname_result.error().formatted_message(),
+              "Key not found: Could not get parameter: No such option \"NoName\".");
+    EXPECT_EQ(get_noname_result.error().code(), mio::StatusCode::KeyNotFound);
+    // case: error in serialize, expect error being forwarded
+    EXPECT_THAT(print_wrap(test_param<ErrorSerializable>("", "").get()), IsFailure(mio::StatusCode::UnknownError));
 }
 
-TEST(TestCLI, test_set_param)
+TEST_F(TestCLI, test_set_param)
 {
     Params p;
-    // set by name
-    EXPECT_TRUE(mio::details::cli::set_param(p, "--A", std::string("5.2")));
+    auto set = mio::cli::details::AbstractSet::build(p).value();
+    auto id  = mio::cli::details::Identifier::make_raw("A");
+    // use normally
+    EXPECT_THAT(print_wrap(set.set_param(id, std::string("5.2"))), IsSuccess());
     EXPECT_EQ(p.get<A>(), 5.2);
-    // set by alias
-    EXPECT_TRUE(mio::details::cli::set_param(p, "-a", std::string("2.7")));
-    EXPECT_EQ(p.get<A>(), 2.7);
-    // Errors
-    EXPECT_EQ(mio::details::cli::set_param(p, "--A", std::string("definitely a double")).error().formatted_message(),
-              "Invalid type: While setting \"A\": Json value is not a double.");
-    EXPECT_EQ(mio::details::cli::set_param(p, "NoName", std::string()).error().formatted_message(),
-              "Key not found: Expected an option, got \"NoName\".");
-    EXPECT_EQ(mio::details::cli::set_param(p, "--NoName", std::string()).error().formatted_message(),
-              "Key not found: No such option \"NoName\".");
+    // cause errors
+    auto result = set.set_param(id, std::string("definitely a double"));
+    EXPECT_THAT(print_wrap(result), IsFailure(mio::StatusCode::InvalidType));
+    EXPECT_EQ(result.error().formatted_message(), "Invalid type: While setting \"A\": Json value is not a double.");
+    result = set.set_param(mio::cli::details::Identifier::make_raw("NotAnOption"), std::string());
+    EXPECT_THAT(print_wrap(result), IsFailure(mio::StatusCode::KeyNotFound));
+    EXPECT_EQ(result.error().formatted_message(),
+              "Key not found: Could not set parameter: No such option \"NotAnOption\".");
 }
 
-TEST(TestCLI, test_write_help)
+TEST_F(TestCLI, test_write_help)
 {
-    mio::set_death_test_mode();
-
+    Params p;
+    auto set = mio::cli::details::AbstractSet::build(p).value();
     std::stringstream ss;
-    const std::string help =
-        "Usage: TestSuite <option> <value> ...\nValues must be entered as json values, i.e. the expression to the "
-        "right of \"Name : \".\nOptions:\n  --help              -h     Show this dialogue and exit.\n  --print_option  "
-        "           Use with parameter option name(s) without \"--\" as value(s). Prints the current values of "
-        "specified options in their correct json format, then exits. Note that quotation marks may have to be escaped "
-        "(\\\")\n  --read_from_json           Takes a filepath as value. Reads and assigns parameter option values "
-        "from the specified json file.\n  --write_to_json            Takes a filepath as value. Writes current values "
-        "of all parameter options to the specified json file.\n  --\rParameter Options:\n  --A                 -a     "
-        "This is A.\n  --B                        This is B. It has a needlessly long description that will most "
-        "probably not fit into a single line on your terminal window, unless maybe on an ultrawide display.\n  --C has "
-        "a name that is too long\n                      -c\n  --D\n";
+    const std::string help_header = "Usage: TestSuite <option> <value> ...\n";
+    const std::string help_header_with_defaults =
+        "Usage: TestSuite [A D] <option> <value> ...\n"
+        "Values of parameter options listed in [brackets] can be optionally entered in that order.\n";
+    const std::string help_body =
+        "All values must be entered as json values, i.e. the expression to the right of \"Name : \".\nNote that, when "
+        "entering values, quotation marks may have to be escaped (\\\").\nOptions:\n  --help              -h     Show "
+        "this dialogue and exit.\n  --print_option             Use with parameter option name(s) without \"--\" as "
+        "value(s). Prints the current values of specified options in their correct json format, then exits.\n  "
+        "--read_from_json           Takes a filepath as value. Reads and assigns parameter option values from the "
+        "specified json file.\n  --write_to_json            Takes a filepath as value. Writes current values of all "
+        "parameter options to the specified json file.\nParameter options:\n  --A                 -a     This is A.\n  "
+        "--B                        This is B. It has a needlessly long description that will most probably not fit "
+        "into a single line on your terminal window, unless maybe on an ultrawide display.\n  --C has a name that is "
+        "too long\n                      -c\n  --D\n";
     // call write help directly
-    mio::details::cli::write_help("TestSuite", Params(), ss);
-    EXPECT_EQ(ss.str(), help);
+    mio::cli::details::write_help("TestSuite", set, {}, ss);
+    EXPECT_EQ(ss.str(), help_header + help_body);
+    ss.str("");
+    ss.clear();
+    // call write help directly, with defaults
+    mio::cli::details::write_help("TestSuite", set, {"A", "D"}, ss);
+    EXPECT_EQ(ss.str(), help_header_with_defaults + help_body);
     // call cli with -h option
-    char c[] = "-h", *argv[2];
-    argv[1]  = c;
-    Params p;
-    EXPECT_EXIT((void)mio::command_line_interface("TestSuite", 2, argv, p, std::cerr), testing::ExitedWithCode(0),
-                testing::StrEq(help));
+    char c[]    = "-h", *argv[2];
+    argv[1]     = c;
+    auto result = mio::command_line_interface("TestSuite", 2, argv, p);
+    ASSERT_THAT(print_wrap(result), IsFailure(mio::StatusCode::OK));
+    EXPECT_EQ(result.error().code(), mio::StatusCode::OK);
+    EXPECT_EQ(result.error().message(), help_header + help_body);
 }
 
-TEST(TestCLI, test_print_options)
+TEST_F(TestCLI, test_print_options)
 {
-    mio::set_death_test_mode();
-
     const std::vector<std::string> args{"", "--print_option", "a", "D"};
-    const int argc = (int)args.size();
-    char** argv    = make_argv(args);
+    auto [argc, argv] = make_argv(args);
 
     Params p;
-    EXPECT_EXIT((void)mio::command_line_interface("TestSuite", argc, argv, p, std::cerr), testing::ExitedWithCode(0),
-                testing::StrEq("Option a:\n0.0\nOption D:\n[]\n"));
-    free_argv(argv, argc);
+    auto result = mio::command_line_interface("TestSuite", argc, argv, p);
+    ASSERT_THAT(print_wrap(result), IsFailure(mio::StatusCode::OK));
+    EXPECT_THAT(result.error().message(), "Option a:\n0.0\nOption D:\n[]\n");
 }
 
-TEST(TestCLI, test_import_export)
+TEST_F(TestCLI, test_import_export)
 {
     TempFileRegister file_register;
     auto tmpfile                = file_register.get_unique_path("TestCLI-%%%%-%%%%.json");
@@ -290,24 +398,75 @@ TEST(TestCLI, test_import_export)
     ofile << read_json;
     ofile.close();
     const std::vector<std::string> args{"", "--read_from_json", tmpfile, "--write_to_json", tmpfile};
-    const int argc = (int)args.size();
-    char** argv    = make_argv(args);
+    auto [argc, argv] = make_argv(args);
     ASSERT_TRUE(mio::command_line_interface("", argc, argv, p));
-    free_argv(argv, argc);
     ifile.open(tmpfile);
     content.assign(std::istreambuf_iterator<char>(ifile), std::istreambuf_iterator<char>());
     ifile.close();
     EXPECT_EQ(content, write_json);
 }
 
-TEST(TestCLI, test_command_line_interface)
+TEST_F(TestCLI, test_default_options)
+{
+    // go through all possible routes default options can go through
+    // generate argv
+    const std::vector<std::string> args{"", "3.4", "\"TestValue\"", "[0, 8, 15]", "[\"Hello \",\"World!\"]"};
+    auto [argc, argv] = make_argv(args);
+    const std::vector<std::string> default_options{A::name(), B::name(), C::name(), D::name()};
+    // case: set all params through defaults; expect success
+    auto result = mio::command_line_interface<A, B, C, D>("TestSuite", argc, argv, default_options);
+    ASSERT_THAT(print_wrap(result), IsSuccess());
+    // also verify (on a subset of params) that values are being set
+    EXPECT_EQ(result.value().get<A>(), 3.4);
+    ASSERT_EQ(result.value().get<D>().size(), 2);
+    // case: provide less params then defaults; expect success
+    const int reduced_argc = argc - 2;
+    result                 = mio::command_line_interface<A, B, C, D>("TestSuite", reduced_argc, argv, default_options);
+    EXPECT_THAT(print_wrap(result), IsSuccess());
+    EXPECT_EQ(result.value().get<A>(), 3.4);
+    ASSERT_EQ(result.value().get<D>().size(), 0); // not set this time
+    // case: use nonexistant param as default; expect failure (when verifying default options)
+    const std::vector<std::string> wrong_options{"NoName"};
+    EXPECT_THAT(print_wrap(mio::command_line_interface<A, B, C, D>("TestSuite", argc, argv, wrong_options)),
+                IsFailure(mio::StatusCode::KeyNotFound));
+    // case: provide more params then defaults; expect failure (when trying to parse identifier)
+    const std::vector<std::string> reduced_options{"A", "B"};
+    EXPECT_THAT(print_wrap(mio::command_line_interface<A, B, C, D>("TestSuite", argc, argv, reduced_options)),
+                IsFailure(mio::StatusCode::InvalidValue));
+    // missing case: pass invalid value; covered sufficiently through test_set_param
+}
+
+TEST_F(TestCLI, test_required_options)
+{
+    // go through all possible routes default options can go through
+    // generate argv
+    const std::vector<std::string> args_opt{"", "--RequiredA", "5", "--RequiredB", "2"};
+    const std::vector<std::string> args_def{"", "5", "2"};
+    auto [argc_opt, argv_opt] = make_argv(args_opt);
+    auto [argc_def, argv_def] = make_argv(args_def);
+    // case: set required params; expect success
+    EXPECT_THAT(print_wrap(mio::command_line_interface<RequiredA, RequiredB>("TestSuite", argc_opt, argv_opt)),
+                IsSuccess());
+    // case: set required params through default option; expect success
+    EXPECT_THAT(print_wrap(mio::command_line_interface<RequiredA, RequiredB>("TestSuite", argc_def, argv_def,
+                                                                             {"RequiredA", "RequiredB"})),
+                IsSuccess());
+    // case: don't set required params; expect failure
+    const int reduced_argc = argc_opt - 2;
+    const int no_argc      = 1;
+    EXPECT_THAT(print_wrap(mio::command_line_interface<RequiredA, RequiredB>("TestSuite", reduced_argc, argv_opt)),
+                IsFailure(mio::StatusCode::InvalidValue));
+    EXPECT_THAT(print_wrap(mio::command_line_interface<RequiredA, RequiredB>("TestSuite", no_argc, argv_opt)),
+                IsFailure(mio::StatusCode::InvalidValue));
+}
+
+TEST_F(TestCLI, test_command_line_interface)
 {
     // generate argv
     const std::vector<std::string> args{
         "",    "-a", "3.4", "--B", "\"TestValue\"",          "--C has a name that is too long",
         "[0,", "8,", "15]", "--D", "[\"Hello \",\"World!\"]"};
-    const int argc = (int)args.size();
-    char** argv    = make_argv(args);
+    auto [argc, argv] = make_argv(args);
     // trigger fail
     // by error in set_param
     EXPECT_FALSE(mio::command_line_interface<A>("TestSuite", argc, argv));
@@ -321,7 +480,7 @@ TEST(TestCLI, test_command_line_interface)
     // run cli normally
     auto result = mio::command_line_interface<A, B, C, D>("TestSuite", argc, argv);
     // check success
-    ASSERT_TRUE(result);
+    ASSERT_THAT(print_wrap(result), IsSuccess());
     Params p = result.value();
     // test values
     // A
@@ -337,8 +496,6 @@ TEST(TestCLI, test_command_line_interface)
     ASSERT_EQ(p.get<D>().size(), 2);
     EXPECT_EQ(p.get<D>().front(), "Hello ");
     EXPECT_EQ(p.get<D>().back(), "World!");
-    // deallocate argv
-    free_argv(argv, argc);
 }
 
 #endif // MEMILIO_HAS_JSONCPP

From 3c0fd5a98a322481245c2d5536c84e158d27cec2 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Wed, 17 Sep 2025 20:13:39 +0200
Subject: [PATCH 02/10] fix CI compilation

---
 cpp/memilio/io/cli.cpp | 7 +++++++
 cpp/memilio/io/cli.h   | 6 +++---
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/cpp/memilio/io/cli.cpp b/cpp/memilio/io/cli.cpp
index 82fb63c36b..9cd71f3cad 100644
--- a/cpp/memilio/io/cli.cpp
+++ b/cpp/memilio/io/cli.cpp
@@ -19,7 +19,12 @@
 */
 #include "memilio/io/cli.h"
 
+#ifdef MEMILIO_HAS_JSONCPP
+
+#include <ostream>
 #include <sstream>
+#include <string>
+#include <vector>
 
 /// @brief Part of write_help implementation. Writes the header with usage information and default options.
 void write_help_preamble(const std::string& executable_name, const std::vector<std::string>& default_options,
@@ -223,3 +228,5 @@ mio::IOResult<void> mio::cli::details::command_line_interface(const std::string&
     }
     return mio::success();
 }
+
+#endif // MEMILIO_HAS_JSONCPP
diff --git a/cpp/memilio/io/cli.h b/cpp/memilio/io/cli.h
index f01713bb8e..c16d832a55 100644
--- a/cpp/memilio/io/cli.h
+++ b/cpp/memilio/io/cli.h
@@ -280,7 +280,7 @@ class AbstractParameter : public DatalessParameter
         , m_serialize([](const std::shared_ptr<void>& param) -> IOResult<Json::Value> {
             return mio::serialize_json(*static_cast<Type*>(param.get()));
         })
-        , m_set(*set_impl<Type>)
+        , m_set(*AbstractParameter::set_impl<Type>)
     {
     }
 
@@ -291,8 +291,8 @@ class AbstractParameter : public DatalessParameter
     template <class Param>
     AbstractParameter(mio::Tag<Param>, typename Param::Type& value)
         : AbstractParameter(mio::Tag<typename Param::Type>{},
-                            DatalessParameter(Name::get(Param{}), Alias::get(Param{}), Description::get(Param{}),
-                                              IsRequired::get(Param{})),
+                            DatalessParameter{Name::get(Param{}), Alias::get(Param{}), Description::get(Param{}),
+                                              IsRequired::get(Param{})},
                             std::shared_ptr<void>(static_cast<void*>(&value), [](void*) {}))
     {
     }

From 998ef2df410f07e9acfaa218220439df76179f44 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Wed, 17 Sep 2025 20:44:09 +0200
Subject: [PATCH 03/10] More fixes for sanitizer and msvc

---
 cpp/examples/cli.cpp      |  2 +-
 cpp/memilio/io/cli.h      | 35 +++++++++++++++--------------------
 cpp/tests/test_io_cli.cpp |  3 ++-
 3 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/cpp/examples/cli.cpp b/cpp/examples/cli.cpp
index 5df8ada063..c2397f69b5 100644
--- a/cpp/examples/cli.cpp
+++ b/cpp/examples/cli.cpp
@@ -44,7 +44,7 @@ int main(int argc, char** argv)
     // the mio::cli::ParameterSet uses StringLiteral%s.
     auto parameters = mio::cli::ParameterSetBuilder()
                           .add<"Name", std::vector<std::string>>({"FirstName", "LastName"},
-                                                                 {"n", "Enter your name as list of strings.", true})
+                                                                 {"n", "Enter your name as list of strings.", false})
                           .add<"Age">(0, {"a", "Enter your age."})
                           .add<"Greeting">(std::string("Hello World!"),
                                            {.description = "Enter a custom greeting.", .is_required = false})
diff --git a/cpp/memilio/io/cli.h b/cpp/memilio/io/cli.h
index c16d832a55..dc9c4fe1f4 100644
--- a/cpp/memilio/io/cli.h
+++ b/cpp/memilio/io/cli.h
@@ -280,7 +280,21 @@ class AbstractParameter : public DatalessParameter
         , m_serialize([](const std::shared_ptr<void>& param) -> IOResult<Json::Value> {
             return mio::serialize_json(*static_cast<Type*>(param.get()));
         })
-        , m_set(*AbstractParameter::set_impl<Type>)
+        , m_set([](std::shared_ptr<void>& param, const std::string& name, const Json::Value& json) -> IOResult<void> {
+            mio::unused(param); // prevent a "set, but unused" compiler warning
+            // deserialize the json value to the parameter's type, then assign it
+            auto param_result = mio::deserialize_json(json, mio::Tag<Type>());
+            if (param_result) {
+                // assign the json to the parameter
+                *(static_cast<Type*>(param.get())) = std::move(param_result.value());
+                return mio::success();
+            }
+            else { // deserialize failed
+                // insert more information to the error message
+                std::string msg = "While setting \"" + name + "\": " + param_result.error().message();
+                return mio::failure(param_result.error().code(), msg);
+            }
+        })
     {
     }
 
@@ -363,25 +377,6 @@ class AbstractParameter : public DatalessParameter
     }
 
 private:
-    /// @brief Implementation for the set method, consisting of deserializing and assigning the Json value.
-    template <class Type>
-    static IOResult<void> set_impl(std::shared_ptr<void>& param, const std::string& name, const Json::Value& value)
-    {
-        mio::unused(param); // prevent a "set, but unused" compiler warning
-        // deserialize the json value to the parameter's type, then assign it
-        auto param_result = mio::deserialize_json(value, mio::Tag<Type>());
-        if (param_result) {
-            // assign the json to the parameter
-            *(static_cast<Type*>(param.get())) = std::move(param_result.value());
-            return mio::success();
-        }
-        else { // deserialize failed
-            // insert more information to the error message
-            std::string msg = "While setting \"" + name + "\": " + param_result.error().message();
-            return mio::failure(param_result.error().code(), msg);
-        }
-    }
-
     std::shared_ptr<void> m_data; ///< An owning or non-owning pointer to the parameter value.
     IOResult<Json::Value> (*m_serialize)(
         const std::shared_ptr<void>&); ///< Function pointer with type info needed for get implementation.
diff --git a/cpp/tests/test_io_cli.cpp b/cpp/tests/test_io_cli.cpp
index 9bceac1523..1f51100a3e 100644
--- a/cpp/tests/test_io_cli.cpp
+++ b/cpp/tests/test_io_cli.cpp
@@ -291,7 +291,8 @@ TEST_F(TestCLI, test_get_param)
               "Key not found: Could not get parameter: No such option \"NoName\".");
     EXPECT_EQ(get_noname_result.error().code(), mio::StatusCode::KeyNotFound);
     // case: error in serialize, expect error being forwarded
-    EXPECT_THAT(print_wrap(test_param<ErrorSerializable>("", "").get()), IsFailure(mio::StatusCode::UnknownError));
+
+    EXPECT_THAT(print_wrap(test_param("", "", new ErrorSerializable).get()), IsFailure(mio::StatusCode::UnknownError));
 }
 
 TEST_F(TestCLI, test_set_param)

From 2dc06805fe430d9281d6e8a67fdf747649f740ee Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Wed, 17 Sep 2025 21:40:07 +0200
Subject: [PATCH 04/10] Add a test for new builder and set

---
 cpp/tests/test_io_cli.cpp | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/cpp/tests/test_io_cli.cpp b/cpp/tests/test_io_cli.cpp
index 1f51100a3e..9dbc43243b 100644
--- a/cpp/tests/test_io_cli.cpp
+++ b/cpp/tests/test_io_cli.cpp
@@ -461,6 +461,31 @@ TEST_F(TestCLI, test_required_options)
                 IsFailure(mio::StatusCode::InvalidValue));
 }
 
+TEST_F(TestCLI, test_parameter_set_and_builder)
+{
+    // test that the builder and resulting set behave correctly
+    // create a set using the builder
+    auto parameters = mio::cli::ParameterSetBuilder().add<"A">(7).add<"B", double>(12, {"b", "desc", true}).build();
+    // check that the DatalessParameter members are set correctly
+    auto a = parameters.get<mio::TypeList<mio::cli::details::NamedType<"A">, int>>();
+    EXPECT_EQ(a.name(), "A");
+    EXPECT_EQ(a.alias(), "");
+    EXPECT_EQ(a.description(), "");
+    EXPECT_EQ(a.is_required(), false);
+    auto b = parameters.get<mio::TypeList<mio::cli::details::NamedType<"B">, double>>();
+    EXPECT_EQ(b.name(), "B");
+    EXPECT_EQ(b.alias(), "b");
+    EXPECT_EQ(b.description(), "desc");
+    EXPECT_EQ(b.is_required(), true);
+    // get and set values to test the parameter set
+    EXPECT_EQ(parameters.get<"A">(), 7);
+    parameters.get<"A">() = 2;
+    EXPECT_EQ(parameters.get<"A">(), 2);
+    EXPECT_EQ(parameters.get<"B">(), 12);
+    parameters.get<"B">() = 0.125;
+    EXPECT_EQ(parameters.get<"B">(), 0.125);
+}
+
 TEST_F(TestCLI, test_command_line_interface)
 {
     // generate argv

From d616d6853cb3e1cbc48617edc2f1d88d69e82340 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Tue, 7 Oct 2025 16:38:46 +0200
Subject: [PATCH 05/10] Review changes

---
 cpp/examples/cli.cpp      |  10 ++--
 cpp/memilio/io/cli.cpp    |   2 +-
 cpp/memilio/io/cli.h      |  35 +++++++----
 cpp/tests/test_io_cli.cpp |  13 +++--
 docs/source/cpp/io.rst    | 119 +++++++++++++++++++++++++++++++++++++-
 5 files changed, 156 insertions(+), 23 deletions(-)

diff --git a/cpp/examples/cli.cpp b/cpp/examples/cli.cpp
index c2397f69b5..5aaf68fed2 100644
--- a/cpp/examples/cli.cpp
+++ b/cpp/examples/cli.cpp
@@ -29,8 +29,8 @@ int main(int argc, char** argv)
     // Create a parameter set for the CLI using the builder. This defines the (parameter) options that the user can set
     // through the command line.
     //
-    // To add a parameter, you need to specify the name and type and pass an initial value. The type can sometimes be
-    // deduced from the initial value, so it can sometimes be omitted.
+    // To add() a parameter, you need to specify the name and type as template arguments, then pass an initial value.
+    // The type can sometimes be deduced from the initial value, so it can potentially be omitted.
     // After the initial value you can set some optional fields of the parameter:
     // - alias, which allows you to add a shorthand for setting values
     // - description, which contains details on, e.g., what the parameter does and what values are accepted.
@@ -39,7 +39,7 @@ int main(int argc, char** argv)
     // As a general rule, use simple types! The more complicated the type, the more complex is the Json representation
     // that the user has to input.
     //
-    // Instead of using the builder, you can also define and pass a mio::ParameterSet as paraneters.
+    // Instead of using the builder, you can also define and pass a mio::ParameterSet as parameters.
     // The main difference (for the CLI) is that the mio::ParameterSet uses struct names to "get" parameters, while
     // the mio::cli::ParameterSet uses StringLiteral%s.
     auto parameters = mio::cli::ParameterSetBuilder()
@@ -62,7 +62,7 @@ int main(int argc, char** argv)
     }
     // Now, do something with the parameters!
     // Note that the CLI only verifies that the user input is parsable, not plausible. If a parameter has certain value
-    // requirements, like "Age > 0", you must check this
+    // requirements, like "Age > 0", you must check this yourself.
     std::cout << parameters.get<"Greeting">() << "\n"
               << "Name: ";
     for (auto& name : parameters.get<"Name">()) {
@@ -72,4 +72,6 @@ int main(int argc, char** argv)
     if (parameters.get<"Age">() > 0) {
         std::cout << "Age: " << parameters.get<"Age">() << "\n";
     }
+
+    return 0;
 }
diff --git a/cpp/memilio/io/cli.cpp b/cpp/memilio/io/cli.cpp
index 9cd71f3cad..2ce16bb076 100644
--- a/cpp/memilio/io/cli.cpp
+++ b/cpp/memilio/io/cli.cpp
@@ -67,7 +67,7 @@ void write_help_parameter(const mio::cli::details::DatalessParameter& parameter,
         }
     }
     // Write alias (if available) with "-" prefix and "  " indent
-    size_t space = std::max<size_t>(alias_space - parameter.alias.size(), 0);
+    size_t space = parameter.alias.size() < alias_space ? alias_space - parameter.alias.size() : 0;
     if (parameter.alias.size() > 0) {
         os << "  -" << parameter.alias;
     }
diff --git a/cpp/memilio/io/cli.h b/cpp/memilio/io/cli.h
index dc9c4fe1f4..4de831824e 100644
--- a/cpp/memilio/io/cli.h
+++ b/cpp/memilio/io/cli.h
@@ -31,6 +31,7 @@
 #include "memilio/utils/string_literal.h"
 #include "memilio/utils/type_list.h"
 
+#include <cassert>
 #include <iostream>
 #include <memory>
 #include <string>
@@ -154,7 +155,7 @@ class Identifier
 public:
     /**
      * @brief Create an Identifier from a command line argument.
-     * @param[in] str A string that is excpected to be an option.
+     * @param[in] str A string that is expected to be an option.
      * @return An Identifier if str is a valid option, an error if not.
      */
     static IOResult<Identifier> parse(const std::string& str)
@@ -392,7 +393,7 @@ class AbstractSet
     /**
      * @brief Create a new AbstractSet from a given set of parameters.
      * Keep in mind that the AbstractSet usually uses the original set's storage, only acting as a type erased
-     * interface. Therefore the AbstractSet must not outlife the original set.
+     * interface. Therefore the AbstractSet must not outlive the original set.
      * This method verifies, that the set does not contain parameters with empty names, or duplicate names or aliases. 
      * @tparam Set Either a class similar to mio::ParameterSet, or a vector of AbstractParameters.
      * @param[in] parameter_set The original set of parameters. Mind its lifetime!
@@ -435,16 +436,18 @@ class AbstractSet
         Json::CharReaderBuilder builder;
         const std::unique_ptr<Json::CharReader> parser(builder.newCharReader());
         parser->parse(args.c_str(), args.c_str() + args.size(), &js, &errors);
-        return set_param(id, js);
+        // do not directly raise errors, to avoid hiding e.g. a "parameter not found"
+        return set_param(id, js, errors);
     }
 
     /**
      * @brief Set a parameter's value.
      * @param[in] id An Identifier matching the parameter to be set.
      * @param[in] value The new value for the parameter in Json representation.
+     * @param[in] parse_errors Optional argument with errors from parsing the Json value.
      * @return Nothing if successful, an error otherwise.
      */
-    IOResult<void> set_param(const Identifier& id, const Json::Value& value)
+    IOResult<void> set_param(const Identifier& id, const Json::Value& value, const std::string& parse_errors = "")
     {
         auto param = find(id);
         if (!param) {
@@ -452,7 +455,14 @@ class AbstractSet
         }
         else {
             param.value()->second.DatalessParameter::is_required = false; // mark as set
-            return param.value()->second.set(value);
+            // try to set the value. append parsing errors if not successful
+            IOResult<void> result = param.value()->second.set(value);
+            if (result || parse_errors.empty()) {
+                return result;
+            }
+            else {
+                return mio::failure(result.error().code(), result.error().message() + "\n" + parse_errors);
+            }
         }
     }
 
@@ -509,7 +519,7 @@ class AbstractSet
         if (param_itr != m_map_by_name.end()) {
             return mio::success(param_itr);
         }
-        return failure(mio::StatusCode::KeyNotFound, "No such option \"" + id.string + "\".");
+        return mio::failure(mio::StatusCode::KeyNotFound, "No such option \"" + id.string + "\".");
     }
 
     /**
@@ -657,16 +667,17 @@ class ParameterSetBuilder
     template <mio::StringLiteral Name, class Type>
     [[nodiscard]] inline auto add(Type&& initial_value, details::OptionalFields&& optionals = {}) &&
     {
+        using ValueType = std::decay_t<Type>; // get base type in case Type was deduced and is e.g. const or &
         // since we get *this as rvalue, we can move the parameters
         auto new_params = std::move(m_parameters);
         // create a new owning data pointer, stored as void*
-        std::shared_ptr<void> data(new Type(initial_value), std::default_delete<Type>{});
-        // create
-        new_params.emplace_back(Tag<Type>{},
+        std::shared_ptr<void> data(new ValueType(initial_value), std::default_delete<ValueType>{});
+        // create a new abstract parameter, then move all parameters to a new builder
+        new_params.emplace_back(Tag<ValueType>{},
                                 details::DatalessParameter{std::string(Name), optionals.alias, optionals.description,
                                                            optionals.is_required},
                                 std::move(data));
-        return ParameterSetBuilder<Params..., TypeList<details::NamedType<Name>, Type>>{std::move(new_params)};
+        return ParameterSetBuilder<Params..., TypeList<details::NamedType<Name>, ValueType>>{std::move(new_params)};
     }
 
     /// @brief Finalize the builder and create a parameter set.
@@ -743,7 +754,7 @@ IOResult<void> read_parameters_from_file(Set<Parameters...>& parameters, const s
  *
  * @param[in] executable_name Name of the executable. Usually argv[0] from the main is a good choice.
  * @param[in] argc Argument count, must be the length of argv. Can be directly passed from main.
- * @param[in] argv Argument list for the Programm. Can be directly passed from main.
+ * @param[in] argv Argument list for the programm. Can be directly passed from main.
  * @param[in,out] parameters An instance of the parameter set.
  * @param[in] default_options Parameter names that allow setting parameter values with leading non-option arguments.
  * @tparam Set A parameter set.
@@ -766,7 +777,7 @@ mio::IOResult<void> command_line_interface(const std::string& executable_name, c
  *
  * @param[in] executable_name Name of the executable. Usually argv[0] from the main is a good choice.
  * @param[in] argc Argument count, must be the length of argv. Can be directly passed from main.
- * @param[in] argv Argument list for the Programm. Can be directly passed from main.
+ * @param[in] argv Argument list for the programm. Can be directly passed from main.
  * @tparam Parameters A list of parameter tags. 
  * @tparam Set A parameter set template. Will be used as Set<Parameters...>. Default: mio::ParameterSet.
  * @return An instance of Set<Parameters...> if no errors occured, the error code and message otherwise.
diff --git a/cpp/tests/test_io_cli.cpp b/cpp/tests/test_io_cli.cpp
index 9dbc43243b..1b70f67681 100644
--- a/cpp/tests/test_io_cli.cpp
+++ b/cpp/tests/test_io_cli.cpp
@@ -120,9 +120,12 @@ struct C {
     }
     const static std::string alias()
     {
-        return "c";
+        return "c has a long alias";
+    }
+    const static std::string description()
+    {
+        return "C.";
     }
-    // const static std::string description()
 };
 
 struct D {
@@ -306,7 +309,9 @@ TEST_F(TestCLI, test_set_param)
     // cause errors
     auto result = set.set_param(id, std::string("definitely a double"));
     EXPECT_THAT(print_wrap(result), IsFailure(mio::StatusCode::InvalidType));
-    EXPECT_EQ(result.error().formatted_message(), "Invalid type: While setting \"A\": Json value is not a double.");
+    EXPECT_EQ(result.error().formatted_message(),
+              "Invalid type: While setting \"A\": Json value is not a double.\n"
+              "* Line 1, Column 1\n  Syntax error: value, object or array expected.\n");
     result = set.set_param(mio::cli::details::Identifier::make_raw("NotAnOption"), std::string());
     EXPECT_THAT(print_wrap(result), IsFailure(mio::StatusCode::KeyNotFound));
     EXPECT_EQ(result.error().formatted_message(),
@@ -332,7 +337,7 @@ TEST_F(TestCLI, test_write_help)
         "parameter options to the specified json file.\nParameter options:\n  --A                 -a     This is A.\n  "
         "--B                        This is B. It has a needlessly long description that will most probably not fit "
         "into a single line on your terminal window, unless maybe on an ultrawide display.\n  --C has a name that is "
-        "too long\n                      -c\n  --D\n";
+        "too long\n                      -c has a long alias  C.\n  --D\n";
     // call write help directly
     mio::cli::details::write_help("TestSuite", set, {}, ss);
     EXPECT_EQ(ss.str(), help_header + help_body);
diff --git a/docs/source/cpp/io.rst b/docs/source/cpp/io.rst
index 53b063ebcc..3697499ee7 100644
--- a/docs/source/cpp/io.rst
+++ b/docs/source/cpp/io.rst
@@ -36,10 +36,24 @@ The command line interface
 
 We provide a function ``mio::command_line_interface`` in the header ``memilio/io/cli.h``, that can be used to write to
 or read from a parameter set. It can take parameters from command line arguments (i.e. the content of ``argv`` in the
-main function), and assign them to or get them from a ``mio::ParameterSet``. A small example can be seen in
+main function), and assign them to or get them from a ``mio::ParameterSet``. If the parameter set is only used for the
+CLI, make use of the ``mio::cli::ParameterSetBuilder``. A small example can be seen in
 `cpp/examples/cli.cpp <https://github.com/SciCompMod/memilio/blob/main/cpp/examples/cli.cpp>`_.
 
-The command line interface (CLI) provides some non-parameter options listed below.
+.. note::
+
+    The CLI communicates using the error message in its result. Hence, all dialogue, including the help text, is
+    passed through the return value. Use the following code snippet to correctly return error codes and messages:
+
+    .. code-block:: cpp
+
+        auto result = mio::command_line_interface(argv[0], argc, argv, parameters);
+        if (!result) {
+            std::cout << result.error().message();
+            return result.error().code().value();
+        }
+
+The command line interface (CLI) provides some built-in options, listed below.
 
 ====================== =====================================
 Name  (Alias)          Description
@@ -68,6 +82,107 @@ followed by the value that should be assigned (reference ``--print_option``). Va
 corresponding to the Type of the parameter. Note that some characters may need to be escaped or quoted. For example, the
 JSON string ``"some string"`` must be entered as ``\\"some string\\"`` or ``'"some string"'``.
 
+
+Feature overview
+~~~~~~~~~~~~~~~~
+
+Here we briefly list available features of the CLI:
+
+- Built-in options (see table above).
+
+- Can be used with any ``ParameterSet``, as long as all parameters are (de)serializable.
+
+- Default options: As an optional parameter to the CLI function, you can pass a list of parameter names. The
+  first command line arguments (after the program name) are passed to these parameters as values. For example:
+
+  .. code:: cpp
+
+      auto result = mio::command_line_interface("example-programm", argc, argv, parameters, {"Path", "N"});
+
+  Now, calling ``example-programm /path/to/something 5`` is equivalent to
+  ``example-programm --Path /path/to/something --N 5``.
+  Make sure to add quotes to values that contain spaces! 
+
+- Required parameters: The CLI checks that all required parameters are set, and returns an error if some were not set.
+  This can be used, e.g., if a program requires a path to be set. Check out the next section to learn how to mark a
+  parameter as required.
+
+
+Parameters and ParameterSetBuilder
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The ``mio::cli::ParameterSetBuilder`` can be used to create parameters specifically for usage with the CLI. For general
+purpose parameters, check out ``mio::ParameterSet``.
+
+In the following example, we create a ``mio::cli::ParameterSet`` with two parameters. One minimal parameter called "A"
+of type ``int`` with default value 5, and a parameter called "B" of type ``double`` with value 2.5, that uses all
+optional features (alias, description, and the required flag).
+
+.. code-block:: cpp
+
+  auto parameters = mio::cli::ParameterSetBuilder()
+                        .add<"A">(5)
+                        .add<"B", double>(2.5, {.alias="b", .description="This is a description.", .is_required=true})
+                        .build();
+
+This set can then be passed to the CLI. You can access parameters using their name, for example ``parameters.get<"A">``.
+
+If you want to use ``mio::ParameterSet`` instead, you can find an equivalent definition of the example parameters A and
+B as structs in the dropdown below.
+
+.. dropdown:: Parameter structs for A and B
+
+    .. code-block:: cpp
+        
+        struct A {
+            using Type = int;
+            static Type get_default()
+            {
+                return 5;
+            }
+            static std::string name()
+            {
+                return "A";
+            }
+        };
+        
+        struct B {
+            using Type = double;
+            static Type get_default()
+            {
+                return 2.5;
+            }
+            static std::string name()
+            {
+                return "B";
+            }
+            static std::string alias()
+            {
+                return "b";
+            }
+            static std::string description()
+            {
+                return "This is a description.";
+            }
+            static bool is_required() {
+                return true;
+            }
+        };
+
+    Note that A is a typical parameter struct, while B has additional member functions. These are only used by the CLI,
+    the ``mio::ParameterSet`` will ignore them.
+
+.. dropdown:: :fa:`gears` Expert's knowledge
+
+    Internally, the CLI uses type erasure via a ``AbstractParameter`` class to avoid dealing with the long template
+    lists needed to use a ``mio::ParametSet`` directly. There are two classes for managing a set of
+    ``AbstractParameter``\s, the ``AbstractSet``, used internally with runtime lookup for parameters by name or alias,
+    and the ``mio::cli::ParameterSet``, which allows direct access of parameters via ``StringLiteral``\s while restoring
+    the parameter's original type. However, the template of a ``mio::cli::ParameterSet`` is difficult to define, since
+    it stores both the name as a ``StringLiteral`` as well as the type of each parameter. The builder allows defining
+    this set iteratively, and makes it easier to change set definitions.
+
+
 .. _history:
 
 Working with the History object

From 350c79a7fd7fe9f6eb0ebdbc9c6d274520da834c Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Fri, 10 Oct 2025 11:08:37 +0200
Subject: [PATCH 06/10] [ci skip] Apply fixes to io.rst from code review

Co-authored-by: Henrik Zunker <69154294+HenrZu@users.noreply.github.com>
---
 docs/source/cpp/io.rst | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/docs/source/cpp/io.rst b/docs/source/cpp/io.rst
index 3697499ee7..2212ec3aa9 100644
--- a/docs/source/cpp/io.rst
+++ b/docs/source/cpp/io.rst
@@ -79,7 +79,7 @@ parameter that can be set.
 
 To set the value of a parameter from the command line, first type the corresponding parameter option (see ``--help``),
 followed by the value that should be assigned (reference ``--print_option``). Values are given as a JSON value
-corresponding to the Type of the parameter. Note that some characters may need to be escaped or quoted. For example, the
+corresponding to the type of the parameter. Note that some characters may need to be escaped or quoted. For example, the
 JSON string ``"some string"`` must be entered as ``\\"some string\\"`` or ``'"some string"'``.
 
 
@@ -97,10 +97,10 @@ Here we briefly list available features of the CLI:
 
   .. code:: cpp
 
-      auto result = mio::command_line_interface("example-programm", argc, argv, parameters, {"Path", "N"});
+      auto result = mio::command_line_interface("example-program", argc, argv, parameters, {"Path", "N"});
 
-  Now, calling ``example-programm /path/to/something 5`` is equivalent to
-  ``example-programm --Path /path/to/something --N 5``.
+  Now, calling ``example-program /path/to/something 5`` is equivalent to
+  ``example-program --Path /path/to/something --N 5``.
   Make sure to add quotes to values that contain spaces! 
 
 - Required parameters: The CLI checks that all required parameters are set, and returns an error if some were not set.
@@ -115,7 +115,7 @@ The ``mio::cli::ParameterSetBuilder`` can be used to create parameters specifica
 purpose parameters, check out ``mio::ParameterSet``.
 
 In the following example, we create a ``mio::cli::ParameterSet`` with two parameters. One minimal parameter called "A"
-of type ``int`` with default value 5, and a parameter called "B" of type ``double`` with value 2.5, that uses all
+of type ``int`` with initial value 5, and a parameter called "B" of type ``double`` with value 2.5, that uses all
 optional features (alias, description, and the required flag).
 
 .. code-block:: cpp
@@ -174,7 +174,7 @@ B as structs in the dropdown below.
 
 .. dropdown:: :fa:`gears` Expert's knowledge
 
-    Internally, the CLI uses type erasure via a ``AbstractParameter`` class to avoid dealing with the long template
+    Internally, the CLI uses type erasure via an ``AbstractParameter`` class to avoid dealing with the long template
     lists needed to use a ``mio::ParametSet`` directly. There are two classes for managing a set of
     ``AbstractParameter``\s, the ``AbstractSet``, used internally with runtime lookup for parameters by name or alias,
     and the ``mio::cli::ParameterSet``, which allows direct access of parameters via ``StringLiteral``\s while restoring

From e251cc76b225fd8aae6df2b793af60eb67d77f86 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Fri, 10 Oct 2025 11:02:30 +0200
Subject: [PATCH 07/10] add comments to clarify is_required usage. only set
 is_required when setting was successful

---
 cpp/memilio/io/cli.h | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/cpp/memilio/io/cli.h b/cpp/memilio/io/cli.h
index 4de831824e..1f0fefcf69 100644
--- a/cpp/memilio/io/cli.h
+++ b/cpp/memilio/io/cli.h
@@ -454,13 +454,19 @@ class AbstractSet
             return IOResult<void>(param.error().code(), "Could not set parameter: " + param.error().message());
         }
         else {
-            param.value()->second.DatalessParameter::is_required = false; // mark as set
-            // try to set the value. append parsing errors if not successful
+            // try to set the value
             IOResult<void> result = param.value()->second.set(value);
-            if (result || parse_errors.empty()) {
+            if (result) {
+                // mark as set. we reuse the is_required flag for this, to make checks and repeated CLI calls easier
+                param.value()->second.DatalessParameter::is_required = false;
+                return result;
+            }
+            else if (parse_errors.empty()) {
+                // no need to modify result if there are no parsing errors
                 return result;
             }
             else {
+                // append parsing errors to original error
                 return mio::failure(result.error().code(), result.error().message() + "\n" + parse_errors);
             }
         }
@@ -564,7 +570,10 @@ class AbstractSet
 void write_help(const std::string& executable_name, const AbstractSet& set,
                 const std::vector<std::string>& default_options, std::ostream& os);
 
-/// @brief Implementation of the CLI. See the main function below for details.
+/**
+ * @brief Implementation of the CLI. See the main function below for details.
+ * This function may overwrite parameter values and is_required flags.
+ */
 mio::IOResult<void> command_line_interface(const std::string& executable_name, const int argc, char** argv,
                                            cli::details::AbstractSet& parameters,
                                            const std::vector<std::string>& default_options);

From 4130674b9b27a4902c055442c76eafe0d01aa708 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Fri, 10 Oct 2025 12:01:08 +0200
Subject: [PATCH 08/10] [ci skip] mention jsoncpp dependency

---
 docs/source/cpp/io.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/docs/source/cpp/io.rst b/docs/source/cpp/io.rst
index 2212ec3aa9..b2ef78d2e7 100644
--- a/docs/source/cpp/io.rst
+++ b/docs/source/cpp/io.rst
@@ -34,6 +34,12 @@ There also exist other IO modules that are implemented for specific models.
 The command line interface
 --------------------------
 
+.. note::
+
+    The CLI requires the JsonCPP dependency to be enabled, which is the default when building MEmilio.
+    You can use the cmake variable ``MEMILIO_HAS_JSONCPP`` and the preprocessor macro of the same name to check if the
+    dependency (and the command line interface) is available.
+
 We provide a function ``mio::command_line_interface`` in the header ``memilio/io/cli.h``, that can be used to write to
 or read from a parameter set. It can take parameters from command line arguments (i.e. the content of ``argv`` in the
 main function), and assign them to or get them from a ``mio::ParameterSet``. If the parameter set is only used for the

From b7b332f0e337d4d7ee26ba09c5f8794c9656ac06 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Fri, 10 Oct 2025 12:15:11 +0200
Subject: [PATCH 09/10] [ci skip] move CLI abbreviation up

---
 docs/source/cpp/io.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/docs/source/cpp/io.rst b/docs/source/cpp/io.rst
index b2ef78d2e7..d66381b158 100644
--- a/docs/source/cpp/io.rst
+++ b/docs/source/cpp/io.rst
@@ -36,7 +36,7 @@ The command line interface
 
 .. note::
 
-    The CLI requires the JsonCPP dependency to be enabled, which is the default when building MEmilio.
+    The command line interface (CLI) requires the JsonCPP dependency to be enabled, which is the default when building MEmilio.
     You can use the cmake variable ``MEMILIO_HAS_JSONCPP`` and the preprocessor macro of the same name to check if the
     dependency (and the command line interface) is available.
 
@@ -48,8 +48,8 @@ CLI, make use of the ``mio::cli::ParameterSetBuilder``. A small example can be s
 
 .. note::
 
-    The CLI communicates using the error message in its result. Hence, all dialogue, including the help text, is
-    passed through the return value. Use the following code snippet to correctly return error codes and messages:
+    The CLI function communicates using the error message in its result. Hence, all dialogue, including the help text,
+    is passed through its return value. Use the following code snippet to correctly return error codes and messages:
 
     .. code-block:: cpp
 
@@ -59,7 +59,7 @@ CLI, make use of the ``mio::cli::ParameterSetBuilder``. A small example can be s
             return result.error().code().value();
         }
 
-The command line interface (CLI) provides some built-in options, listed below.
+The CLI provides some built-in options, listed below.
 
 ====================== =====================================
 Name  (Alias)          Description

From ef8a4890e0d4da7c392574d183cd302ca99f39f9 Mon Sep 17 00:00:00 2001
From: reneSchm <49305466+reneSchm@users.noreply.github.com>
Date: Fri, 10 Oct 2025 12:42:45 +0200
Subject: [PATCH 10/10] [ci skip] Update docs/source/cpp/io.rst

Co-authored-by: Henrik Zunker <69154294+HenrZu@users.noreply.github.com>
---
 docs/source/cpp/io.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/source/cpp/io.rst b/docs/source/cpp/io.rst
index d66381b158..b43a391e37 100644
--- a/docs/source/cpp/io.rst
+++ b/docs/source/cpp/io.rst
@@ -37,7 +37,7 @@ The command line interface
 .. note::
 
     The command line interface (CLI) requires the JsonCPP dependency to be enabled, which is the default when building MEmilio.
-    You can use the cmake variable ``MEMILIO_HAS_JSONCPP`` and the preprocessor macro of the same name to check if the
+    You can use the CMake variable ``MEMILIO_HAS_JSONCPP`` and the preprocessor macro of the same name to check if the
     dependency (and the command line interface) is available.
 
 We provide a function ``mio::command_line_interface`` in the header ``memilio/io/cli.h``, that can be used to write to