diff --git a/README.md b/README.md
index fb0ceb72c..0b9991bd6 100644
--- a/README.md
+++ b/README.md
@@ -195,14 +195,15 @@ While all options internally are the same type, there are several ways to add an
 app.add_option(option_name, help_str="")
 
 app.add_option(option_name,
-               variable_to_bind_to, // bool, int, float, vector, enum, or string-like, or anything with a defined conversion from a string or that takes an int 🆕, double 🆕, or string in a constructor. Also allowed are tuples 🆕, std::array 🆕 or std::pair 🆕.
+               variable_to_bind_to, // bool, int, float, vector, enum, or string-like, or anything with a defined conversion from a string or that takes an int 🆕, double 🆕, or string in a constructor. Also allowed are tuples 🆕, std::array 🆕 or std::pair 🆕. Also supported are complex numbers🚧, wrapper types🚧, and containers besides vector🚧 of any other supported type
                help_string="")
 
 app.add_option_function<type>(option_name,
                function <void(const type &value)>, // type can be any type supported by add_option
                help_string="")
 
-app.add_complex(... // Special case: support for complex numbers
+app.add_complex(... // Special case: support for complex numbers ⚠️. complex numbers are now fully supported in the add_option so this function is redundant.
+
 // 🆕 There is a template overload which takes two template parameters the first is the type of object to assign the value to, the second is the conversion type.  The conversion type should have a known way to convert from a string, such as any of the types that work in the non-template version.  If XC is a std::pair and T is some non pair type.  Then a two argument constructor for T is called to assign the value.  For tuples or other multi element types, XC must be a single type or a tuple like object of the same size as the assignment type
 app.add_option<typename T, typename XC>(option_name,
                T &output, // output must be assignable or constructible from a value of type XC
@@ -213,7 +214,7 @@ app.add_flag(option_name,
              help_string="")
 
 app.add_flag(option_name,
-             variable_to_bind_to, // bool, int, float, vector, enum, or string-like, or any singular object with a defined conversion from a string like add_option
+             variable_to_bind_to, // bool, int, float,complex, containers, enum, or string-like, or any singular object with a defined conversion from a string like add_option
              help_string="")
 
 app.add_flag_function(option_name,
@@ -245,9 +246,9 @@ app.add_option<vtype,std:string>("--vs",v1);
 app.add_option<vtype,int>("--vi",v1);
 app.add_option<vtype,double>("--vf",v1);
 ```
-otherwise the output would default to a string.  The `add_option` can be used with any integral or floating point types, enumerations, or strings.  Or any type that takes an int, double, or std::string in an assignment operator or constructor.  If an object can take multiple varieties of those, std::string takes precedence, then double then int.    To better control which one is used or to use another type for the underlying conversions use the two parameter template to directly specify the conversion type.
+otherwise the output would default to a string.  The `add_option` can be used with any integral or floating point types, enumerations, or strings.  Or any type that takes an int, double, or std\::string in an assignment operator or constructor.  If an object can take multiple varieties of those, std::string takes precedence, then double then int.    To better control which one is used or to use another type for the underlying conversions use the two parameter template to directly specify the conversion type.
 
-Types such as (std or boost) `optional<int>`, `optional<double>`, and `optional<string>` are supported directly, other optional types can be added using the two parameter template.  See [CLI11 Advanced Topics/Custom Converters][] for information on how this could be done and how you can add your own converters for additional types.
+Types such as (std or boost) `optional<int>`, `optional<double>`, and `optional<string>` and any other wrapper types are supported directly. For purposes of CLI11 wrapper types are those which `value_type` definition.  See [CLI11 Advanced Topics/Custom Converters][] for information on how you can add your own converters for additional types.
 
 Vector types can also be used in the two parameter template overload
 ```
@@ -308,7 +309,7 @@ Before parsing, you can set the following options:
 -   `->disable_flag_override()`: From the command line long form flag options can be assigned a value on the command line using the `=` notation `--flag=value`. If this behavior is not desired, the `disable_flag_override()` disables it and will generate an exception if it is done on the command line.  The `=` does not work with short form flag options.
 -   `->delimiter(char)`: Allows specification of a custom delimiter for separating single arguments into vector arguments, for example specifying `->delimiter(',')` on an option would result in `--opt=1,2,3` producing 3 elements of a vector and the equivalent of --opt 1 2 3 assuming opt is a vector value.
 -   `->description(str)`: Set/change the description.
--   `->multi_option_policy(CLI::MultiOptionPolicy::Throw)`: Set the multi-option policy. Shortcuts available: `->take_last()`, `->take_first()`, and `->join()`. This will only affect options expecting 1 argument or bool flags (which do not inherit their default but always start with a specific policy).
+-   `->multi_option_policy(CLI::MultiOptionPolicy::Throw)`: Set the multi-option policy. Shortcuts available: `->take_last()`, `->take_first()`,`->take_all()`, and `->join()`. This will only affect options expecting 1 argument or bool flags (which do not inherit their default but always start with a specific policy).
 -   `->check(std::string(const std::string &), validator_name="",validator_description="")`: Define a check function.  The function should return a non empty string with the error message if the check fails
 -   `->check(Validator)`: Use a Validator object to do the check see [Validators](#validators) for a description of available Validators and how to create new ones.
 -   `->transform(std::string(std::string &), validator_name="",validator_description=")`: Converts the input string into the output string, in-place in the parsed options.
@@ -319,7 +320,7 @@ Before parsing, you can set the following options:
 -   `->default_function(std::string())`: Advanced: Change the function that `capture_default_str()` uses.
 -   `->always_capture_default()`: Always run `capture_default_str()` when creating new options. Only useful on an App's `option_defaults`.
 -   `default_str(string)`:  Set the default string directly.  This string will also be used as a default value if no arguments are passed and the value is requested.
--   `default_val(value)`: 🆕 Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or a stream operator).
+-   `default_val(value)`: 🆕 Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator).
 
 
 These options return the `Option` pointer, so you can chain them together, and even skip storing the pointer entirely. The `each` function takes any function that has the signature `void(const std::string&)`; it should throw a `ValidationError` when validation fails. The help message will have the name of the parent option prepended. Since `each`, `check` and `transform` use the same underlying mechanism, you can chain as many as you want, and they will be executed in order. Operations added through `transform` are executed first in reverse order of addition, and `check` and `each` are run following the transform functions in order of addition. If you just want to see the unconverted values, use `.results()` to get the `std::vector<std::string>` of results.
diff --git a/book/chapters/options.md b/book/chapters/options.md
index 571240de2..149cd654b 100644
--- a/book/chapters/options.md
+++ b/book/chapters/options.md
@@ -9,7 +9,7 @@ int int_option{0};
 app.add_option("-i", int_option, "Optional description");
 ```
 
-This will bind the option `-i` to the integer `int_option`. On the command line, a single value that can be converted to an integer will be expected. Non-integer results will fail. If that option is not given, CLI11 will not touch the initial value. This allows you to set up defaults by simply setting your value beforehand. If you want CLI11 to display your default value, you can add the optional final argument `true` when you add the option. If you do not add this, you do not even need your option value to be printable[^1].
+This will bind the option `-i` to the integer `int_option`. On the command line, a single value that can be converted to an integer will be expected. Non-integer results will fail. If that option is not given, CLI11 will not touch the initial value. This allows you to set up defaults by simply setting your value beforehand. If you want CLI11 to display your default value, you can add the optional final argument `true` when you add the option.
 
 ```cpp
 int int_option{0};
@@ -20,11 +20,15 @@ You can use any C++ int-like type, not just `int`. CLI11 understands the followi
 
 | Type        | CLI11 |
 |-------------|-------|
-| int-like    | Integer conversion up to 64-bit, can be unsigned |
-| float-like  | Floating point conversions |
-| string-like | Anything else that can be shifted into a StringStream |
-| vector-like | A vector of the above three types (see below) |
+| number like    | Integers, floats, bools, or any type that can be constructed from an integer or floating point number |
+| string-like | std\::string, or anything that can be constructed from or assigned a std\::string |
+| complex-number | std::complex or any type which has a real(), and imag() operations available, will allow 1 or 2 string definitions like "1+2j" or two arguments "1","2" |
+| enumeration | any enum or enum class type is supported through conversion from the underlying type(typically int, though it can be specified otherwise) |
+| container-like | a container(like vector) of any available types including other containers |
+| wrapper | any other object with a `value_type` static definition where the type specified by `value_type` is one of type in this list |
+| tuple | a tuple, pair, or array, or other type with a tuple size and tuple_type operations defined and the members being a type contained in this list |
 | function | A function that takes an array of strings and returns a string that describes the conversion failure or empty for success. May be the empty function. (`{}`) |
+| streamable | any other type with a `<<` operator will also work |
 
 By default, CLI11 will assume that an option is optional, and one value is expected if you do not use a vector. You can change this on a specific option using option modifiers.
 
@@ -46,15 +50,15 @@ To make a positional option, you simply give CLI11 one name that does not start
 
 This would make two short option aliases, two long option alias, and the option would be also be accepted as a positional.
 
-## Vectors of options
+## Containers of options
 
-If you use a vector instead of a plain option, you can accept more than one value on the command line. By default, a vector accepts as many options as possible, until the next value that could be a valid option name. You can specify a set number using an option modifier `->expected(N)`. (The default unlimited behavior on vectors is restore with `N=-1`) CLI11 does not differentiate between these two methods for unlimited acceptance options:[^2]
+If you use a vector or other container instead of a plain option, you can accept more than one value on the command line. By default, a container accepts as many options as possible, until the next value that could be a valid option name. You can specify a set number using an option modifier `->expected(N)`. (The default unlimited behavior on vectors is restored with `N=-1`) CLI11 does not differentiate between these two methods for unlimited acceptance options.
 
 | Separate names    | Combined names  |
 |-------------------|-----------------|
 | `--vec 1 --vec 2` | `--vec 1 2`     |
 
-The original version did allow the option system to access information on the grouping of options received, but was removed for simplicity.
+It is also possible to specify a minimum and maximum number through `->expected(Min,Max)`.  It is also possible to specify a min and max type size for the elements of the container.  It most cases these values will be automatically determined but a user can manually restrict them.
 
 An example of setting up a vector option:
 
@@ -65,6 +69,43 @@ app.add_option("--vec", int_vec, "My vector option");
 
 Vectors will be replaced by the parsed content if the option is given on the command line.
 
+A definition of a container for purposes of CLI11 is a type with a `end()`, `insert(...)`, `clear()` and `value_type` definitions.  This includes `vector`, `set`, `deque`, `list`, `forward_iist`, `map`, `unordered_map` and a few others from the standard library, and many other containers from the boost library.
+
+### containers of containers
+Containers of containers are also supported.
+```cpp
+std::vector<std::vector<int>> int_vec;
+app.add_option("--vec", int_vec, "My vector of vectors option");
+```
+CLI11 inserts a separator sequence at the start of each argument call to separate the vectors.  So unless the separators are injected as part of the command line each call of the option on the command line will result in a separate element of the outer vector.  This can be manually controlled via `inject_separator(true|false)` but in nearly all cases this should be left to the defaults.  To insert of a separator from the command line add a `%%` where the separation should occur.
+```
+cmd --vec_of_vec 1 2 3 4 %% 1 2
+```
+would then result in a container of size 2 with the first element containing 4 values and the second 2.
+
+This separator is also the only way to get values into something like
+```cpp
+std::pair<std::vector<int>,std::vector<int>> two_vecs;
+app.add_option("--vec", two_vecs, "pair of vectors");
+```
+without calling the argument twice.
+
+Further levels of nesting containers should compile but intermediate layers will only have a single element in the container, so is probably not that useful.
+
+### Nested types
+Types can be nested For example
+```cpp
+std::map<int, std::pair<int,std::string>> map;
+app.add_option("--dict", map, "map of pairs");
+```
+
+will require 3 arguments for each invocation, and multiple sets of 3 arguments can be entered for a single invocation on the command line.
+
+```cpp
+std::map<int, std::pair<int,std::vector<std::string>>> map;
+app.add_option("--dict", map, "map of pairs");
+```
+will result in a requirement for 2 integers on each invocation and absorb an unlimited number of strings including 0.
 
 ## Option modifiers
 
@@ -75,25 +116,32 @@ When you call `add_option`, you get a pointer to the added option. You can use t
 | `->required()` | The program will quit if this option is not present. This is `mandatory` in Plumbum, but required options seems to be a more standard term. For compatibility, `->mandatory()` also works. |
 | `->expected(N)` | Take `N` values instead of as many as possible, mainly for vector args. |
 | `->expected(Nmin,Nmax)` | Take between `Nmin` and `Nmax` values. |
+| `->type_size(N)` | specify that each block of values would consist of N elements |
+| `->type_size(Nmin,Nmax)` | specify that each block of values would consist of between Nmin and Nmax elements |
 | `->needs(opt)` | This option requires another option to also be present, opt is an `Option` pointer. |
 | `->excludes(opt)` | This option cannot be given with `opt` present, opt is an `Option` pointer. |
 | `->envname(name)` | Gets the value from the environment if present and not passed on the command line. |
 | `->group(name)` | The help group to put the option in. No effect for positional options. Defaults to `"Options"`. `"Hidden"` will not show up in the help print. |
+| `->description(string)` | Set/change the description |
 | `->ignore_case()` | Ignore the case on the command line (also works on subcommands, does not affect arguments). |
-| `->ignore_underscore()` | Ignore any underscores on the command line (also works on subcommands, does not affect arguments, new in CLI11 1.7). |
+| `->ignore_underscore()` | Ignore any underscores on the command line (also works on subcommands, does not affect arguments). |
 | `->allow_extra_args()` | Allow extra argument values to be included when an option is passed. Enabled by default for vector options. |
-| `->multi_option_policy(CLI::MultiOptionPolicy::Throw)` | Sets the policy for handling multiple arguments if the option was received on the command line several times. `Throw`ing an error is the default, but `TakeLast`, `TakeFirst`, `TakeAll`, and `Join` are also available. See the next three lines for shortcuts to set this more easily. |
+| `->disable_flag_override()` | specify that flag options cannot be overridden on the command line use `=<newval>` |
+| `->delimiter('<CH>')` | specify a character that can be used to separate elements in a command line argument, default is <none>, common values are ',', and ';' |
+| `->multi_option_policy(CLI::MultiOptionPolicy::Throw)` | Sets the policy for handling multiple arguments if the option was received on the command line several times. `Throw`ing an error is the default, but `TakeLast`, `TakeFirst`, `TakeAll`, and `Join` are also available. See the next four lines for shortcuts to set this more easily. |
 | `->take_last()` | Only use the last option if passed several times. This is always true by default for bool options, regardless of the app default, but can be set to false explicitly with `->multi_option_policy()`. |
 | `->take_first()` | sets `->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst)` |
+| `->take_all()` | sets `->multi_option_policy(CLI::MultiOptionPolicy::TakeAll)` |
 | `->join()` | sets `->multi_option_policy(CLI::MultiOptionPolicy::Join)`, which uses newlines or the specified delimiter to join all arguments into a single string output. |
-| `->join(delim)` | sets `->multi_option_policy(CLI::MultiOptionPolicy::Join)`, which uses `delim` to join all arguments into a single string output. |
-| `->check(CLI::ExistingFile)` | Requires that the file exists if given. |
-| `->check(CLI::ExistingDirectory)` | Requires that the directory exists. |
-| `->check(CLI::NonexistentPath)` | Requires that the path does not exist. |
-| `->check(CLI::Range(min,max))` | Requires that the option be between min and max (make sure to use floating point if needed). Min defaults to 0. |
+| `->join(delim)` | sets `->multi_option_policy(CLI::MultiOptionPolicy::Join)`, which uses `delim` to join all arguments into a single string output. this also sets the delimiter |
+| `->check(Validator)` | perform a check on the returned results to verify they meet some criteria. See [Validators](./validators.md) for more info |
+| `->transform(Validator)` | Run a transforming validator on each value passed. See [Validators](./validators.md) for more info |
 | `->each(void(std::string))` | Run a function on each parsed value, *in order*. |
+| `->default_str(string)` | set a default string for use in the help and as a default value if no arguments are passed and a value is requested |
+| `->default_function(string())` | Advanced: Change the function that `capture_default_str()` uses. |
+| `->default_val(value)` | Generate the default string from a value and validate that the value is also valid.  For options that assign directly to a value type the value in that type is also updated.  Value must be convertible to a string(one of known types or have a stream operator). |
 
-The `->check(...)` modifiers adds a callback function of the form `bool function(std::string)` that runs on every value that the option receives, and returns a value that tells CLI11 whether the check passed or failed.
+The `->check(...)` and `->transform(...)` modifiers can also take a callback function of the form `bool function(std::string)` that runs on every value that the option receives, and returns a value that tells CLI11 whether the check passed or failed.
 
 ## Using the `CLI::Option` pointer
 
@@ -110,12 +158,17 @@ if(* opt)
 
 ## Inheritance of defaults
 
-One of CLI11's systems to allow customizability without high levels of verbosity is the inheritance system. You can set default values on the parent `App`, and all options and subcommands created from it remember the default values at the point of creation. The default value for Options, specifically, are accessible through the `option_defaults()` method. There are four settings that can be set and inherited:
+One of CLI11's systems to allow customizability without high levels of verbosity is the inheritance system. You can set default values on the parent `App`, and all options and subcommands created from it remember the default values at the point of creation. The default value for Options, specifically, are accessible through the `option_defaults()` method. There are a number of settings that can be set and inherited:
 
 *   `group`: The group name starts as "Options"
 *   `required`: If the option must be given. Defaults to `false`. Is ignored for flags.
 *   `multi_option_policy`: What to do if several copies of an option are passed and one value is expected. Defaults to `CLI::MultiOptionPolicy::Throw`. This is also used for bool flags, but they always are created with the value `CLI::MultiOptionPolicy::TakeLast` regardless of the default, so that multiple bool flags does not cause an error. But you can override that flag by flag.
 *   `ignore_case`: Allow any mixture of cases for the option or flag name
+*   `ignore_underscore`: Allow any number of underscores in the option or flag name
+*   `configurable`:  Specify whether an option can be configured through a config file
+*   `disable_flag_override`:  do not allow flag values to be overridden on the command line
+*   `always_capture_default`:  specify that the default values should be automatically captured.
+*   `delimiter`:  A delimiter to use for capturing multiple values in a single command line string (e.g. --flag="flag,-flag2,flag3")
 
 An example of usage:
 
@@ -129,29 +182,7 @@ app.get_group() // is "Required"
 Groups are mostly for visual organization, but an empty string for a group name will hide the option.
 
 
-## Listing of specialty options:
-
-Besides `add_option` and `add_flag`, there are several special ways to create options for sets and complex numbers.
-
-### Sets
-
-You can add a set with `add_set`, where you give a variable to set and a `std::set` of choices to pick from. There also is a `add_set_ignore_case` version which ignores case when set matching. If you use an existing set instead of an inline one, you can edit the set after adding it and changes will be reflected in the set checking and help message.
-
-```cpp
-int val{0};
-app.add_set("--even", val, {0,2,4,6,8});
-```
-
-### Complex numbers
-
-You can also add a complex number. This type just needs to support a `(T x, T y)` constructor and be printable. You can also pass one extra argument that will set the label of the type; by default it is "COMPLEX".
-
-```cpp
-std::complex<float> val{0.0F,0.0F};
-app.add_complex("--cplx", val);
-```
-
-### Windows style options (New in CLI11 1.7)
+### Windows style options
 
 You can also set the app setting `app->allow_windows_style_options()` to allow windows style options to also be recognized on the command line:
 
@@ -160,12 +191,13 @@ You can also set the app setting `app->allow_windows_style_options()` to allow w
 *   `/long` (long flag)
 *   `/file filename` (space)
 *   `/file:filename` (colon)
+*   `/long_flag:false` (long flag with : to override the default value)
 
-Windows style options do not allow combining short options or values not separated from the short option like with `-` options. You still specify option names in the same manor as on Linux with single and double dashes when you use the `add_*` functions, and the Linux style on the command line will still work. If a long and a short option share the same name, the option will match on the first one defined.
+Windows style options do not allow combining short options or values not separated from the short option like with `-` options. You still specify option names in the same manner as on Linux with single and double dashes when you use the `add_*` functions, and the Linux style on the command line will still work. If a long and a short option share the same name, the option will match on the first one defined.
 
 ## Parse configuration
 
-How an option and its arguments are parsed depends on a set of controls that are part of the option structure.  In most circumstances these controls are set automatically based on the function used to create the option and the type the arguments are parsed into.  The variables define the size of the underlying type (essentially how many strings make up the type), the expected size (how many groups are expected) and a flag indicating if multiple groups are allowed with a single option.  And these interact with the `multi_option_policy` when it comes time to parse.
+How an option and its arguments are parsed depends on a set of controls that are part of the option structure.  In most circumstances these controls are set automatically based on the type or function used to create the option and the type the arguments are parsed into.  The variables define the size of the underlying type (essentially how many strings make up the type), the expected size (how many groups are expected) and a flag indicating if multiple groups are allowed with a single option.  And these interact with the `multi_option_policy` when it comes time to parse.
 
 ### examples
 How options manage this is best illustrated through some examples
@@ -173,7 +205,7 @@ How options manage this is best illustrated through some examples
 std::string val;
 app.add_option("--opt",val,"description");
 ```
-creates an option that assigns a value to a `std::string`  When this option is constructed it sets a type_size of 1.  meaning that the assignment uses a single string.  The Expected size is also set to 1 by default, and `allow_extra_args` is set to false. meaning that each time this option is called 1 argument is expected.  This would also be the case if val were a `double`, `int` or any other single argument types.
+creates an option that assigns a value to a `std::string`  When this option is constructed it sets a type_size min and max of 1.  Meaning that the assignment uses a single string.  The Expected size is also set to 1 by default, and `allow_extra_args` is set to false. meaning that each time this option is called 1 argument is expected.  This would also be the case if val were a `double`, `int` or any other single argument types.
 
 now for example
 ```cpp
@@ -203,6 +235,20 @@ app.add_flag("--opt",val,"description");
 
 Using the add_flag methods for creating options creates an option with an expected size of 0, implying no arguments can be passed.
 
+```cpp
+std::complex<double> val;
+app.add_option("--opt",val,"description");
+```
+
+triggers the complex number type which has a min of 1 and max of 2,  so 1 or 2 strings can be passed.  Complex number conversion supports arguments of the form "1+2j" or "1","2", or "1" "2i".  The imaginary number symbols `i` and `j` are interchangeable in this context.
+
+
+```cpp
+std::vector<std::vector<int>> val;
+app.add_option("--opt",val,"description");
+```
+has a type size of 1 to (1<<30).
+
 ### Customization
 
 The `type_size(N)`, `type_size(Nmin, Nmax)`, `expected(N)`, `expected(Nmin,Nmax)`, and `allow_extra_args()` can be used to customize an option.  For example
@@ -214,5 +260,9 @@ opt->expected(0,1);
 ```
 will create a hybrid option, that can exist on its own in which case the value "vvv" is used or if a value is given that value will be used.
 
-[^1]: For example, enums are not printable to `std::cout`.
-[^2]: There is a small difference. An combined unlimited option will not prioritize over a positional that could still accept values.
+There are some additional options that can be specified to modify an option for specific cases
+-   `->run_callback_for_default()` will specify that the callback should be executed when a default_val is set. This is set automatically when appropriate though it can be turned on or off and any user specified callback for an option will be executed when the default value for an option is set.
+
+## Unusual circumstances
+There are a few cases where some things break down in the type system managing options and definitions.  Using the `add_option` method defines a lambda function to extract a default value if required.  In most cases this either straightforward or a failure is detected automatically and handled.  But in a few cases a streaming template is available that several layers down may not actually be defined.  The conditions in CLI11 cannot detect this circumstance automatically and will result in compile error.  One specific known case is `boost::optional` if the boost optional_io header is included.  This header defines a template for all boost optional values even if they do no actually have a streaming operator.  For example `boost::optional<std::vector>` does not have a streaming operator but one is detected since it is part of a template.  For these cases a secondary method `app->add_option_no_stream(...)` is provided that bypasses this operation completely and should compile in these cases.
+
diff --git a/extern/googletest b/extern/googletest
index 2fe3bd994..703bd9caa 160000
--- a/extern/googletest
+++ b/extern/googletest
@@ -1 +1 @@
-Subproject commit 2fe3bd994b3189899d93f1d5a881e725e046fdc2
+Subproject commit 703bd9caab50b139428cea1aaff9974ebee5742e
diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index 882046afc..2caabff45 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -610,21 +610,39 @@ class App {
         // to structs used in the evaluation can be temporary so that would cause issues.
         auto Tcount = detail::type_count<AssignTo>::value;
         auto XCcount = detail::type_count<ConvertTo>::value;
-        opt->type_size((std::max)(Tcount, XCcount));
+        opt->type_size(detail::type_count_min<ConvertTo>::value, (std::max)(Tcount, XCcount));
         opt->expected(detail::expected_count<ConvertTo>::value);
         opt->run_callback_for_default();
         return opt;
     }
 
+    /// Add option for assigning to a variable
+    template <typename AssignTo, enable_if_t<!std::is_const<AssignTo>::value, detail::enabler> = detail::dummy>
+    Option *add_option_no_stream(std::string option_name,
+                                 AssignTo &variable, ///< The variable to set
+                                 std::string option_description = "") {
+
+        auto fun = [&variable](const CLI::results_t &res) { // comment for spacing
+            return detail::lexical_conversion<AssignTo, AssignTo>(res, variable);
+        };
+
+        Option *opt = add_option(option_name, fun, option_description, false, []() { return std::string{}; });
+        opt->type_name(detail::type_name<AssignTo>());
+        opt->type_size(detail::type_count_min<AssignTo>::value, detail::type_count<AssignTo>::value);
+        opt->expected(detail::expected_count<AssignTo>::value);
+        opt->run_callback_for_default();
+        return opt;
+    }
+
     /// Add option for a callback of a specific type
-    template <typename T>
+    template <typename ArgType>
     Option *add_option_function(std::string option_name,
-                                const std::function<void(const T &)> &func,  ///< the callback to execute
+                                const std::function<void(const ArgType &)> &func, ///< the callback to execute
                                 std::string option_description = "") {
 
         auto fun = [func](const CLI::results_t &res) {
-            T variable;
-            bool result = detail::lexical_conversion<T, T>(res, variable);
+            ArgType variable;
+            bool result = detail::lexical_conversion<ArgType, ArgType>(res, variable);
             if(result) {
                 func(variable);
             }
@@ -632,15 +650,15 @@ class App {
         };
 
         Option *opt = add_option(option_name, std::move(fun), option_description, false);
-        opt->type_name(detail::type_name<T>());
-        opt->type_size(detail::type_count<T>::value);
-        opt->expected(detail::expected_count<T>::value);
+        opt->type_name(detail::type_name<ArgType>());
+        opt->type_size(detail::type_count_min<ArgType>::value, detail::type_count<ArgType>::value);
+        opt->expected(detail::expected_count<ArgType>::value);
         return opt;
     }
 
     /// Add option with no description or variable assignment
     Option *add_option(std::string option_name) {
-        return add_option(option_name, CLI::callback_t(), std::string{}, false);
+        return add_option(option_name, CLI::callback_t{}, std::string{}, false);
     }
 
     /// Add option with description but with no variable assignment or callback
@@ -749,7 +767,7 @@ class App {
     /// Other type version accepts all other types that are not vectors such as bool, enum, string or other classes
     /// that can be converted from a string
     template <typename T,
-              enable_if_t<!is_vector<T>::value && !std::is_const<T>::value &&
+              enable_if_t<!detail::is_mutable_container<T>::value && !std::is_const<T>::value &&
                               (!std::is_integral<T>::value || is_bool<T>::value) &&
                               !std::is_constructible<std::function<void(int)>, T>::value,
                           detail::enabler> = detail::dummy>
@@ -873,7 +891,7 @@ class App {
         return opt;
     }
 
-    /// Add a complex number
+    /// Add a complex number DEPRECATED --use add_option instead
     template <typename T, typename XC = double>
     Option *add_complex(std::string option_name,
                         T &variable,
@@ -2652,7 +2670,12 @@ class App {
 
         // Get a reference to the pointer to make syntax bearable
         Option_p &op = *op_ptr;
-
+        /// if we require a separator add it here
+        if(op->get_inject_separator()) {
+            if(!op->results().empty() && !op->results().back().empty()) {
+                op->add_result(std::string{});
+            }
+        }
         int min_num = (std::min)(op->get_type_size_min(), op->get_items_expected_min());
         int max_num = op->get_items_expected_max();
 
@@ -2717,7 +2740,7 @@ class App {
         }
 
         // if we only partially completed a type then add an empty string for later processing
-        if(min_num > 0 && op->get_type_size_max() != min_num && collected % op->get_type_size_max() != 0) {
+        if(min_num > 0 && op->get_type_size_max() != min_num && (collected % op->get_type_size_max()) != 0) {
             op->add_result(std::string{});
         }
 
diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index 2e0293038..ae8907d5c 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -315,7 +315,7 @@ class Option : public OptionBase<Option> {
     /// results after reduction
     results_t proc_results_{};
     /// enumeration for the option state machine
-    enum class option_state {
+    enum class option_state : char {
         parsing = 0,       //!< The option is currently collecting parsed results
         validated = 2,     //!< the results have been validated
         reduced = 4,       //!< a subset of results has been generated
@@ -329,6 +329,8 @@ class Option : public OptionBase<Option> {
     bool flag_like_{false};
     /// Control option to run the callback to set the default
     bool run_callback_for_default_{false};
+    /// flag indicating a separator needs to be injected after each argument call
+    bool inject_separator_{false};
     ///@}
 
     /// Making an option by hand is not defined, it must be made by the App class
@@ -658,6 +660,9 @@ class Option : public OptionBase<Option> {
     /// The maximum number of arguments the option expects
     int get_type_size_max() const { return type_size_max_; }
 
+    /// The number of arguments the option expects
+    int get_inject_separator() const { return inject_separator_; }
+
     /// The environment variable associated to this value
     std::string get_envname() const { return envname_; }
 
@@ -941,8 +946,8 @@ class Option : public OptionBase<Option> {
         return this;
     }
 
-    /// Get a copy of the results
-    results_t results() const { return results_; }
+    /// Get the current complete results set
+    const results_t &results() const { return results_; }
 
     /// Get a copy of the results
     results_t reduced_results() const {
@@ -964,8 +969,7 @@ class Option : public OptionBase<Option> {
     }
 
     /// Get the results as a specified type
-    template <typename T, enable_if_t<!std::is_const<T>::value, detail::enabler> = detail::dummy>
-    void results(T &output) const {
+    template <typename T> void results(T &output) const {
         bool retval;
         if(current_option_state_ >= option_state::reduced || (results_.size() == 1 && validators_.empty())) {
             const results_t &res = (proc_results_.empty()) ? results_ : proc_results_;
@@ -1032,6 +1036,8 @@ class Option : public OptionBase<Option> {
             type_size_max_ = option_type_size;
             if(type_size_max_ < detail::expected_max_vector_size) {
                 type_size_min_ = option_type_size;
+            } else {
+                inject_separator_ = true;
             }
             if(type_size_max_ == 0)
                 required_ = false;
@@ -1057,9 +1063,15 @@ class Option : public OptionBase<Option> {
         if(type_size_max_ == 0) {
             required_ = false;
         }
+        if(type_size_max_ >= detail::expected_max_vector_size) {
+            inject_separator_ = true;
+        }
         return this;
     }
 
+    /// Set the value of the separator injection flag
+    void inject_separator(bool value = true) { inject_separator_ = value; }
+
     /// Set a capture function for the default. Mostly used by App.
     Option *default_function(const std::function<std::string()> &func) {
         default_function_ = func;
@@ -1135,7 +1147,7 @@ class Option : public OptionBase<Option> {
                 }
 
                 for(std::string &result : res) {
-                    if(result.empty() && type_size_max_ != type_size_min_ && index >= 0) {
+                    if(detail::is_separator(result) && type_size_max_ != type_size_min_ && index >= 0) {
                         index = 0;  // reset index for variable size chunks
                         continue;
                     }
diff --git a/include/CLI/StringTools.hpp b/include/CLI/StringTools.hpp
index 121637471..cd861ba2d 100644
--- a/include/CLI/StringTools.hpp
+++ b/include/CLI/StringTools.hpp
@@ -190,6 +190,12 @@ inline bool valid_name_string(const std::string &str) {
     return true;
 }
 
+/// check if a string is a container segment separator (empty or "%%"
+inline bool is_separator(const std::string &str) {
+    static const std::string sep("%%");
+    return (str.empty() || str == sep);
+}
+
 /// Verify that str consists of letters only
 inline bool isalpha(const std::string &str) {
     return std::all_of(str.begin(), str.end(), [](char c) { return std::isalpha(c, std::locale()); });
diff --git a/include/CLI/TypeTools.hpp b/include/CLI/TypeTools.hpp
index 62f4e460d..49e558dd6 100644
--- a/include/CLI/TypeTools.hpp
+++ b/include/CLI/TypeTools.hpp
@@ -45,15 +45,6 @@ template <typename... Ts> using void_t = typename make_void<Ts...>::type;
 /// A copy of std::conditional_t from C++14 - same reasoning as enable_if_t, it does not hurt to redefine
 template <bool B, class T, class F> using conditional_t = typename std::conditional<B, T, F>::type;
 
-/// Check to see if something is a vector (fail check by default)
-template <typename T> struct is_vector : std::false_type {};
-
-/// Check to see if something is a vector (true if actually a vector)
-template <class T, class A> struct is_vector<std::vector<T, A>> : std::true_type {};
-
-/// Check to see if something is a vector (true if actually a const vector)
-template <class T, class A> struct is_vector<const std::vector<T, A>> : std::true_type {};
-
 /// Check to see if something is bool (fail check by default)
 template <typename T> struct is_bool : std::false_type {};
 
@@ -195,6 +186,17 @@ template <typename T, typename S = std::istringstream> class is_istreamable {
     static constexpr bool value = decltype(test<T, S>(0))::value;
 };
 
+/// Check for complex
+template <typename T> class is_complex {
+    template <typename TT>
+    static auto test(int) -> decltype(std::declval<TT>().real(), std::declval<TT>().imag(), std::true_type());
+
+    template <typename> static auto test(...) -> std::false_type;
+
+  public:
+    static constexpr bool value = decltype(test<T>(0))::value;
+};
+
 /// Templated operation to get a value from a stream
 template <typename T, enable_if_t<is_istreamable<T>::value, detail::enabler> = detail::dummy>
 bool from_stream(const std::string &istring, T &obj) {
@@ -209,12 +211,49 @@ bool from_stream(const std::string & /*istring*/, T & /*obj*/) {
     return false;
 }
 
+// check to see if an object is a mutable container (fail by default)
+template <typename T, typename _ = void> struct is_mutable_container : std::false_type {};
+
+/// type trait to test if a type is a mutable container meaning it has a value_type, it has an iterator, a clear, and
+/// end methods and an insert function.  And for our purposes we exclude std::string and types that can be constructed
+/// from a std::string
+template <typename T>
+struct is_mutable_container<
+    T,
+    conditional_t<false,
+                  void_t<typename T::value_type,
+                         decltype(std::declval<T>().end()),
+                         decltype(std::declval<T>().clear()),
+                         decltype(std::declval<T>().insert(std::declval<decltype(std::declval<T>().end())>(),
+                                                           std::declval<const typename T::value_type &>()))>,
+                  void>>
+    : public conditional_t<std::is_constructible<T, std::string>::value, std::false_type, std::true_type> {};
+
+// check to see if an object is a mutable container (fail by default)
+template <typename T, typename _ = void> struct is_readable_container : std::false_type {};
+
+/// type trait to test if a type is a container meaning it has a value_type, it has an iterator, a clear, and an en end
+/// methods and an insert function.  And for our purposes we exclude std::string and types that can be constructed from
+/// a std::string
+template <typename T>
+struct is_readable_container<
+    T,
+    conditional_t<false, void_t<decltype(std::declval<T>().end()), decltype(std::declval<T>().begin())>, void>>
+    : public std::true_type {};
+
+// check to see if an object is a wrapper (fail by default)
+template <typename T, typename _ = void> struct is_wrapper : std::false_type {};
+
+// check if an object is a is a wrapper (it has a value_type defined)
+template <typename T>
+struct is_wrapper<T, conditional_t<false, void_t<typename T::value_type>, void>> : public std::true_type {};
+
 // Check for tuple like types, as in classes with a tuple_size type trait
 template <typename S> class is_tuple_like {
     template <typename SS>
     // static auto test(int)
     //     -> decltype(std::conditional<(std::tuple_size<SS>::value > 0), std::true_type, std::false_type>::type());
-    static auto test(int) -> decltype(std::tuple_size<SS>::value, std::true_type{});
+    static auto test(int) -> decltype(std::tuple_size<typename std::decay<SS>::type>::value, std::true_type{});
     template <typename> static auto test(...) -> std::false_type;
 
   public:
@@ -249,20 +288,19 @@ std::string to_string(T &&value) {
 /// If conversion is not supported, return an empty string (streaming is not supported for that type)
 template <typename T,
           enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
-                          !is_vector<typename std::remove_reference<typename std::remove_const<T>::type>::type>::value,
+                          !is_readable_container<typename std::remove_const<T>::type>::value,
                       detail::enabler> = detail::dummy>
 std::string to_string(T &&) {
     return std::string{};
 }
 
-/// convert a vector to a string
+/// convert a readable container to a string
 template <typename T,
           enable_if_t<!std::is_constructible<std::string, T>::value && !is_ostreamable<T>::value &&
-                          is_vector<typename std::remove_reference<typename std::remove_const<T>::type>::type>::value,
+                          is_readable_container<T>::value,
                       detail::enabler> = detail::dummy>
 std::string to_string(T &&variable) {
     std::vector<std::string> defaults;
-    defaults.reserve(variable.size());
     auto cval = variable.begin();
     auto end = variable.end();
     while(cval != end) {
@@ -306,25 +344,142 @@ auto value_string(const T &value) -> decltype(to_string(value)) {
     return to_string(value);
 }
 
+/// temple to get the underlying value type if it exists or use a default
+template <typename T, typename def, typename Enable = void> struct wrapped_type { using type = def; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T, typename def> struct wrapped_type<T, def, typename std::enable_if<is_wrapper<T>::value>::type> {
+    using type = typename T::value_type;
+};
+
 /// This will only trigger for actual void type
-template <typename T, typename Enable = void> struct type_count { static const int value{0}; };
+template <typename T, typename Enable = void> struct type_count_base { static const int value{0}; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T>
+struct type_count_base<T,
+                       typename std::enable_if<!is_tuple_like<T>::value && !is_mutable_container<T>::value &&
+                                               !std::is_void<T>::value>::type> {
+    static constexpr int value{1};
+};
+
+/// the base tuple size
+template <typename T>
+struct type_count_base<T, typename std::enable_if<is_tuple_like<T>::value && !is_mutable_container<T>::value>::type> {
+    static constexpr int value{std::tuple_size<T>::value};
+};
+
+/// Type count base for containers is the type_count_base of the individual element
+template <typename T> struct type_count_base<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr int value{type_count_base<typename T::value_type>::value};
+};
 
 /// Set of overloads to get the type size of an object
+
+/// forward declare the subtype_count structure
+template <typename T> struct subtype_count;
+
+/// forward declare the subtype_count_min structure
+template <typename T> struct subtype_count_min;
+
+/// This will only trigger for actual void type
+template <typename T, typename Enable = void> struct type_count { static const int value{0}; };
+
+/// Type size for regular object types that do not look like a tuple
+template <typename T>
+struct type_count<T,
+                  typename std::enable_if<!is_wrapper<T>::value && !is_tuple_like<T>::value && !is_complex<T>::value &&
+                                          !std::is_void<T>::value>::type> {
+    static constexpr int value{1};
+};
+
+/// Type size for complex since it sometimes looks like a wrapper
+template <typename T> struct type_count<T, typename std::enable_if<is_complex<T>::value>::type> {
+    static constexpr int value{2};
+};
+
+/// Type size of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)
+template <typename T> struct type_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr int value{subtype_count<typename T::value_type>::value};
+};
+
+/// Type size of types that are wrappers,except containers complex and tuples(which can also be wrappers sometimes)
+template <typename T>
+struct type_count<T,
+                  typename std::enable_if<is_wrapper<T>::value && !is_complex<T>::value && !is_tuple_like<T>::value &&
+                                          !is_mutable_container<T>::value>::type> {
+    static constexpr int value{type_count<typename T::value_type>::value};
+};
+
+/// 0 if the index > tuple size
+template <typename T, std::size_t I>
+constexpr typename std::enable_if<I == type_count_base<T>::value, int>::type tuple_type_size() {
+    return 0;
+}
+
+/// Recursively generate the tuple type name
+template <typename T, std::size_t I>
+    constexpr typename std::enable_if < I<type_count_base<T>::value, int>::type tuple_type_size() {
+    return subtype_count<typename std::tuple_element<I, T>::type>::value + tuple_type_size<T, I + 1>();
+}
+
+/// Get the type size of the sum of type sizes for all the individual tuple types
 template <typename T> struct type_count<T, typename std::enable_if<is_tuple_like<T>::value>::type> {
-    static constexpr int value{std::tuple_size<T>::value};
+    static constexpr int value{tuple_type_size<T, 0>()};
+};
+
+/// definition of subtype count
+template <typename T> struct subtype_count {
+    static constexpr int value{is_mutable_container<T>::value ? expected_max_vector_size : type_count<T>::value};
 };
+
+/// This will only trigger for actual void type
+template <typename T, typename Enable = void> struct type_count_min { static const int value{0}; };
+
 /// Type size for regular object types that do not look like a tuple
 template <typename T>
-struct type_count<
+struct type_count_min<
     T,
-    typename std::enable_if<!is_vector<T>::value && !is_tuple_like<T>::value && !std::is_void<T>::value>::type> {
+    typename std::enable_if<!is_mutable_container<T>::value && !is_tuple_like<T>::value && !is_wrapper<T>::value &&
+                            !is_complex<T>::value && !std::is_void<T>::value>::type> {
+    static constexpr int value{type_count<T>::value};
+};
+
+/// Type size for complex since it sometimes looks like a wrapper
+template <typename T> struct type_count_min<T, typename std::enable_if<is_complex<T>::value>::type> {
     static constexpr int value{1};
 };
 
-/// Type size of types that look like a vector
-template <typename T> struct type_count<T, typename std::enable_if<is_vector<T>::value>::type> {
-    static constexpr int value{is_vector<typename T::value_type>::value ? expected_max_vector_size
-                                                                        : type_count<typename T::value_type>::value};
+/// Type size min of types that are wrappers,except complex and tuples(which can also be wrappers sometimes)
+template <typename T>
+struct type_count_min<
+    T,
+    typename std::enable_if<is_wrapper<T>::value && !is_complex<T>::value && !is_tuple_like<T>::value>::type> {
+    static constexpr int value{subtype_count_min<typename T::value_type>::value};
+};
+
+/// 0 if the index > tuple size
+template <typename T, std::size_t I>
+constexpr typename std::enable_if<I == type_count_base<T>::value, int>::type tuple_type_size_min() {
+    return 0;
+}
+
+/// Recursively generate the tuple type name
+template <typename T, std::size_t I>
+    constexpr typename std::enable_if < I<type_count_base<T>::value, int>::type tuple_type_size_min() {
+    return subtype_count_min<typename std::tuple_element<I, T>::type>::value + tuple_type_size_min<T, I + 1>();
+}
+
+/// Get the type size of the sum of type sizes for all the individual tuple types
+template <typename T> struct type_count_min<T, typename std::enable_if<is_tuple_like<T>::value>::type> {
+    static constexpr int value{tuple_type_size_min<T, 0>()};
+};
+
+/// definition of subtype count
+template <typename T> struct subtype_count_min {
+    static constexpr int value{is_mutable_container<T>::value
+                                   ? ((type_count<T>::value < expected_max_vector_size) ? type_count<T>::value : 0)
+                                   : type_count_min<T>::value};
 };
 
 /// This will only trigger for actual void type
@@ -332,14 +487,22 @@ template <typename T, typename Enable = void> struct expected_count { static con
 
 /// For most types the number of expected items is 1
 template <typename T>
-struct expected_count<T, typename std::enable_if<!is_vector<T>::value && !std::is_void<T>::value>::type> {
+struct expected_count<T,
+                      typename std::enable_if<!is_mutable_container<T>::value && !is_wrapper<T>::value &&
+                                              !std::is_void<T>::value>::type> {
     static constexpr int value{1};
 };
 /// number of expected items in a vector
-template <typename T> struct expected_count<T, typename std::enable_if<is_vector<T>::value>::type> {
+template <typename T> struct expected_count<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
     static constexpr int value{expected_max_vector_size};
 };
 
+/// number of expected items in a vector
+template <typename T>
+struct expected_count<T, typename std::enable_if<!is_mutable_container<T>::value && is_wrapper<T>::value>::type> {
+    static constexpr int value{expected_count<typename T::value_type>::value};
+};
+
 // Enumeration of the different supported categorizations of objects
 enum class object_category : int {
     integral_value = 2,
@@ -350,12 +513,15 @@ enum class object_category : int {
     number_constructible = 12,
     double_constructible = 14,
     integer_constructible = 16,
-    vector_value = 30,
-    tuple_value = 35,
-    // string assignable or greater used in a condition so anything string like must come last
-    string_assignable = 50,
-    string_constructible = 60,
-    other = 200,
+    // string like types
+    string_assignable = 23,
+    string_constructible = 24,
+    other = 45,
+    // special wrapper or container types
+    wrapper_value = 50,
+    complex_number = 60,
+    tuple_value = 70,
+    container_value = 80,
 
 };
 
@@ -392,10 +558,9 @@ template <typename T> struct classify_object<T, typename std::enable_if<std::is_
 
 /// String and similar direct assignment
 template <typename T>
-struct classify_object<
-    T,
-    typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
-                            std::is_assignable<T &, std::string>::value && !is_vector<T>::value>::type> {
+struct classify_object<T,
+                       typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
+                                               std::is_assignable<T &, std::string>::value>::type> {
     static constexpr object_category value{object_category::string_assignable};
 };
 
@@ -404,8 +569,8 @@ template <typename T>
 struct classify_object<
     T,
     typename std::enable_if<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
-                            !std::is_assignable<T &, std::string>::value &&
-                            std::is_constructible<T, std::string>::value && !is_vector<T>::value>::type> {
+                            !std::is_assignable<T &, std::string>::value && (type_count<T>::value == 1) &&
+                            std::is_constructible<T, std::string>::value>::type> {
     static constexpr object_category value{object_category::string_constructible};
 };
 
@@ -414,23 +579,35 @@ template <typename T> struct classify_object<T, typename std::enable_if<std::is_
     static constexpr object_category value{object_category::enumeration};
 };
 
+template <typename T> struct classify_object<T, typename std::enable_if<is_complex<T>::value>::type> {
+    static constexpr object_category value{object_category::complex_number};
+};
+
 /// Handy helper to contain a bunch of checks that rule out many common types (integers, string like, floating point,
 /// vectors, and enumerations
 template <typename T> struct uncommon_type {
     using type = typename std::conditional<!std::is_floating_point<T>::value && !std::is_integral<T>::value &&
                                                !std::is_assignable<T &, std::string>::value &&
-                                               !std::is_constructible<T, std::string>::value && !is_vector<T>::value &&
-                                               !std::is_enum<T>::value,
+                                               !std::is_constructible<T, std::string>::value && !is_complex<T>::value &&
+                                               !is_mutable_container<T>::value && !std::is_enum<T>::value,
                                            std::true_type,
                                            std::false_type>::type;
     static constexpr bool value = type::value;
 };
 
+/// wrapper type
+template <typename T>
+struct classify_object<T,
+                       typename std::enable_if<(!is_mutable_container<T>::value && is_wrapper<T>::value &&
+                                                !is_tuple_like<T>::value && uncommon_type<T>::value)>::type> {
+    static constexpr object_category value{object_category::wrapper_value};
+};
+
 /// Assignable from double or int
 template <typename T>
 struct classify_object<T,
                        typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
-                                               is_direct_constructible<T, double>::value &&
+                                               !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
                                                is_direct_constructible<T, int>::value>::type> {
     static constexpr object_category value{object_category::number_constructible};
 };
@@ -439,7 +616,7 @@ struct classify_object<T,
 template <typename T>
 struct classify_object<T,
                        typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
-                                               !is_direct_constructible<T, double>::value &&
+                                               !is_wrapper<T>::value && !is_direct_constructible<T, double>::value &&
                                                is_direct_constructible<T, int>::value>::type> {
     static constexpr object_category value{object_category::integer_constructible};
 };
@@ -448,24 +625,30 @@ struct classify_object<T,
 template <typename T>
 struct classify_object<T,
                        typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
-                                               is_direct_constructible<T, double>::value &&
+                                               !is_wrapper<T>::value && is_direct_constructible<T, double>::value &&
                                                !is_direct_constructible<T, int>::value>::type> {
     static constexpr object_category value{object_category::double_constructible};
 };
 
 /// Tuple type
 template <typename T>
-struct classify_object<T,
-                       typename std::enable_if<(type_count<T>::value >= 2 && !is_vector<T>::value) ||
-                                               (is_tuple_like<T>::value && uncommon_type<T>::value &&
-                                                !is_direct_constructible<T, double>::value &&
-                                                !is_direct_constructible<T, int>::value)>::type> {
+struct classify_object<
+    T,
+    typename std::enable_if<is_tuple_like<T>::value &&
+                            ((type_count<T>::value >= 2 && !is_wrapper<T>::value) ||
+                             (uncommon_type<T>::value && !is_direct_constructible<T, double>::value &&
+                              !is_direct_constructible<T, int>::value))>::type> {
     static constexpr object_category value{object_category::tuple_value};
+    // the condition on this class requires it be like a tuple, but on some compilers (like Xcode) tuples can be
+    // constructed from just the first element so tuples of <string, int,int> can be constructed from a string, which
+    // could lead to issues so there are two variants of the condition, the first isolates things with a type size >=2
+    // mainly to get tuples on Xcode with the exception of wrappers, the second is the main one and just separating out
+    // those cases that are caught by other object classifications
 };
 
-/// Vector type
-template <typename T> struct classify_object<T, typename std::enable_if<is_vector<T>::value>::type> {
-    static constexpr object_category value{object_category::vector_value};
+/// container type
+template <typename T> struct classify_object<T, typename std::enable_if<is_mutable_container<T>::value>::type> {
+    static constexpr object_category value{object_category::container_value};
 };
 
 // Type name print
@@ -511,31 +694,53 @@ constexpr const char *type_name() {
     return "BOOLEAN";
 }
 
+/// Print name for enumeration types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::complex_number, detail::enabler> = detail::dummy>
+constexpr const char *type_name() {
+    return "COMPLEX";
+}
+
 /// Print for all other types
 template <typename T,
-          enable_if_t<classify_object<T>::value >= object_category::string_assignable, detail::enabler> = detail::dummy>
+          enable_if_t<classify_object<T>::value >= object_category::string_assignable &&
+                          classify_object<T>::value <= object_category::other,
+                      detail::enabler> = detail::dummy>
 constexpr const char *type_name() {
     return "TEXT";
 }
+/// typename for tuple value
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count_base<T>::value >= 2,
+                      detail::enabler> = detail::dummy>
+std::string type_name(); // forward declaration
+
+/// Generate type name for a wrapper or container value
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::container_value ||
+                          classify_object<T>::value == object_category::wrapper_value,
+                      detail::enabler> = detail::dummy>
+std::string type_name(); // forward declaration
 
 /// Print name for single element tuple types
 template <typename T,
-          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count<T>::value == 1,
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count_base<T>::value == 1,
                       detail::enabler> = detail::dummy>
 inline std::string type_name() {
-    return type_name<typename std::tuple_element<0, T>::type>();
+    return type_name<typename std::decay<typename std::tuple_element<0, T>::type>::type>();
 }
 
 /// Empty string if the index > tuple size
 template <typename T, std::size_t I>
-inline typename std::enable_if<I == type_count<T>::value, std::string>::type tuple_name() {
+inline typename std::enable_if<I == type_count_base<T>::value, std::string>::type tuple_name() {
     return std::string{};
 }
 
 /// Recursively generate the tuple type name
 template <typename T, std::size_t I>
-    inline typename std::enable_if < I<type_count<T>::value, std::string>::type tuple_name() {
-    std::string str = std::string(type_name<typename std::tuple_element<I, T>::type>()) + ',' + tuple_name<T, I + 1>();
+inline typename std::enable_if<(I < type_count_base<T>::value), std::string>::type tuple_name() {
+    std::string str = std::string(type_name<typename std::decay<typename std::tuple_element<I, T>::type>::type>()) +
+                      ',' + tuple_name<T, I + 1>();
     if(str.back() == ',')
         str.pop_back();
     return str;
@@ -543,17 +748,19 @@ template <typename T, std::size_t I>
 
 /// Print type name for tuples with 2 or more elements
 template <typename T,
-          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count<T>::value >= 2,
-                      detail::enabler> = detail::dummy>
-std::string type_name() {
+          enable_if_t<classify_object<T>::value == object_category::tuple_value && type_count_base<T>::value >= 2,
+                      detail::enabler>>
+inline std::string type_name() {
     auto tname = std::string(1, '[') + tuple_name<T, 0>();
     tname.push_back(']');
     return tname;
 }
 
-/// This one should not be used normally, since vector types print the internal type
+/// get the type name for a type that has a value_type member
 template <typename T,
-          enable_if_t<classify_object<T>::value == object_category::vector_value, detail::enabler> = detail::dummy>
+          enable_if_t<classify_object<T>::value == object_category::container_value ||
+                          classify_object<T>::value == object_category::wrapper_value,
+                      detail::enabler>>
 inline std::string type_name() {
     return type_name<typename T::value_type>();
 }
@@ -671,6 +878,38 @@ bool lexical_cast(const std::string &input, T &output) {
     }
 }
 
+/// complex
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::complex_number, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    using XC = typename wrapped_type<T, double>::type;
+    XC x{0.0}, y{0.0};
+    auto str1 = input;
+    bool worked = false;
+    auto nloc = str1.find_last_of("+-");
+    if(nloc != std::string::npos && nloc > 0) {
+        worked = detail::lexical_cast(str1.substr(0, nloc), x);
+        str1 = str1.substr(nloc);
+        if(str1.back() == 'i' || str1.back() == 'j')
+            str1.pop_back();
+        worked = worked && detail::lexical_cast(str1, y);
+    } else {
+        if(str1.back() == 'i' || str1.back() == 'j') {
+            str1.pop_back();
+            worked = detail::lexical_cast(str1, y);
+            x = XC{0};
+        } else {
+            worked = detail::lexical_cast(str1, x);
+            y = XC{0};
+        }
+    }
+    if(worked) {
+        output = T{x, y};
+        return worked;
+    }
+    return from_stream(input, output);
+}
+
 /// String and similar direct assignment
 template <typename T,
           enable_if_t<classify_object<T>::value == object_category::string_assignable, detail::enabler> = detail::dummy>
@@ -701,6 +940,18 @@ bool lexical_cast(const std::string &input, T &output) {
     return true;
 }
 
+/// wrapper types
+template <typename T,
+          enable_if_t<classify_object<T>::value == object_category::wrapper_value, detail::enabler> = detail::dummy>
+bool lexical_cast(const std::string &input, T &output) {
+    typename T::value_type val;
+    if(lexical_cast(input, val)) {
+        output = T{val};
+        return true;
+    }
+    return from_stream(input, output);
+}
+
 /// Assignable from double or int
 template <
     typename T,
@@ -756,38 +1007,40 @@ bool lexical_cast(const std::string &input, T &output) {
 }
 
 /// Assign a value through lexical cast operations
-template <
-    typename T,
-    typename XC,
-    enable_if_t<std::is_same<T, XC>::value && (classify_object<T>::value == object_category::string_assignable ||
-                                               classify_object<T>::value == object_category::string_constructible),
-                detail::enabler> = detail::dummy>
-bool lexical_assign(const std::string &input, T &output) {
+/// Strings can be empty so we need to do a little different
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<std::is_same<AssignTo, ConvertTo>::value &&
+                          (classify_object<AssignTo>::value == object_category::string_assignable ||
+                           classify_object<AssignTo>::value == object_category::string_constructible),
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
     return lexical_cast(input, output);
 }
 
 /// Assign a value through lexical cast operations
-template <typename T,
-          typename XC,
-          enable_if_t<std::is_same<T, XC>::value && classify_object<T>::value != object_category::string_assignable &&
-                          classify_object<T>::value != object_category::string_constructible,
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<std::is_same<AssignTo, ConvertTo>::value &&
+                          classify_object<AssignTo>::value != object_category::string_assignable &&
+                          classify_object<AssignTo>::value != object_category::string_constructible,
                       detail::enabler> = detail::dummy>
-bool lexical_assign(const std::string &input, T &output) {
+bool lexical_assign(const std::string &input, AssignTo &output) {
     if(input.empty()) {
-        output = T{};
+        output = AssignTo{};
         return true;
     }
     return lexical_cast(input, output);
 }
 
 /// Assign a value converted from a string in lexical cast to the output value directly
-template <
-    typename T,
-    typename XC,
-    enable_if_t<!std::is_same<T, XC>::value && std::is_assignable<T &, XC &>::value, detail::enabler> = detail::dummy>
-bool lexical_assign(const std::string &input, T &output) {
-    XC val{};
-    bool parse_result = (!input.empty()) ? lexical_cast<XC>(input, val) : true;
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<!std::is_same<AssignTo, ConvertTo>::value && std::is_assignable<AssignTo &, ConvertTo &>::value,
+                      detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    ConvertTo val{};
+    bool parse_result = (!input.empty()) ? lexical_cast<ConvertTo>(input, val) : true;
     if(parse_result) {
         output = val;
     }
@@ -795,195 +1048,325 @@ bool lexical_assign(const std::string &input, T &output) {
 }
 
 /// Assign a value from a lexical cast through constructing a value and move assigning it
-template <typename T,
-          typename XC,
-          enable_if_t<!std::is_same<T, XC>::value && !std::is_assignable<T &, XC &>::value &&
-                          std::is_move_assignable<T>::value,
-                      detail::enabler> = detail::dummy>
-bool lexical_assign(const std::string &input, T &output) {
-    XC val{};
-    bool parse_result = input.empty() ? true : lexical_cast<XC>(input, val);
+template <
+    typename AssignTo,
+    typename ConvertTo,
+    enable_if_t<!std::is_same<AssignTo, ConvertTo>::value && !std::is_assignable<AssignTo &, ConvertTo &>::value &&
+                    std::is_move_assignable<AssignTo>::value,
+                detail::enabler> = detail::dummy>
+bool lexical_assign(const std::string &input, AssignTo &output) {
+    ConvertTo val{};
+    bool parse_result = input.empty() ? true : lexical_cast<ConvertTo>(input, val);
     if(parse_result) {
-        output = T(val);  // use () form of constructor to allow some implicit conversions
+        output = AssignTo(val);  // use () form of constructor to allow some implicit conversions
     }
     return parse_result;
 }
-/// Lexical conversion if there is only one element
-template <
-    typename T,
-    typename XC,
-    enable_if_t<!is_tuple_like<T>::value && !is_tuple_like<XC>::value && !is_vector<T>::value && !is_vector<XC>::value,
-                detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    return lexical_assign<T, XC>(strings[0], output);
+
+/// primary lexical conversion operation, 1 string to 1 type of some kind
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<classify_object<ConvertTo>::value <= object_category::other &&
+                          classify_object<AssignTo>::value <= object_category::wrapper_value,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    return lexical_assign<AssignTo, ConvertTo>(strings[0], output);
 }
 
-/// Lexical conversion if there is only one element but the conversion type is for two call a two element constructor
-template <typename T,
-          typename XC,
-          enable_if_t<type_count<T>::value == 1 && type_count<XC>::value == 2, detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    typename std::tuple_element<0, XC>::type v1;
-    typename std::tuple_element<1, XC>::type v2;
+/// Lexical conversion if there is only one element but the conversion type is for two, then call a two element
+/// constructor
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<(type_count<AssignTo>::value <= 2) && expected_count<AssignTo>::value == 1 &&
+                          is_tuple_like<ConvertTo>::value && type_count_base<ConvertTo>::value == 2,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    // the remove const is to handle pair types coming from a container
+    typename std::remove_const<typename std::tuple_element<0, ConvertTo>::type>::type v1;
+    typename std::tuple_element<1, ConvertTo>::type v2;
     bool retval = lexical_assign<decltype(v1), decltype(v1)>(strings[0], v1);
     if(strings.size() > 1) {
         retval = retval && lexical_assign<decltype(v2), decltype(v2)>(strings[1], v2);
     }
     if(retval) {
-        output = T{v1, v2};
+        output = AssignTo{v1, v2};
     }
     return retval;
 }
 
-/// Lexical conversion of a vector types
-template <class T,
-          class XC,
-          enable_if_t<expected_count<T>::value == expected_max_vector_size &&
-                          expected_count<XC>::value == expected_max_vector_size && type_count<XC>::value == 1,
+/// Lexical conversion of a container types of single elements
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count<ConvertTo>::value == 1,
                       detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    output.clear();
-    output.reserve(strings.size());
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
+    output.erase(output.begin(), output.end());
     for(const auto &elem : strings) {
-
-        output.emplace_back();
-        bool retval = lexical_assign<typename T::value_type, typename XC::value_type>(elem, output.back());
+        typename AssignTo::value_type out;
+        bool retval = lexical_assign<typename AssignTo::value_type, typename ConvertTo::value_type>(elem, out);
         if(!retval) {
             return false;
         }
+        output.insert(output.end(), std::move(out));
     }
     return (!output.empty());
 }
 
-/// Lexical conversion of a vector types with type size of two
-template <class T,
-          class XC,
-          enable_if_t<expected_count<T>::value == expected_max_vector_size &&
-                          expected_count<XC>::value == expected_max_vector_size && type_count<XC>::value == 2,
-                      detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    output.clear();
-    for(std::size_t ii = 0; ii < strings.size(); ii += 2) {
+/// Lexical conversion for complex types
+template <class AssignTo, class ConvertTo, enable_if_t<is_complex<ConvertTo>::value, detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output) {
 
-        typename std::tuple_element<0, typename XC::value_type>::type v1;
-        typename std::tuple_element<1, typename XC::value_type>::type v2;
-        bool retval = lexical_assign<decltype(v1), decltype(v1)>(strings[ii], v1);
-        if(strings.size() > ii + 1) {
-            retval = retval && lexical_assign<decltype(v2), decltype(v2)>(strings[ii + 1], v2);
+    if(strings.size() >= 2 && !strings[1].empty()) {
+        using XC2 = typename wrapped_type<ConvertTo, double>::type;
+        XC2 x{0.0}, y{0.0};
+        auto str1 = strings[1];
+        if(str1.back() == 'i' || str1.back() == 'j') {
+            str1.pop_back();
         }
-        if(retval) {
-            output.emplace_back(v1, v2);
-        } else {
-            return false;
+        auto worked = detail::lexical_cast(strings[0], x) && detail::lexical_cast(str1, y);
+        if(worked) {
+            output = ConvertTo{x, y};
         }
+        return worked;
+    } else {
+        return lexical_assign<AssignTo, ConvertTo>(strings[0], output);
     }
-    return (!output.empty());
 }
 
 /// Conversion to a vector type using a particular single type as the conversion type
-template <class T,
-          class XC,
-          enable_if_t<(expected_count<T>::value == expected_max_vector_size) && (expected_count<XC>::value == 1) &&
-                          (type_count<XC>::value == 1),
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && (expected_count<ConvertTo>::value == 1) &&
+                          (type_count<ConvertTo>::value == 1),
                       detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
     bool retval = true;
     output.clear();
     output.reserve(strings.size());
     for(const auto &elem : strings) {
 
         output.emplace_back();
-        retval = retval && lexical_assign<typename T::value_type, XC>(elem, output.back());
+        retval = retval && lexical_assign<typename AssignTo::value_type, ConvertTo>(elem, output.back());
     }
     return (!output.empty()) && retval;
 }
-// This one is last since it can call other lexical_conversion functions
-/// Lexical conversion if there is only one element but the conversion type is a vector
-template <typename T,
-          typename XC,
-          enable_if_t<!is_tuple_like<T>::value && !is_vector<T>::value && is_vector<XC>::value, detail::enabler> =
-              detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
+
+// forward declaration
+
+/// Lexical conversion of a container types with conversion type of two elements
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value == 2,
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(std::vector<std::string> strings, AssignTo &output);
+
+/// Lexical conversion of a vector types with type_size >2 forward declaration
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value != 2 &&
+                          ((type_count<ConvertTo>::value > 2) ||
+                           (type_count<ConvertTo>::value > type_count_base<ConvertTo>::value)),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output);
+
+/// Conversion for tuples
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_tuple_like<AssignTo>::value && is_tuple_like<ConvertTo>::value &&
+                          (type_count_base<ConvertTo>::value != type_count<ConvertTo>::value ||
+                           type_count<ConvertTo>::value > 2),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output); // forward declaration
+
+/// Conversion for operations where the assigned type is some class but the conversion is a mutable container or large
+/// tuple
+template <typename AssignTo,
+          typename ConvertTo,
+          enable_if_t<!is_tuple_like<AssignTo>::value && !is_mutable_container<AssignTo>::value &&
+                          classify_object<ConvertTo>::value != object_category::wrapper_value &&
+                          (is_mutable_container<ConvertTo>::value || type_count<ConvertTo>::value > 2),
+                      detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
 
     if(strings.size() > 1 || (!strings.empty() && !(strings.front().empty()))) {
-        XC val;
-        auto retval = lexical_conversion<XC, XC>(strings, val);
-        output = T{val};
+        ConvertTo val;
+        auto retval = lexical_conversion<ConvertTo, ConvertTo>(strings, val);
+        output = AssignTo{val};
         return retval;
     }
-    output = T{};
+    output = AssignTo{};
     return true;
 }
 
 /// function template for converting tuples if the static Index is greater than the tuple size
-template <class T, class XC, std::size_t I>
-inline typename std::enable_if<I >= type_count<T>::value, bool>::type tuple_conversion(const std::vector<std::string> &,
-                                                                                       T &) {
+template <class AssignTo, class ConvertTo, std::size_t I>
+inline typename std::enable_if<(I >= type_count_base<AssignTo>::value), bool>::type
+tuple_conversion(const std::vector<std::string> &, AssignTo &) {
     return true;
 }
+
+/// Conversion of a tuple element where the type size ==1 and not a mutable container
+template <class AssignTo, class ConvertTo>
+inline typename std::enable_if<!is_mutable_container<ConvertTo>::value && type_count<ConvertTo>::value == 1, bool>::type
+tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
+    auto retval = lexical_assign<AssignTo, ConvertTo>(strings[0], output);
+    strings.erase(strings.begin());
+    return retval;
+}
+
+/// Conversion of a tuple element where the type size !=1 but the size is fixed and not a mutable container
+template <class AssignTo, class ConvertTo>
+inline typename std::enable_if<!is_mutable_container<ConvertTo>::value && (type_count<ConvertTo>::value > 1) &&
+                                   type_count<ConvertTo>::value == type_count_min<ConvertTo>::value,
+                               bool>::type
+tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
+    auto retval = lexical_conversion<AssignTo, ConvertTo>(strings, output);
+    strings.erase(strings.begin(), strings.begin() + type_count<ConvertTo>::value);
+    return retval;
+}
+
+/// Conversion of a tuple element where the type is a mutable container or a type with different min and max type sizes
+template <class AssignTo, class ConvertTo>
+inline typename std::enable_if<is_mutable_container<ConvertTo>::value ||
+                                   type_count<ConvertTo>::value != type_count_min<ConvertTo>::value,
+                               bool>::type
+tuple_type_conversion(std::vector<std::string> &strings, AssignTo &output) {
+
+    std::size_t index{subtype_count_min<ConvertTo>::value};
+    const std::size_t mx_count{subtype_count<ConvertTo>::value};
+    const std::size_t mx{(std::max)(mx_count, strings.size())};
+
+    while(index < mx) {
+        if(is_separator(strings[index])) {
+            break;
+        }
+        ++index;
+    }
+    bool retval = lexical_conversion<AssignTo, ConvertTo>(
+        std::vector<std::string>(strings.begin(), strings.begin() + static_cast<std::ptrdiff_t>(index)), output);
+    strings.erase(strings.begin(), strings.begin() + static_cast<std::ptrdiff_t>(index) + 1);
+    return retval;
+}
+
 /// Tuple conversion operation
-template <class T, class XC, std::size_t I>
-    inline typename std::enable_if <
-    I<type_count<T>::value, bool>::type tuple_conversion(const std::vector<std::string> &strings, T &output) {
+template <class AssignTo, class ConvertTo, std::size_t I>
+inline typename std::enable_if<(I < type_count_base<AssignTo>::value), bool>::type
+tuple_conversion(std::vector<std::string> strings, AssignTo &output) {
     bool retval = true;
-    if(strings.size() > I) {
-        retval = retval && lexical_assign<typename std::tuple_element<I, T>::type,
-                                          typename std::conditional<is_tuple_like<XC>::value,
-                                                                    typename std::tuple_element<I, XC>::type,
-                                                                    XC>::type>(strings[I], std::get<I>(output));
+    using ConvertToElement = typename std::
+        conditional<is_tuple_like<ConvertTo>::value, typename std::tuple_element<I, ConvertTo>::type, ConvertTo>::type;
+    if(!strings.empty()) {
+        retval = retval && tuple_type_conversion<typename std::tuple_element<I, AssignTo>::type, ConvertToElement>(
+                               strings, std::get<I>(output));
     }
-    retval = retval && tuple_conversion<T, XC, I + 1>(strings, output);
+    retval = retval && tuple_conversion<AssignTo, ConvertTo, I + 1>(std::move(strings), output);
     return retval;
 }
 
-/// Conversion for tuples
-template <class T, class XC, enable_if_t<is_tuple_like<T>::value, detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
+/// Lexical conversion of a container types with tuple elements of size 2
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value == 2,
+                      detail::enabler>>
+bool lexical_conversion(std::vector<std::string> strings, AssignTo &output) {
+    output.clear();
+    while(!strings.empty()) {
+
+        typename std::remove_const<typename std::tuple_element<0, typename ConvertTo::value_type>::type>::type v1;
+        typename std::tuple_element<1, typename ConvertTo::value_type>::type v2;
+        bool retval = tuple_type_conversion<decltype(v1), decltype(v1)>(strings, v1);
+        if(!strings.empty()) {
+            retval = retval && tuple_type_conversion<decltype(v2), decltype(v2)>(strings, v2);
+        }
+        if(retval) {
+            output.insert(output.end(), typename AssignTo::value_type{v1, v2});
+        } else {
+            return false;
+        }
+    }
+    return (!output.empty());
+}
+
+/// lexical conversion of tuples with type count>2 or tuples of types of some element with a type size>=2
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_tuple_like<AssignTo>::value && is_tuple_like<ConvertTo>::value &&
+                          (type_count_base<ConvertTo>::value != type_count<ConvertTo>::value ||
+                           type_count<ConvertTo>::value > 2),
+                      detail::enabler>>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
     static_assert(
-        !is_tuple_like<XC>::value || type_count<T>::value == type_count<XC>::value,
+        !is_tuple_like<ConvertTo>::value || type_count_base<AssignTo>::value == type_count_base<ConvertTo>::value,
         "if the conversion type is defined as a tuple it must be the same size as the type you are converting to");
-    return tuple_conversion<T, XC, 0>(strings, output);
+    return tuple_conversion<AssignTo, ConvertTo, 0>(strings, output);
 }
 
-/// Lexical conversion of a vector types with type_size >2
-template <class T,
-          class XC,
-          enable_if_t<expected_count<T>::value == expected_max_vector_size &&
-                          expected_count<XC>::value == expected_max_vector_size && (type_count<XC>::value > 2),
-                      detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
+/// Lexical conversion of a vector types for everything but tuples of two elements and types of size 1
+template <class AssignTo,
+          class ConvertTo,
+          enable_if_t<is_mutable_container<AssignTo>::value && is_mutable_container<ConvertTo>::value &&
+                          type_count_base<ConvertTo>::value != 2 &&
+                          ((type_count<ConvertTo>::value > 2) ||
+                           (type_count<ConvertTo>::value > type_count_base<ConvertTo>::value)),
+                      detail::enabler>>
+bool lexical_conversion(const std::vector<std ::string> &strings, AssignTo &output) {
     bool retval = true;
     output.clear();
     std::vector<std::string> temp;
-    std::size_t ii = 0;
-    std::size_t icount = 0;
-    std::size_t xcm = type_count<XC>::value;
-    while(ii < strings.size()) {
+    std::size_t ii{0};
+    std::size_t icount{0};
+    std::size_t xcm{type_count<ConvertTo>::value};
+    auto ii_max = strings.size();
+    while(ii < ii_max) {
         temp.push_back(strings[ii]);
         ++ii;
         ++icount;
-        if(icount == xcm || temp.back().empty()) {
-            if(static_cast<int>(xcm) == expected_max_vector_size) {
+        if(icount == xcm || is_separator(temp.back()) || ii == ii_max) {
+            if(static_cast<int>(xcm) > type_count_min<ConvertTo>::value && is_separator(temp.back())) {
                 temp.pop_back();
             }
-            output.emplace_back();
-            retval = retval && lexical_conversion<typename T::value_type, typename XC::value_type>(temp, output.back());
+            typename AssignTo::value_type temp_out;
+            retval = retval &&
+                     lexical_conversion<typename AssignTo::value_type, typename ConvertTo::value_type>(temp, temp_out);
             temp.clear();
             if(!retval) {
                 return false;
             }
+            output.insert(output.end(), std::move(temp_out));
             icount = 0;
         }
     }
     return retval;
 }
+
+/// conversion for wrapper types
+template <
+    typename AssignTo,
+    class ConvertTo,
+    enable_if_t<classify_object<ConvertTo>::value == object_category::wrapper_value, detail::enabler> = detail::dummy>
+bool lexical_conversion(const std::vector<std::string> &strings, AssignTo &output) {
+    if(strings.empty() || strings.front().empty()) {
+        output = ConvertTo{};
+        return true;
+    }
+    typename ConvertTo::value_type val;
+    if(lexical_conversion<typename ConvertTo::value_type, typename ConvertTo::value_type>(strings, val)) {
+        output = ConvertTo{val};
+        return true;
+    }
+    return false;
+}
+
 /// Sum a vector of flag representations
 /// The flag vector produces a series of strings in a vector,  simple true is represented by a "1",  simple false is
 /// by
 /// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
 /// common true and false strings then uses stoll to convert the rest for summing
-template <typename T,
-          enable_if_t<std::is_integral<T>::value && std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
+template <typename T, enable_if_t<std::is_unsigned<T>::value, detail::enabler> = detail::dummy>
 void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
     std::int64_t count{0};
     for(auto &flag : flags) {
@@ -997,8 +1380,7 @@ void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
 /// by
 /// "-1" an if numbers are passed by some fashion they are captured as well so the function just checks for the most
 /// common true and false strings then uses stoll to convert the rest for summing
-template <typename T,
-          enable_if_t<std::is_integral<T>::value && std::is_signed<T>::value, detail::enabler> = detail::dummy>
+template <typename T, enable_if_t<std::is_signed<T>::value, detail::enabler> = detail::dummy>
 void sum_flag_vector(const std::vector<std::string> &flags, T &output) {
     std::int64_t count{0};
     for(auto &flag : flags) {
diff --git a/tests/AppTest.cpp b/tests/AppTest.cpp
index 671a64681..b041ec4ef 100644
--- a/tests/AppTest.cpp
+++ b/tests/AppTest.cpp
@@ -454,98 +454,6 @@ TEST_F(TApp, SepInt) {
     EXPECT_EQ(i, 4);
 }
 
-TEST_F(TApp, OneStringAgain) {
-    std::string str;
-    app.add_option("-s,--string", str);
-    args = {"--string", "mystring"};
-    run();
-    EXPECT_EQ(1u, app.count("-s"));
-    EXPECT_EQ(1u, app.count("--string"));
-    EXPECT_EQ(str, "mystring");
-}
-
-TEST_F(TApp, OneStringFunction) {
-    std::string str;
-    app.add_option_function<std::string>("-s,--string", [&str](const std::string &val) { str = val; });
-    args = {"--string", "mystring"};
-    run();
-    EXPECT_EQ(1u, app.count("-s"));
-    EXPECT_EQ(1u, app.count("--string"));
-    EXPECT_EQ(str, "mystring");
-}
-
-TEST_F(TApp, doubleFunction) {
-    double res{0.0};
-    app.add_option_function<double>("--val", [&res](double val) { res = std::abs(val + 54); });
-    args = {"--val", "-354.356"};
-    run();
-    EXPECT_EQ(res, 300.356);
-    // get the original value as entered as an integer
-    EXPECT_EQ(app["--val"]->as<float>(), -354.356f);
-}
-
-TEST_F(TApp, doubleFunctionFail) {
-    double res;
-    app.add_option_function<double>("--val", [&res](double val) { res = std::abs(val + 54); });
-    args = {"--val", "not_double"};
-    EXPECT_THROW(run(), CLI::ConversionError);
-}
-
-TEST_F(TApp, doubleVectorFunction) {
-    std::vector<double> res;
-    app.add_option_function<std::vector<double>>("--val", [&res](const std::vector<double> &val) {
-        res = val;
-        std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
-    });
-    args = {"--val", "5", "--val", "6", "--val", "7"};
-    run();
-    EXPECT_EQ(res.size(), 3u);
-    EXPECT_EQ(res[0], 10.0);
-    EXPECT_EQ(res[2], 12.0);
-}
-
-TEST_F(TApp, doubleVectorFunctionFail) {
-    std::vector<double> res;
-    std::string vstring = "--val";
-    app.add_option_function<std::vector<double>>(vstring, [&res](const std::vector<double> &val) {
-        res = val;
-        std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
-    });
-    args = {"--val", "five", "--val", "nine", "--val", "7"};
-    EXPECT_THROW(run(), CLI::ConversionError);
-    // check that getting the results through the results function generates the same error
-    EXPECT_THROW(app[vstring]->results(res), CLI::ConversionError);
-    auto strvec = app[vstring]->as<std::vector<std::string>>();
-    EXPECT_EQ(strvec.size(), 3u);
-}
-
-TEST_F(TApp, doubleVectorFunctionRunCallbackOnDefault) {
-    std::vector<double> res;
-    auto opt = app.add_option_function<std::vector<double>>("--val", [&res](const std::vector<double> &val) {
-        res = val;
-        std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
-    });
-    args = {"--val", "5", "--val", "6", "--val", "7"};
-    run();
-    EXPECT_EQ(res.size(), 3u);
-    EXPECT_EQ(res[0], 10.0);
-    EXPECT_EQ(res[2], 12.0);
-    EXPECT_FALSE(opt->get_run_callback_for_default());
-    opt->run_callback_for_default();
-    opt->default_val(std::vector<int>{2, 1, -2});
-    EXPECT_EQ(res[0], 7.0);
-    EXPECT_EQ(res[2], 3.0);
-
-    EXPECT_THROW(opt->default_val("this is a string"), CLI::ConversionError);
-    auto vec = opt->as<std::vector<double>>();
-    ASSERT_EQ(vec.size(), 3U);
-    EXPECT_EQ(vec[0], 5.0);
-    EXPECT_EQ(vec[2], 7.0);
-    opt->check(CLI::Number);
-    opt->run_callback_for_default(false);
-    EXPECT_THROW(opt->default_val("this is a string"), CLI::ValidationError);
-}
-
 TEST_F(TApp, DefaultStringAgain) {
     std::string str = "previous";
     app.add_option("-s,--string", str);
@@ -647,35 +555,6 @@ TEST_F(TApp, LotsOfFlagsSingleStringExtraSpace) {
     EXPECT_EQ(1u, app.count("-A"));
 }
 
-TEST_F(TApp, BoolAndIntFlags) {
-
-    bool bflag{false};
-    int iflag{0};
-    unsigned int uflag{0};
-
-    app.add_flag("-b", bflag);
-    app.add_flag("-i", iflag);
-    app.add_flag("-u", uflag);
-
-    args = {"-b", "-i", "-u"};
-    run();
-    EXPECT_TRUE(bflag);
-    EXPECT_EQ(1, iflag);
-    EXPECT_EQ((unsigned int)1, uflag);
-
-    args = {"-b", "-b"};
-    ASSERT_NO_THROW(run());
-    EXPECT_TRUE(bflag);
-
-    bflag = false;
-
-    args = {"-iiiuu"};
-    run();
-    EXPECT_FALSE(bflag);
-    EXPECT_EQ(3, iflag);
-    EXPECT_EQ((unsigned int)2, uflag);
-}
-
 TEST_F(TApp, FlagLikeOption) {
     bool val{false};
     auto opt = app.add_option("--flag", val)->type_size(0)->default_str("true");
@@ -724,32 +603,6 @@ TEST_F(TApp, BoolOnlyFlag) {
     EXPECT_THROW(run(), CLI::ArgumentMismatch);
 }
 
-TEST_F(TApp, BoolOption) {
-    bool bflag{false};
-    app.add_option("-b", bflag);
-
-    args = {"-b", "false"};
-    run();
-    EXPECT_FALSE(bflag);
-
-    args = {"-b", "1"};
-    run();
-    EXPECT_TRUE(bflag);
-
-    args = {"-b", "-7"};
-    run();
-    EXPECT_FALSE(bflag);
-
-    // cause an out of bounds error internally
-    args = {"-b", "751615654161688126132138844896646748852"};
-    run();
-    EXPECT_TRUE(bflag);
-
-    args = {"-b", "-751615654161688126132138844896646748852"};
-    run();
-    EXPECT_FALSE(bflag);
-}
-
 TEST_F(TApp, ShortOpts) {
 
     unsigned long long funnyint{0};
@@ -892,37 +745,6 @@ TEST_F(TApp, TakeLastOptMulti) {
     EXPECT_EQ(vals, std::vector<int>({2, 3}));
 }
 
-TEST_F(TApp, vectorDefaults) {
-    std::vector<int> vals{4, 5};
-    auto opt = app.add_option("--long", vals, "", true);
-
-    args = {"--long", "[1,2,3]"};
-
-    run();
-
-    EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
-
-    args.clear();
-    run();
-    auto res = app["--long"]->as<std::vector<int>>();
-    EXPECT_EQ(res, std::vector<int>({4, 5}));
-
-    app.clear();
-    opt->expected(1)->take_last();
-    res = app["--long"]->as<std::vector<int>>();
-    EXPECT_EQ(res, std::vector<int>({5}));
-    opt->take_first();
-    res = app["--long"]->as<std::vector<int>>();
-    EXPECT_EQ(res, std::vector<int>({4}));
-
-    opt->expected(0, 1)->take_last();
-    run();
-
-    EXPECT_EQ(res, std::vector<int>({4}));
-    res = app["--long"]->as<std::vector<int>>();
-    EXPECT_EQ(res, std::vector<int>({5}));
-}
-
 TEST_F(TApp, TakeLastOptMulti_alternative_path) {
     std::vector<int> vals;
     app.add_option("--long", vals)->expected(2, -1)->take_last();
@@ -1452,27 +1274,6 @@ TEST_F(TApp, CallbackFlags) {
     EXPECT_THROW(app.add_flag_function("hi", func), CLI::IncorrectConstruction);
 }
 
-TEST_F(TApp, CallbackBoolFlags) {
-
-    bool value{false};
-
-    auto func = [&value]() { value = true; };
-
-    auto cback = app.add_flag_callback("--val", func);
-    args = {"--val"};
-    run();
-    EXPECT_TRUE(value);
-    value = false;
-    args = {"--val=false"};
-    run();
-    EXPECT_FALSE(value);
-
-    EXPECT_THROW(app.add_flag_callback("hi", func), CLI::IncorrectConstruction);
-    cback->multi_option_policy(CLI::MultiOptionPolicy::Throw);
-    args = {"--val", "--val=false"};
-    EXPECT_THROW(run(), CLI::ArgumentMismatch);
-}
-
 TEST_F(TApp, CallbackFlagsFalse) {
     std::int64_t value = 0;
 
@@ -1747,107 +1548,6 @@ TEST_F(TApp, NotFileExists) {
     EXPECT_FALSE(CLI::ExistingFile(myfile).empty());
 }
 
-TEST_F(TApp, pair_check) {
-    std::string myfile{"pair_check_file.txt"};
-    bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a'));  // create file
-    EXPECT_TRUE(ok);
-
-    EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
-    std::pair<std::string, int> findex;
-
-    auto v0 = CLI::ExistingFile;
-    v0.application_index(0);
-    auto v1 = CLI::PositiveNumber;
-    v1.application_index(1);
-    app.add_option("--file", findex)->check(v0)->check(v1);
-
-    args = {"--file", myfile, "2"};
-
-    EXPECT_NO_THROW(run());
-
-    EXPECT_EQ(findex.first, myfile);
-    EXPECT_EQ(findex.second, 2);
-
-    args = {"--file", myfile, "-3"};
-
-    EXPECT_THROW(run(), CLI::ValidationError);
-
-    args = {"--file", myfile, "2"};
-    std::remove(myfile.c_str());
-    EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-// this will require that modifying the multi-option policy for tuples be allowed which it isn't at present
-
-TEST_F(TApp, pair_check_take_first) {
-    std::string myfile{"pair_check_file2.txt"};
-    bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a'));  // create file
-    EXPECT_TRUE(ok);
-
-    EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
-    std::pair<std::string, int> findex;
-
-    auto opt = app.add_option("--file", findex)->check(CLI::ExistingFile)->check(CLI::PositiveNumber);
-    EXPECT_THROW(opt->get_validator(3), CLI::OptionNotFound);
-    opt->get_validator(0)->application_index(0);
-    opt->get_validator(1)->application_index(1);
-    opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
-    args = {"--file", "not_a_file.txt", "-16", "--file", myfile, "2"};
-    // should only check the last one
-    EXPECT_NO_THROW(run());
-
-    EXPECT_EQ(findex.first, myfile);
-    EXPECT_EQ(findex.second, 2);
-
-    opt->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst);
-
-    EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, VectorFixedString) {
-    std::vector<std::string> strvec;
-    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
-
-    CLI::Option *opt = app.add_option("-s,--string", strvec)->expected(3);
-    EXPECT_EQ(3, opt->get_expected());
-
-    args = {"--string", "mystring", "mystring2", "mystring3"};
-    run();
-    EXPECT_EQ(3u, app.count("--string"));
-    EXPECT_EQ(answer, strvec);
-}
-
-TEST_F(TApp, VectorDefaultedFixedString) {
-    std::vector<std::string> strvec{"one"};
-    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
-
-    CLI::Option *opt = app.add_option("-s,--string", strvec, "")->expected(3)->capture_default_str();
-    EXPECT_EQ(3, opt->get_expected());
-
-    args = {"--string", "mystring", "mystring2", "mystring3"};
-    run();
-    EXPECT_EQ(3u, app.count("--string"));
-    EXPECT_EQ(answer, strvec);
-}
-
-TEST_F(TApp, VectorIndexedValidator) {
-    std::vector<int> vvec;
-
-    CLI::Option *opt = app.add_option("-v", vvec);
-
-    args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
-    run();
-    EXPECT_EQ(4u, app.count("-v"));
-    EXPECT_EQ(4u, vvec.size());
-    opt->check(CLI::PositiveNumber.application_index(0));
-    opt->check((!CLI::PositiveNumber).application_index(1));
-    EXPECT_NO_THROW(run());
-    EXPECT_EQ(4u, vvec.size());
-    // v[3] would be negative
-    opt->check(CLI::PositiveNumber.application_index(3));
-    EXPECT_THROW(run(), CLI::ValidationError);
-}
-
 TEST_F(TApp, DefaultedResult) {
     std::string sval = "NA";
     int ival{0};
@@ -1866,93 +1566,6 @@ TEST_F(TApp, DefaultedResult) {
     EXPECT_EQ(newIval, 442);
 }
 
-TEST_F(TApp, VectorUnlimString) {
-    std::vector<std::string> strvec;
-    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
-
-    CLI::Option *opt = app.add_option("-s,--string", strvec);
-    EXPECT_EQ(1, opt->get_expected());
-    EXPECT_EQ(CLI::detail::expected_max_vector_size, opt->get_expected_max());
-
-    args = {"--string", "mystring", "mystring2", "mystring3"};
-    run();
-    EXPECT_EQ(3u, app.count("--string"));
-    EXPECT_EQ(answer, strvec);
-
-    args = {"-s", "mystring", "mystring2", "mystring3"};
-    run();
-    EXPECT_EQ(3u, app.count("--string"));
-    EXPECT_EQ(answer, strvec);
-}
-
-// From https://github.com/CLIUtils/CLI11/issues/420
-TEST_F(TApp, stringLikeTests) {
-    struct nType {
-        explicit nType(const std::string &a_value) : m_value{a_value} {}
-
-        explicit operator std::string() const { return std::string{"op str"}; }
-
-        std::string m_value;
-    };
-
-    nType m_type{"abc"};
-    app.add_option("--type", m_type, "type")->capture_default_str();
-    run();
-
-    EXPECT_EQ(app["--type"]->as<std::string>(), "op str");
-    args = {"--type", "bca"};
-    run();
-    EXPECT_EQ(std::string(m_type), "op str");
-    EXPECT_EQ(m_type.m_value, "bca");
-}
-
-TEST_F(TApp, VectorExpectedRange) {
-    std::vector<std::string> strvec;
-
-    CLI::Option *opt = app.add_option("--string", strvec);
-    opt->expected(2, 4)->multi_option_policy(CLI::MultiOptionPolicy::Throw);
-
-    args = {"--string", "mystring", "mystring2", "mystring3"};
-    run();
-    EXPECT_EQ(3u, app.count("--string"));
-
-    args = {"--string", "mystring"};
-    EXPECT_THROW(run(), CLI::ArgumentMismatch);
-
-    args = {"--string", "mystring", "mystring2", "string2", "--string", "string4", "string5"};
-    EXPECT_THROW(run(), CLI::ArgumentMismatch);
-
-    EXPECT_EQ(opt->get_expected_max(), 4);
-    EXPECT_EQ(opt->get_expected_min(), 2);
-    opt->expected(4, 2);  // just test the handling of reversed arguments
-    EXPECT_EQ(opt->get_expected_max(), 4);
-    EXPECT_EQ(opt->get_expected_min(), 2);
-    opt->expected(-5);
-    EXPECT_EQ(opt->get_expected_max(), 5);
-    EXPECT_EQ(opt->get_expected_min(), 5);
-    opt->expected(-5, 7);
-    EXPECT_EQ(opt->get_expected_max(), 7);
-    EXPECT_EQ(opt->get_expected_min(), 5);
-}
-
-TEST_F(TApp, VectorFancyOpts) {
-    std::vector<std::string> strvec;
-    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
-
-    CLI::Option *opt = app.add_option("-s,--string", strvec)->required()->expected(3);
-    EXPECT_EQ(3, opt->get_expected());
-
-    args = {"--string", "mystring", "mystring2", "mystring3"};
-    run();
-    EXPECT_EQ(3u, app.count("--string"));
-    EXPECT_EQ(answer, strvec);
-
-    args = {"one", "two"};
-    EXPECT_THROW(run(), CLI::RequiredError);
-
-    EXPECT_THROW(run(), CLI::ParseError);
-}
-
 TEST_F(TApp, OriginalOrder) {
     std::vector<int> st1;
     CLI::Option *op1 = app.add_option("-a", st1);
@@ -2386,170 +1999,6 @@ TEST_F(TApp, EachItem) {
     EXPECT_EQ(results, dummy);
 }
 
-// #87
-TEST_F(TApp, CustomDoubleOption) {
-
-    std::pair<int, double> custom_opt;
-
-    auto opt = app.add_option("posit", [&custom_opt](CLI::results_t vals) {
-        custom_opt = {stol(vals.at(0)), stod(vals.at(1))};
-        return true;
-    });
-    opt->type_name("INT FLOAT")->type_size(2);
-
-    args = {"12", "1.5"};
-
-    run();
-    EXPECT_EQ(custom_opt.first, 12);
-    EXPECT_DOUBLE_EQ(custom_opt.second, 1.5);
-}
-
-// now with tuple support this is possible
-TEST_F(TApp, CustomDoubleOptionAlt) {
-
-    std::pair<int, double> custom_opt;
-
-    app.add_option("posit", custom_opt);
-
-    args = {"12", "1.5"};
-
-    run();
-    EXPECT_EQ(custom_opt.first, 12);
-    EXPECT_DOUBLE_EQ(custom_opt.second, 1.5);
-}
-
-// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorPair) {
-
-    std::vector<std::pair<int, std::string>> custom_opt;
-
-    auto opt = app.add_option("--dict", custom_opt);
-
-    args = {"--dict", "1", "str1", "--dict", "3", "str3"};
-
-    run();
-    EXPECT_EQ(custom_opt.size(), 2u);
-    EXPECT_EQ(custom_opt[0].first, 1);
-    EXPECT_EQ(custom_opt[1].second, "str3");
-
-    args = {"--dict", "1", "str1", "--dict", "3", "str3", "--dict", "-1", "str4"};
-    run();
-    EXPECT_EQ(custom_opt.size(), 3u);
-    EXPECT_EQ(custom_opt[2].first, -1);
-    EXPECT_EQ(custom_opt[2].second, "str4");
-    opt->check(CLI::PositiveNumber.application_index(0));
-
-    EXPECT_THROW(run(), CLI::ValidationError);
-}
-
-TEST_F(TApp, vectorPairFail) {
-
-    std::vector<std::pair<int, std::string>> custom_opt;
-
-    app.add_option("--dict", custom_opt);
-
-    args = {"--dict", "1", "str1", "--dict", "str3", "1"};
-
-    EXPECT_THROW(run(), CLI::ConversionError);
-}
-
-TEST_F(TApp, vectorPairTypeRange) {
-
-    std::vector<std::pair<int, std::string>> custom_opt;
-
-    auto opt = app.add_option("--dict", custom_opt);
-
-    opt->type_size(2, 1);  // just test switched arguments
-    EXPECT_EQ(opt->get_type_size_min(), 1);
-    EXPECT_EQ(opt->get_type_size_max(), 2);
-
-    args = {"--dict", "1", "str1", "--dict", "3", "str3"};
-
-    run();
-    EXPECT_EQ(custom_opt.size(), 2u);
-    EXPECT_EQ(custom_opt[0].first, 1);
-    EXPECT_EQ(custom_opt[1].second, "str3");
-
-    args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
-    run();
-    EXPECT_EQ(custom_opt.size(), 3u);
-    EXPECT_TRUE(custom_opt[1].second.empty());
-    EXPECT_EQ(custom_opt[2].first, -1);
-    EXPECT_EQ(custom_opt[2].second, "str4");
-
-    opt->type_size(-2, -1);  // test negative arguments
-    EXPECT_EQ(opt->get_type_size_min(), 1);
-    EXPECT_EQ(opt->get_type_size_max(), 2);
-    // this type size spec should run exactly as before
-    run();
-    EXPECT_EQ(custom_opt.size(), 3u);
-    EXPECT_TRUE(custom_opt[1].second.empty());
-    EXPECT_EQ(custom_opt[2].first, -1);
-    EXPECT_EQ(custom_opt[2].second, "str4");
-}
-
-// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorTuple) {
-
-    std::vector<std::tuple<int, std::string, double>> custom_opt;
-
-    auto opt = app.add_option("--dict", custom_opt);
-
-    args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
-
-    run();
-    EXPECT_EQ(custom_opt.size(), 2u);
-    EXPECT_EQ(std::get<0>(custom_opt[0]), 1);
-    EXPECT_EQ(std::get<1>(custom_opt[1]), "str3");
-    EXPECT_EQ(std::get<2>(custom_opt[1]), 2.7);
-
-    args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
-    run();
-    EXPECT_EQ(custom_opt.size(), 3u);
-    EXPECT_EQ(std::get<0>(custom_opt[2]), -1);
-    EXPECT_EQ(std::get<1>(custom_opt[2]), "str4");
-    EXPECT_EQ(std::get<2>(custom_opt[2]), -1.87);
-    opt->check(CLI::PositiveNumber.application_index(0));
-
-    EXPECT_THROW(run(), CLI::ValidationError);
-
-    args.back() = "haha";
-    args[9] = "45";
-    EXPECT_THROW(run(), CLI::ConversionError);
-}
-
-// now with independent type sizes and expected this is possible
-TEST_F(TApp, vectorVector) {
-
-    std::vector<std::vector<int>> custom_opt;
-
-    auto opt = app.add_option("--dict", custom_opt);
-
-    args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
-
-    run();
-    EXPECT_EQ(custom_opt.size(), 2u);
-    EXPECT_EQ(custom_opt[0].size(), 3u);
-    EXPECT_EQ(custom_opt[1].size(), 2u);
-
-    args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
-            "3",      "3", "3", "3", "3",      "3", "3", "3",      "3", "-3"};
-    run();
-    EXPECT_EQ(custom_opt.size(), 4u);
-    EXPECT_EQ(custom_opt[0].size(), 3u);
-    EXPECT_EQ(custom_opt[1].size(), 2u);
-    EXPECT_EQ(custom_opt[2].size(), 1u);
-    EXPECT_EQ(custom_opt[3].size(), 10u);
-    opt->check(CLI::PositiveNumber.application_index(9));
-
-    EXPECT_THROW(run(), CLI::ValidationError);
-    args.pop_back();
-    EXPECT_NO_THROW(run());
-
-    args.back() = "haha";
-    EXPECT_THROW(run(), CLI::ConversionError);
-}
-
 // #128
 TEST_F(TApp, RepeatingMultiArgumentOptions) {
     std::vector<std::string> entries;
diff --git a/tests/BoostOptionTypeTest.cpp b/tests/BoostOptionTypeTest.cpp
new file mode 100644
index 000000000..c0dbfad49
--- /dev/null
+++ b/tests/BoostOptionTypeTest.cpp
@@ -0,0 +1,141 @@
+#include "app_helper.hpp"
+#include <boost/container/flat_map.hpp>
+#include <boost/container/flat_set.hpp>
+#include <boost/container/slist.hpp>
+#include <boost/container/small_vector.hpp>
+#include <boost/container/stable_vector.hpp>
+#include <boost/container/static_vector.hpp>
+#include <boost/container/vector.hpp>
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+
+using namespace boost::container;
+
+template <class T> class TApp_container_single_boost : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_single_boost() : TApp(){};
+};
+
+using containerTypes_single_boost =
+    ::testing::Types<small_vector<int, 2>, small_vector<int, 3>, flat_set<int>, stable_vector<int>, slist<int>>;
+
+TYPED_TEST_SUITE(TApp_container_single_boost, containerTypes_single_boost, );
+
+TYPED_TEST(TApp_container_single_boost, containerInt_boost) {
+
+    auto &cv = TApp_container_single_boost<TypeParam>::cval;
+    CLI::Option *opt = (TApp::app).add_option("-v", cv);
+
+    TApp::args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
+    TApp::run();
+    EXPECT_EQ(4u, (TApp::app).count("-v"));
+    EXPECT_EQ(4u, cv.size());
+    opt->check(CLI::PositiveNumber.application_index(0));
+    opt->check((!CLI::PositiveNumber).application_index(1));
+    EXPECT_NO_THROW(TApp::run());
+    EXPECT_EQ(4u, cv.size());
+    // v[3] would be negative
+    opt->check(CLI::PositiveNumber.application_index(3));
+    EXPECT_THROW(TApp::run(), CLI::ValidationError);
+}
+
+template <class T> class TApp_container_pair_boost : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_pair_boost() : TApp(){};
+};
+
+using isp = std::pair<int, std::string>;
+using containerTypes_pair_boost = ::testing::
+    Types<stable_vector<isp>, small_vector<isp, 2>, flat_set<isp>, slist<isp>, vector<isp>, flat_map<int, std::string>>;
+
+TYPED_TEST_SUITE(TApp_container_pair_boost, containerTypes_pair_boost, );
+
+TYPED_TEST(TApp_container_pair_boost, containerPair_boost) {
+
+    auto &cv = TApp_container_pair_boost<TypeParam>::cval;
+    (TApp::app).add_option("--dict", cv);
+
+    TApp::args = {"--dict", "1", "str1", "--dict", "3", "str3"};
+
+    TApp::run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    TApp::args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
+    TApp::run();
+    EXPECT_EQ(cv.size(), 3u);
+}
+
+template <class T> class TApp_container_tuple_boost : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_tuple_boost() : TApp(){};
+};
+
+using tup_obj = std::tuple<int, std::string, double>;
+using containerTypes_tuple_boost =
+    ::testing::Types<small_vector<tup_obj, 3>, stable_vector<tup_obj>, flat_set<tup_obj>, slist<tup_obj>>;
+
+TYPED_TEST_SUITE(TApp_container_tuple_boost, containerTypes_tuple_boost, );
+
+TYPED_TEST(TApp_container_tuple_boost, containerTuple_boost) {
+
+    auto &cv = TApp_container_tuple_boost<TypeParam>::cval;
+    (TApp::app).add_option("--dict", cv);
+
+    TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
+
+    TApp::run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
+    TApp::run();
+    EXPECT_EQ(cv.size(), 3u);
+}
+
+using icontainer1 = vector<int>;
+using icontainer2 = flat_set<int>;
+using icontainer3 = slist<int>;
+using containerTypes_container_boost = ::testing::Types<std::vector<icontainer1>,
+                                                        slist<icontainer1>,
+                                                        flat_set<icontainer1>,
+                                                        small_vector<icontainer1, 2>,
+                                                        std::vector<icontainer2>,
+                                                        slist<icontainer2>,
+                                                        flat_set<icontainer2>,
+                                                        stable_vector<icontainer2>,
+                                                        static_vector<icontainer3, 10>,
+                                                        slist<icontainer3>,
+                                                        flat_set<icontainer3>,
+                                                        static_vector<icontainer3, 10>>;
+
+template <class T> class TApp_container_container_boost : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_container_boost() : TApp(){};
+};
+
+TYPED_TEST_SUITE(TApp_container_container_boost, containerTypes_container_boost, );
+
+TYPED_TEST(TApp_container_container_boost, containerContainer_boost) {
+
+    auto &cv = TApp_container_container_boost<TypeParam>::cval;
+    (TApp::app).add_option("--dict", cv);
+
+    TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
+
+    TApp::run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
+                  "3",      "3", "3", "3", "3",      "3", "3", "3",      "3", "-3"};
+    TApp::run();
+    EXPECT_EQ(cv.size(), 4u);
+}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index f697867d7..7e76321e4 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -32,13 +32,19 @@ endif()
 set(GOOGLE_TEST_INDIVIDUAL OFF)
 include(AddGoogletest)
 
+# Add boost to test boost::optional if available
+find_package(Boost 1.61)
+
+set(boost-optional-def $<$<BOOL:${Boost_FOUND}>:CLI11_BOOST_OPTIONAL>)
+
 set(CLI11_TESTS
     HelpersTest
     ConfigFileTest
+    OptionTypeTest
     SimpleTest
     AppTest
     SetTest
-	TransformTest
+    TransformTest
     CreationTest
     SubcommandTest
     HelpTest
@@ -47,6 +53,7 @@ set(CLI11_TESTS
     OptionalTest
     DeprecatedTest
     StringParseTest
+    ComplexTypeTest
     TrueFalseTest
     OptionGroupTest
     )
@@ -55,6 +62,10 @@ if(WIN32)
     list(APPEND CLI11_TESTS WindowsTest)
 endif()
 
+if (Boost_FOUND)
+   list(APPEND CLI11_TESTS BoostOptionTypeTest)
+endif()
+
 set(CLI11_MULTIONLY_TESTS TimerTest)
 
 # Only affects current directory, so safe
@@ -140,20 +151,29 @@ file(WRITE "${PROJECT_BINARY_DIR}/CTestCustom.cmake"
     "set(CTEST_CUSTOM_PRE_TEST \"${CMAKE_BINARY_DIR}/informational\")"
 )
 
-# Add boost to test boost::optional if available
-find_package(Boost 1.61)
-
-set(boost-optional-def $<$<BOOL:${Boost_FOUND}>:CLI11_BOOST_OPTIONAL>)
-
 target_compile_definitions(informational PRIVATE ${boost-optional-def})
 target_compile_definitions(OptionalTest PRIVATE ${boost-optional-def})
 
+message(STATUS "Boost libs=${Boost_INCLUDE_DIRS}")
+
 if(TARGET Boost::boost)
+    message(STATUS "including boost target")
     target_link_libraries(informational PRIVATE Boost::boost)
     target_link_libraries(OptionalTest PRIVATE Boost::boost)
+    target_link_libraries(BoostOptionTypeTest PRIVATE Boost::boost)
+    if(CLI11_SINGLE_FILE AND CLI11_SINGLE_FILE_TESTS)
+       target_link_libraries(OptionalTest_Single PRIVATE Boost::boost)
+       target_link_libraries(BoostOptionTypeTest_Single PRIVATE Boost::boost)
+    endif()
 elseif(BOOST_FOUND)
+message(STATUS "no boost target")
     target_include_directories(informational PRIVATE ${Boost_INCLUDE_DIRS})
     target_include_directories(OptionalTest PRIVATE ${Boost_INCLUDE_DIRS})
+    target_include_directories(BoostOptionTypeTest PRIVATE ${Boost_INCLUDE_DIRS})
+    if(CLI11_SINGLE_FILE AND CLI11_SINGLE_FILE_TESTS)
+        target_include_directories(OptionalTest_Single PRIVATE ${Boost_INCLUDE_DIRS})
+        target_include_directories(BoostOptionTypeTest_Single PRIVATE ${Boost_INCLUDE_DIRS})
+     endif()
 endif()
 
 if(CMAKE_BUILD_TYPE STREQUAL Coverage)
diff --git a/tests/ComplexTypeTest.cpp b/tests/ComplexTypeTest.cpp
new file mode 100644
index 000000000..5f43508ee
--- /dev/null
+++ b/tests/ComplexTypeTest.cpp
@@ -0,0 +1,185 @@
+#include "app_helper.hpp"
+#include "gmock/gmock.h"
+#include <complex>
+#include <cstdint>
+
+using ::testing::HasSubstr;
+
+using cx = std::complex<double>;
+
+CLI::Option *
+add_option(CLI::App &app, std::string name, cx &variable, std::string description = "", bool defaulted = false) {
+    CLI::callback_t fun = [&variable](CLI::results_t res) {
+        double x, y;
+        bool worked = CLI::detail::lexical_cast(res[0], x) && CLI::detail::lexical_cast(res[1], y);
+        if(worked)
+            variable = cx(x, y);
+        return worked;
+    };
+
+    CLI::Option *opt = app.add_option(name, fun, description, defaulted);
+    opt->type_name("COMPLEX")->type_size(2);
+    if(defaulted) {
+        std::stringstream out;
+        out << variable;
+        opt->default_str(out.str());
+    }
+    return opt;
+}
+
+TEST_F(TApp, AddingComplexParser) {
+
+    cx comp{0, 0};
+    add_option(app, "-c,--complex", comp);
+    args = {"-c", "1.5", "2.5"};
+
+    run();
+
+    EXPECT_DOUBLE_EQ(1.5, comp.real());
+    EXPECT_DOUBLE_EQ(2.5, comp.imag());
+}
+
+TEST_F(TApp, DefaultedComplex) {
+
+    cx comp{1, 2};
+    add_option(app, "-c,--complex", comp, "", true);
+    args = {"-c", "4", "3"};
+
+    std::string help = app.help();
+    EXPECT_THAT(help, HasSubstr("1"));
+    EXPECT_THAT(help, HasSubstr("2"));
+
+    EXPECT_DOUBLE_EQ(1, comp.real());
+    EXPECT_DOUBLE_EQ(2, comp.imag());
+
+    run();
+
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(3, comp.imag());
+}
+
+// an example of custom complex number converter that can be used to add new parsing options
+#if defined(__has_include)
+#if __has_include(<regex>)
+// an example of custom converter that can be used to add new parsing options
+#define HAS_REGEX_INCLUDE
+#endif
+#endif
+
+#ifdef HAS_REGEX_INCLUDE
+// Gcc 4.8 and older and the corresponding standard libraries have a broken <regex> so this would
+// fail.  And if a clang compiler is using libstd++ then this will generate an error as well so this is just a check to
+// simplify compilation and prevent a much more complicated #if expression
+#include <regex>
+namespace CLI {
+namespace detail {
+
+// On MSVC and possibly some other new compilers this can be a free standing function without the template
+// specialization but this is compiler dependent
+template <> bool lexical_cast<std::complex<double>>(const std::string &input, std::complex<double> &output) {
+    // regular expression to handle complex numbers of various formats
+    static const std::regex creg(
+        R"(([+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)\s*([+-]\s*(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)[ji]*)");
+
+    std::smatch m;
+    double x{0.0}, y{0.0};
+    bool worked;
+    std::regex_search(input, m, creg);
+    if(m.size() == 9) {
+        worked = CLI::detail::lexical_cast(m[1], x) && CLI::detail::lexical_cast(m[6], y);
+        if(worked) {
+            if(*m[5].first == '-') {
+                y = -y;
+            }
+        }
+    } else {
+        if((input.back() == 'j') || (input.back() == 'i')) {
+            auto strval = input.substr(0, input.size() - 1);
+            CLI::detail::trim(strval);
+            worked = CLI::detail::lexical_cast(strval, y);
+        } else {
+            std::string ival = input;
+            CLI::detail::trim(ival);
+            worked = CLI::detail::lexical_cast(ival, x);
+        }
+    }
+    if(worked) {
+        output = cx{x, y};
+    }
+    return worked;
+}
+} // namespace detail
+} // namespace CLI
+
+TEST_F(TApp, AddingComplexParserDetail) {
+
+    bool skip_tests = false;
+    try { // check if the library actually supports regex,  it is possible to link against a non working regex in the
+          // standard library
+        std::smatch m;
+        std::string input = "1.5+2.5j";
+        static const std::regex creg(
+            R"(([+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)\s*([+-]\s*(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)[ji]*)");
+
+        auto rsearch = std::regex_search(input, m, creg);
+        if(!rsearch) {
+            skip_tests = true;
+        } else {
+            EXPECT_EQ(m.size(), 9u);
+        }
+
+    } catch(...) {
+        skip_tests = true;
+    }
+    static_assert(CLI::detail::is_complex<cx>::value, "complex should register as complex in this situation");
+    if(!skip_tests) {
+        cx comp{0, 0};
+
+        app.add_option("-c,--complex", comp, "add a complex number option");
+        args = {"-c", "1.5+2.5j"};
+
+        run();
+
+        EXPECT_DOUBLE_EQ(1.5, comp.real());
+        EXPECT_DOUBLE_EQ(2.5, comp.imag());
+        args = {"-c", "1.5-2.5j"};
+
+        run();
+
+        EXPECT_DOUBLE_EQ(1.5, comp.real());
+        EXPECT_DOUBLE_EQ(-2.5, comp.imag());
+    }
+}
+#endif
+// defining a new complex class
+class complex_new {
+  public:
+    complex_new() = default;
+    complex_new(double v1, double v2) : val1_{v1}, val2_{v2} {};
+    double real() { return val1_; }
+    double imag() { return val2_; }
+
+  private:
+    double val1_{0.0};
+    double val2_{0.0};
+};
+
+TEST_F(TApp, newComplex) {
+    complex_new cval;
+    static_assert(CLI::detail::is_complex<complex_new>::value, "complex new does not register as a complex type");
+    static_assert(CLI::detail::classify_object<complex_new>::value == CLI::detail::object_category::complex_number,
+                  "complex new does not result in complex number categorization");
+    app.add_option("-c,--complex", cval, "add a complex number option");
+    args = {"-c", "1.5+2.5j"};
+
+    run();
+
+    EXPECT_DOUBLE_EQ(1.5, cval.real());
+    EXPECT_DOUBLE_EQ(2.5, cval.imag());
+    args = {"-c", "1.5-2.5j"};
+
+    run();
+
+    EXPECT_DOUBLE_EQ(1.5, cval.real());
+    EXPECT_DOUBLE_EQ(-2.5, cval.imag());
+}
diff --git a/tests/HelpersTest.cpp b/tests/HelpersTest.cpp
index 8dac6ef37..a23f00717 100644
--- a/tests/HelpersTest.cpp
+++ b/tests/HelpersTest.cpp
@@ -6,8 +6,10 @@
 #include <cstdint>
 #include <cstdio>
 #include <fstream>
+#include <map>
 #include <string>
 #include <tuple>
+#include <unordered_map>
 #include <utility>
 
 class NotStreamable {};
@@ -52,6 +54,57 @@ TEST(TypeTools, type_size) {
     EXPECT_EQ(V, 5);
     V = CLI::detail::type_count<std::vector<std::pair<std::string, double>>>::value;
     EXPECT_EQ(V, 2);
+    V = CLI::detail::type_count<std::tuple<std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 2);
+    V = CLI::detail::type_count<std::tuple<int, std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 3);
+    V = CLI::detail::type_count<std::tuple<std::pair<int, double>, std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 4);
+    // maps
+    V = CLI::detail::type_count<std::map<int, std::pair<int, double>>>::value;
+    EXPECT_EQ(V, 3);
+    // three level tuples
+    V = CLI::detail::type_count<std::tuple<int, std::pair<int, std::tuple<int, double, std::string>>>>::value;
+    EXPECT_EQ(V, 5);
+    V = CLI::detail::type_count<std::pair<int, std::vector<int>>>::value;
+    EXPECT_GE(V, CLI::detail::expected_max_vector_size);
+    V = CLI::detail::type_count<std::vector<std::vector<int>>>::value;
+    EXPECT_EQ(V, CLI::detail::expected_max_vector_size);
+}
+
+TEST(TypeTools, type_size_min) {
+    auto V = CLI::detail::type_count_min<int>::value;
+    EXPECT_EQ(V, 1);
+    V = CLI::detail::type_count_min<void>::value;
+    EXPECT_EQ(V, 0);
+    V = CLI::detail::type_count_min<std::vector<double>>::value;
+    EXPECT_EQ(V, 1);
+    V = CLI::detail::type_count_min<std::tuple<double, int>>::value;
+    EXPECT_EQ(V, 2);
+    V = CLI::detail::type_count_min<std::tuple<std::string, double, int>>::value;
+    EXPECT_EQ(V, 3);
+    V = CLI::detail::type_count_min<std::array<std::string, 5>>::value;
+    EXPECT_EQ(V, 5);
+    V = CLI::detail::type_count_min<std::vector<std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 2);
+    V = CLI::detail::type_count_min<std::tuple<std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 2);
+    V = CLI::detail::type_count_min<std::tuple<int, std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 3);
+    V = CLI::detail::type_count_min<std::tuple<std::pair<int, double>, std::pair<std::string, double>>>::value;
+    EXPECT_EQ(V, 4);
+    // maps
+    V = CLI::detail::type_count_min<std::map<int, std::pair<int, double>>>::value;
+    EXPECT_EQ(V, 3);
+    // three level tuples
+    V = CLI::detail::type_count_min<std::tuple<int, std::pair<int, std::tuple<int, double, std::string>>>>::value;
+    EXPECT_EQ(V, 5);
+    V = CLI::detail::type_count_min<std::pair<int, std::vector<int>>>::value;
+    EXPECT_EQ(V, 2);
+    V = CLI::detail::type_count_min<std::vector<std::vector<int>>>::value;
+    EXPECT_EQ(V, 1);
+    V = CLI::detail::type_count_min<std::vector<std::vector<std::pair<int, int>>>>::value;
+    EXPECT_EQ(V, 2);
 }
 
 TEST(TypeTools, expected_count) {
@@ -862,6 +915,10 @@ TEST(Types, TypeName) {
                       CLI::detail::object_category::tuple_value,
                   "pair<int,string> does not read like a tuple");
 
+    static_assert(CLI::detail::classify_object<std::tuple<std::string, double>>::value ==
+                      CLI::detail::object_category::tuple_value,
+                  "tuple<string,double> does not read like a tuple");
+
     std::string pair_name = CLI::detail::type_name<std::vector<std::pair<int, std::string>>>();
     EXPECT_EQ("[INT,TEXT]", pair_name);
 
@@ -869,7 +926,7 @@ TEST(Types, TypeName) {
     EXPECT_EQ("UINT", vector_name);
 
     auto vclass = CLI::detail::classify_object<std::vector<std::vector<unsigned char>>>::value;
-    EXPECT_EQ(vclass, CLI::detail::object_category::vector_value);
+    EXPECT_EQ(vclass, CLI::detail::object_category::container_value);
 
     auto tclass = CLI::detail::classify_object<std::tuple<double>>::value;
     EXPECT_EQ(tclass, CLI::detail::object_category::number_constructible);
@@ -883,6 +940,18 @@ TEST(Types, TypeName) {
     tuple_name = CLI::detail::type_name<std::tuple<int, std::string>>();
     EXPECT_EQ("[INT,TEXT]", tuple_name);
 
+    tuple_name = CLI::detail::type_name<std::tuple<const int, std::string>>();
+    EXPECT_EQ("[INT,TEXT]", tuple_name);
+
+    tuple_name = CLI::detail::type_name<const std::tuple<int, std::string>>();
+    EXPECT_EQ("[INT,TEXT]", tuple_name);
+
+    tuple_name = CLI::detail::type_name<std::tuple<std::string, double>>();
+    EXPECT_EQ("[TEXT,FLOAT]", tuple_name);
+
+    tuple_name = CLI::detail::type_name<const std::tuple<std::string, double>>();
+    EXPECT_EQ("[TEXT,FLOAT]", tuple_name);
+
     tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double>>();
     EXPECT_EQ("[INT,TEXT,FLOAT]", tuple_name);
 
@@ -911,6 +980,8 @@ TEST(Types, TypeName) {
                   "tuple<test> does not classify as a tuple");
     std::string enum_name2 = CLI::detail::type_name<std::tuple<test>>();
     EXPECT_EQ("ENUM", enum_name2);
+    std::string umapName = CLI::detail::type_name<std::unordered_map<int, std::tuple<std::string, double>>>();
+    EXPECT_EQ("[INT,[TEXT,FLOAT]]", umapName);
 }
 
 TEST(Types, OverflowSmall) {
@@ -995,11 +1066,11 @@ TEST(Types, LexicalCastParsable) {
     std::complex<double> output;
     EXPECT_TRUE(CLI::detail::lexical_cast(input, output));
     EXPECT_DOUBLE_EQ(output.real(), 4.2);  // Doing this in one go sometimes has trouble
-    EXPECT_DOUBLE_EQ(output.imag(), 7.3);  // on clang + c++4.8 due to missing const
+    EXPECT_DOUBLE_EQ(output.imag(), 7.3);  // on clang + gcc 4.8 due to missing const
 
     EXPECT_TRUE(CLI::detail::lexical_cast("2.456", output));
     EXPECT_DOUBLE_EQ(output.real(), 2.456);  // Doing this in one go sometimes has trouble
-    EXPECT_DOUBLE_EQ(output.imag(), 0.0);    // on clang + c++4.8 due to missing const
+    EXPECT_DOUBLE_EQ(output.imag(), 0.0);    // on clang + gcc 4.8 due to missing const
 
     EXPECT_FALSE(CLI::detail::lexical_cast(fail_input, output));
     EXPECT_FALSE(CLI::detail::lexical_cast(extra_input, output));
@@ -1173,6 +1244,26 @@ TEST(Types, LexicalConversionComplex) {
     EXPECT_EQ(x.imag(), 3.5);
 }
 
+static_assert(CLI::detail::is_wrapper<std::vector<double>>::value, "vector double should be a wrapper");
+static_assert(CLI::detail::is_wrapper<std::vector<std::string>>::value, "vector string should be a wrapper");
+static_assert(CLI::detail::is_wrapper<std::string>::value, "string should be a wrapper");
+static_assert(!CLI::detail::is_wrapper<double>::value, "double should not be a wrapper");
+
+static_assert(CLI::detail::is_mutable_container<std::vector<double>>::value, "vector class should be a container");
+static_assert(CLI::detail::is_mutable_container<std::vector<std::string>>::value, "vector class should be a container");
+static_assert(!CLI::detail::is_mutable_container<std::string>::value, "string should be a container");
+static_assert(!CLI::detail::is_mutable_container<double>::value, "double should not be a container");
+static_assert(!CLI::detail::is_mutable_container<std::array<double, 5>>::value, "array should not be a container");
+
+static_assert(CLI::detail::is_mutable_container<std::vector<int>>::value, "vector int should be a container");
+
+static_assert(CLI::detail::is_readable_container<std::vector<int> &>::value,
+              "vector int & should be a readable container");
+static_assert(CLI::detail::is_readable_container<const std::vector<int>>::value,
+              "const vector int should be a readable container");
+static_assert(CLI::detail::is_readable_container<const std::vector<int> &>::value,
+              "const vector int & should be a readable container");
+
 TEST(FixNewLines, BasicCheck) {
     std::string input = "one\ntwo";
     std::string output = "one\n; two";
diff --git a/tests/NewParseTest.cpp b/tests/NewParseTest.cpp
index 0b61e7480..4a79b4435 100644
--- a/tests/NewParseTest.cpp
+++ b/tests/NewParseTest.cpp
@@ -7,47 +7,36 @@ using ::testing::HasSubstr;
 
 using cx = std::complex<double>;
 
-CLI::Option *
-add_option(CLI::App &app, std::string name, cx &variable, std::string description = "", bool defaulted = false) {
-    CLI::callback_t fun = [&variable](CLI::results_t res) {
-        double x, y;
-        bool worked = CLI::detail::lexical_cast(res[0], x) && CLI::detail::lexical_cast(res[1], y);
-        if(worked)
-            variable = cx(x, y);
-        return worked;
-    };
-
-    CLI::Option *opt = app.add_option(name, fun, description, defaulted);
-    opt->type_name("COMPLEX")->type_size(2);
-    if(defaulted) {
-        std::stringstream out;
-        out << variable;
-        opt->default_str(out.str());
-    }
-    return opt;
-}
+TEST_F(TApp, Complex) {
+    cx comp{1, 2};
+    app.add_complex("-c,--complex", comp, "", true);
+
+    args = {"-c", "4", "3"};
 
-TEST_F(TApp, AddingComplexParser) {
+    std::string help = app.help();
+    EXPECT_THAT(help, HasSubstr("1"));
+    EXPECT_THAT(help, HasSubstr("2"));
+    EXPECT_THAT(help, HasSubstr("COMPLEX"));
 
-    cx comp{0, 0};
-    add_option(app, "-c,--complex", comp);
-    args = {"-c", "1.5", "2.5"};
+    EXPECT_DOUBLE_EQ(1, comp.real());
+    EXPECT_DOUBLE_EQ(2, comp.imag());
 
     run();
 
-    EXPECT_DOUBLE_EQ(1.5, comp.real());
-    EXPECT_DOUBLE_EQ(2.5, comp.imag());
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(3, comp.imag());
 }
 
-TEST_F(TApp, DefaultComplex) {
-
+TEST_F(TApp, ComplexOption) {
     cx comp{1, 2};
-    add_option(app, "-c,--complex", comp, "", true);
+    app.add_option("-c,--complex", comp, "", true);
+
     args = {"-c", "4", "3"};
 
     std::string help = app.help();
     EXPECT_THAT(help, HasSubstr("1"));
     EXPECT_THAT(help, HasSubstr("2"));
+    EXPECT_THAT(help, HasSubstr("COMPLEX"));
 
     EXPECT_DOUBLE_EQ(1, comp.real());
     EXPECT_DOUBLE_EQ(2, comp.imag());
@@ -58,9 +47,9 @@ TEST_F(TApp, DefaultComplex) {
     EXPECT_DOUBLE_EQ(3, comp.imag());
 }
 
-TEST_F(TApp, BuiltinComplex) {
-    cx comp{1, 2};
-    app.add_complex("-c,--complex", comp, "", true);
+TEST_F(TApp, ComplexFloat) {
+    std::complex<float> comp{1, 2};
+    app.add_complex<std::complex<float>, float>("-c,--complex", comp, "", true);
 
     args = {"-c", "4", "3"};
 
@@ -69,18 +58,18 @@ TEST_F(TApp, BuiltinComplex) {
     EXPECT_THAT(help, HasSubstr("2"));
     EXPECT_THAT(help, HasSubstr("COMPLEX"));
 
-    EXPECT_DOUBLE_EQ(1, comp.real());
-    EXPECT_DOUBLE_EQ(2, comp.imag());
+    EXPECT_FLOAT_EQ(1, comp.real());
+    EXPECT_FLOAT_EQ(2, comp.imag());
 
     run();
 
-    EXPECT_DOUBLE_EQ(4, comp.real());
-    EXPECT_DOUBLE_EQ(3, comp.imag());
+    EXPECT_FLOAT_EQ(4, comp.real());
+    EXPECT_FLOAT_EQ(3, comp.imag());
 }
 
-TEST_F(TApp, BuiltinComplexFloat) {
+TEST_F(TApp, ComplexFloatOption) {
     std::complex<float> comp{1, 2};
-    app.add_complex<std::complex<float>, float>("-c,--complex", comp, "", true);
+    app.add_option("-c,--complex", comp, "", true);
 
     args = {"-c", "4", "3"};
 
@@ -98,7 +87,7 @@ TEST_F(TApp, BuiltinComplexFloat) {
     EXPECT_FLOAT_EQ(3, comp.imag());
 }
 
-TEST_F(TApp, BuiltinComplexWithDelimiter) {
+TEST_F(TApp, ComplexWithDelimiter) {
     cx comp{1, 2};
     app.add_complex("-c,--complex", comp, "", true)->delimiter('+');
 
@@ -130,7 +119,39 @@ TEST_F(TApp, BuiltinComplexWithDelimiter) {
     EXPECT_DOUBLE_EQ(-4, comp.imag());
 }
 
-TEST_F(TApp, BuiltinComplexIgnoreI) {
+TEST_F(TApp, ComplexWithDelimiterOption) {
+    cx comp{1, 2};
+    app.add_option("-c,--complex", comp, "", true)->delimiter('+');
+
+    args = {"-c", "4+3i"};
+
+    std::string help = app.help();
+    EXPECT_THAT(help, HasSubstr("1"));
+    EXPECT_THAT(help, HasSubstr("2"));
+    EXPECT_THAT(help, HasSubstr("COMPLEX"));
+
+    EXPECT_DOUBLE_EQ(1, comp.real());
+    EXPECT_DOUBLE_EQ(2, comp.imag());
+
+    run();
+
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(3, comp.imag());
+
+    args = {"-c", "5+-3i"};
+    run();
+
+    EXPECT_DOUBLE_EQ(5, comp.real());
+    EXPECT_DOUBLE_EQ(-3, comp.imag());
+
+    args = {"-c", "6", "-4i"};
+    run();
+
+    EXPECT_DOUBLE_EQ(6, comp.real());
+    EXPECT_DOUBLE_EQ(-4, comp.imag());
+}
+
+TEST_F(TApp, ComplexIgnoreI) {
     cx comp{1, 2};
     app.add_complex("-c,--complex", comp);
 
@@ -142,7 +163,19 @@ TEST_F(TApp, BuiltinComplexIgnoreI) {
     EXPECT_DOUBLE_EQ(3, comp.imag());
 }
 
-TEST_F(TApp, BuiltinComplexSingleArg) {
+TEST_F(TApp, ComplexIgnoreIOption) {
+    cx comp{1, 2};
+    app.add_option("-c,--complex", comp);
+
+    args = {"-c", "4", "3i"};
+
+    run();
+
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(3, comp.imag());
+}
+
+TEST_F(TApp, ComplexSingleArg) {
     cx comp{1, 2};
     app.add_complex("-c,--complex", comp);
 
@@ -176,7 +209,41 @@ TEST_F(TApp, BuiltinComplexSingleArg) {
     EXPECT_DOUBLE_EQ(-2.7, comp.imag());
 }
 
-TEST_F(TApp, BuiltinComplexSingleImag) {
+TEST_F(TApp, ComplexSingleArgOption) {
+    cx comp{1, 2};
+    app.add_option("-c,--complex", comp);
+
+    args = {"-c", "4"};
+    run();
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(0, comp.imag());
+
+    args = {"-c", "4-2i"};
+    run();
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(-2, comp.imag());
+    args = {"-c", "4+2i"};
+    run();
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(2, comp.imag());
+
+    args = {"-c", "-4+2j"};
+    run();
+    EXPECT_DOUBLE_EQ(-4, comp.real());
+    EXPECT_DOUBLE_EQ(2, comp.imag());
+
+    args = {"-c", "-4.2-2j"};
+    run();
+    EXPECT_DOUBLE_EQ(-4.2, comp.real());
+    EXPECT_DOUBLE_EQ(-2, comp.imag());
+
+    args = {"-c", "-4.2-2.7i"};
+    run();
+    EXPECT_DOUBLE_EQ(-4.2, comp.real());
+    EXPECT_DOUBLE_EQ(-2.7, comp.imag());
+}
+
+TEST_F(TApp, ComplexSingleImag) {
     cx comp{1, 2};
     app.add_complex("-c,--complex", comp);
 
@@ -199,6 +266,29 @@ TEST_F(TApp, BuiltinComplexSingleImag) {
     EXPECT_DOUBLE_EQ(0, comp.imag());
 }
 
+TEST_F(TApp, ComplexSingleImagOption) {
+    cx comp{1, 2};
+    app.add_option("-c,--complex", comp);
+
+    args = {"-c", "4j"};
+    run();
+    EXPECT_DOUBLE_EQ(0, comp.real());
+    EXPECT_DOUBLE_EQ(4, comp.imag());
+
+    args = {"-c", "-4j"};
+    run();
+    EXPECT_DOUBLE_EQ(0, comp.real());
+    EXPECT_DOUBLE_EQ(-4, comp.imag());
+    args = {"-c", "-4"};
+    run();
+    EXPECT_DOUBLE_EQ(-4, comp.real());
+    EXPECT_DOUBLE_EQ(0, comp.imag());
+    args = {"-c", "+4"};
+    run();
+    EXPECT_DOUBLE_EQ(4, comp.real());
+    EXPECT_DOUBLE_EQ(0, comp.imag());
+}
+
 /// Simple class containing two strings useful for testing lexical cast and conversions
 class spair {
   public:
@@ -245,98 +335,6 @@ TEST_F(TApp, custom_string_converterFail) {
     EXPECT_THROW(run(), CLI::ConversionError);
 }
 
-// an example of custom complex number converter that can be used to add new parsing options
-#if defined(__has_include)
-#if __has_include(<regex>)
-// an example of custom converter that can be used to add new parsing options
-#define HAS_REGEX_INCLUDE
-#endif
-#endif
-
-#ifdef HAS_REGEX_INCLUDE
-// Gcc 4.8 and older and the corresponding standard libraries have a broken <regex> so this would
-// fail.  And if a clang compiler is using libstd++ then this will generate an error as well so this is just a check to
-// simplify compilation and prevent a much more complicated #if expression
-#include <regex>
-namespace CLI {
-namespace detail {
-
-// On MSVC and possibly some other new compilers this can be a free standing function without the template
-// specialization but this is compiler dependent
-template <> bool lexical_cast<std::complex<double>>(const std::string &input, std::complex<double> &output) {
-    // regular expression to handle complex numbers of various formats
-    static const std::regex creg(
-        R"(([+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)\s*([+-]\s*(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)[ji]*)");
-
-    std::smatch m;
-    double x{0.0}, y{0.0};
-    bool worked;
-    std::regex_search(input, m, creg);
-    if(m.size() == 9) {
-        worked = CLI::detail::lexical_cast(m[1], x) && CLI::detail::lexical_cast(m[6], y);
-        if(worked) {
-            if(*m[5].first == '-') {
-                y = -y;
-            }
-        }
-    } else {
-        if((input.back() == 'j') || (input.back() == 'i')) {
-            auto strval = input.substr(0, input.size() - 1);
-            CLI::detail::trim(strval);
-            worked = CLI::detail::lexical_cast(strval, y);
-        } else {
-            std::string ival = input;
-            CLI::detail::trim(ival);
-            worked = CLI::detail::lexical_cast(ival, x);
-        }
-    }
-    if(worked) {
-        output = cx{x, y};
-    }
-    return worked;
-}
-}  // namespace detail
-}  // namespace CLI
-
-TEST_F(TApp, AddingComplexParserDetail) {
-
-    bool skip_tests = false;
-    try {  // check if the library actually supports regex,  it is possible to link against a non working regex in the
-           // standard library
-        std::smatch m;
-        std::string input = "1.5+2.5j";
-        static const std::regex creg(
-            R"(([+-]?(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)\s*([+-]\s*(\d+(\.\d+)?|\.\d+)([eE][+-]?\d+)?)[ji]*)");
-
-        auto rsearch = std::regex_search(input, m, creg);
-        if(!rsearch) {
-            skip_tests = true;
-        } else {
-            EXPECT_EQ(m.size(), 9u);
-        }
-
-    } catch(...) {
-        skip_tests = true;
-    }
-    if(!skip_tests) {
-        cx comp{0, 0};
-        app.add_option("-c,--complex", comp, "add a complex number option");
-        args = {"-c", "1.5+2.5j"};
-
-        run();
-
-        EXPECT_DOUBLE_EQ(1.5, comp.real());
-        EXPECT_DOUBLE_EQ(2.5, comp.imag());
-        args = {"-c", "1.5-2.5j"};
-
-        run();
-
-        EXPECT_DOUBLE_EQ(1.5, comp.real());
-        EXPECT_DOUBLE_EQ(-2.5, comp.imag());
-    }
-}
-#endif
-
 /// simple class to wrap another  with a very specific type constructor and assignment operators to test out some of the
 /// option assignments
 template <class X> class objWrapper {
@@ -523,3 +521,107 @@ TEST_F(TApp, uint16Wrapper) {
 
     EXPECT_THROW(run(), CLI::ConversionError);
 }
+
+template <class T> class SimpleWrapper {
+  public:
+    SimpleWrapper() : val_{} {};
+    explicit SimpleWrapper(const T &initial) : val_{initial} {};
+    T &getRef() { return val_; };
+    using value_type = T;
+
+  private:
+    T val_;
+};
+
+TEST_F(TApp, wrapperInt) {
+    SimpleWrapper<int> wrap;
+    app.add_option("--val", wrap);
+    args = {"--val", "2"};
+
+    run();
+    EXPECT_EQ(wrap.getRef(), 2);
+}
+
+TEST_F(TApp, wrapperString) {
+    SimpleWrapper<std::string> wrap;
+    app.add_option("--val", wrap);
+    args = {"--val", "str"};
+
+    run();
+    EXPECT_EQ(wrap.getRef(), "str");
+}
+
+TEST_F(TApp, wrapperVector) {
+    SimpleWrapper<std::vector<int>> wrap;
+    app.add_option("--val", wrap);
+    args = {"--val", "1", "2", "3", "4"};
+
+    run();
+    auto v1 = wrap.getRef();
+    auto v2 = std::vector<int>{1, 2, 3, 4};
+    EXPECT_EQ(v1, v2);
+}
+
+TEST_F(TApp, wrapperwrapperString) {
+    SimpleWrapper<SimpleWrapper<std::string>> wrap;
+    app.add_option("--val", wrap);
+    args = {"--val", "arg"};
+
+    run();
+    auto v1 = wrap.getRef().getRef();
+    auto v2 = "arg";
+    EXPECT_EQ(v1, v2);
+}
+
+TEST_F(TApp, wrapperwrapperVector) {
+    SimpleWrapper<SimpleWrapper<std::vector<int>>> wrap;
+    auto opt = app.add_option("--val", wrap);
+    args = {"--val", "1", "2", "3", "4"};
+
+    run();
+    auto v1 = wrap.getRef().getRef();
+    auto v2 = std::vector<int>{1, 2, 3, 4};
+    EXPECT_EQ(v1, v2);
+    opt->type_size(0, 5);
+
+    args = {"--val"};
+
+    run();
+    EXPECT_TRUE(wrap.getRef().getRef().empty());
+
+    args = {"--val", "happy", "sad"};
+
+    EXPECT_THROW(run(), CLI::ConversionError);
+}
+
+TEST_F(TApp, wrapperComplex) {
+    SimpleWrapper<std::complex<double>> wrap;
+    app.add_option("--val", wrap);
+    args = {"--val", "1", "2"};
+
+    run();
+    auto &v1 = wrap.getRef();
+    auto v2 = std::complex<double>{1, 2};
+    EXPECT_EQ(v1.real(), v2.real());
+    EXPECT_EQ(v1.imag(), v2.imag());
+    args = {"--val", "1.4-4j"};
+
+    run();
+    v2 = std::complex<double>{1.4, -4};
+    EXPECT_EQ(v1.real(), v2.real());
+    EXPECT_EQ(v1.imag(), v2.imag());
+}
+
+TEST_F(TApp, vectorComplex) {
+    std::vector<std::complex<double>> vcomplex;
+    app.add_option("--val", vcomplex);
+    args = {"--val", "1", "2", "--val", "1.4-4j"};
+
+    run();
+
+    ASSERT_EQ(vcomplex.size(), 2U);
+    EXPECT_EQ(vcomplex[0].real(), 1.0);
+    EXPECT_EQ(vcomplex[0].imag(), 2.0);
+    EXPECT_EQ(vcomplex[1].real(), 1.4);
+    EXPECT_EQ(vcomplex[1].imag(), -4.0);
+}
diff --git a/tests/OptionTypeTest.cpp b/tests/OptionTypeTest.cpp
new file mode 100644
index 000000000..12eb33917
--- /dev/null
+++ b/tests/OptionTypeTest.cpp
@@ -0,0 +1,834 @@
+#include "app_helper.hpp"
+#include <complex>
+#include <cstdint>
+#include <cstdlib>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <queue>
+#include <set>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "gmock/gmock.h"
+
+TEST_F(TApp, OneStringAgain) {
+    std::string str;
+    app.add_option("-s,--string", str);
+    args = {"--string", "mystring"};
+    run();
+    EXPECT_EQ(1u, app.count("-s"));
+    EXPECT_EQ(1u, app.count("--string"));
+    EXPECT_EQ(str, "mystring");
+}
+
+TEST_F(TApp, OneStringFunction) {
+    std::string str;
+    app.add_option_function<std::string>("-s,--string", [&str](const std::string &val) { str = val; });
+    args = {"--string", "mystring"};
+    run();
+    EXPECT_EQ(1u, app.count("-s"));
+    EXPECT_EQ(1u, app.count("--string"));
+    EXPECT_EQ(str, "mystring");
+}
+
+TEST_F(TApp, doubleFunction) {
+    double res{0.0};
+    app.add_option_function<double>("--val", [&res](double val) { res = std::abs(val + 54); });
+    args = {"--val", "-354.356"};
+    run();
+    EXPECT_EQ(res, 300.356);
+    // get the original value as entered as an integer
+    EXPECT_EQ(app["--val"]->as<float>(), -354.356f);
+}
+
+TEST_F(TApp, doubleFunctionFail) {
+    double res;
+    app.add_option_function<double>("--val", [&res](double val) { res = std::abs(val + 54); });
+    args = {"--val", "not_double"};
+    EXPECT_THROW(run(), CLI::ConversionError);
+}
+
+TEST_F(TApp, doubleVectorFunction) {
+    std::vector<double> res;
+    app.add_option_function<std::vector<double>>("--val", [&res](const std::vector<double> &val) {
+        res = val;
+        std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
+    });
+    args = {"--val", "5", "--val", "6", "--val", "7"};
+    run();
+    EXPECT_EQ(res.size(), 3u);
+    EXPECT_EQ(res[0], 10.0);
+    EXPECT_EQ(res[2], 12.0);
+}
+
+TEST_F(TApp, doubleVectorFunctionFail) {
+    std::vector<double> res;
+    std::string vstring = "--val";
+    app.add_option_function<std::vector<double>>(vstring, [&res](const std::vector<double> &val) {
+        res = val;
+        std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
+    });
+    args = {"--val", "five", "--val", "nine", "--val", "7"};
+    EXPECT_THROW(run(), CLI::ConversionError);
+    // check that getting the results through the results function generates the same error
+    EXPECT_THROW(app[vstring]->results(res), CLI::ConversionError);
+    auto strvec = app[vstring]->as<std::vector<std::string>>();
+    EXPECT_EQ(strvec.size(), 3u);
+}
+
+TEST_F(TApp, doubleVectorFunctionRunCallbackOnDefault) {
+    std::vector<double> res;
+    auto opt = app.add_option_function<std::vector<double>>("--val", [&res](const std::vector<double> &val) {
+        res = val;
+        std::transform(res.begin(), res.end(), res.begin(), [](double v) { return v + 5.0; });
+    });
+    args = {"--val", "5", "--val", "6", "--val", "7"};
+    run();
+    EXPECT_EQ(res.size(), 3u);
+    EXPECT_EQ(res[0], 10.0);
+    EXPECT_EQ(res[2], 12.0);
+    EXPECT_FALSE(opt->get_run_callback_for_default());
+    opt->run_callback_for_default();
+    opt->default_val(std::vector<int>{2, 1, -2});
+    EXPECT_EQ(res[0], 7.0);
+    EXPECT_EQ(res[2], 3.0);
+
+    EXPECT_THROW(opt->default_val("this is a string"), CLI::ConversionError);
+    auto vec = opt->as<std::vector<double>>();
+    ASSERT_EQ(vec.size(), 3U);
+    EXPECT_EQ(vec[0], 5.0);
+    EXPECT_EQ(vec[2], 7.0);
+    opt->check(CLI::Number);
+    opt->run_callback_for_default(false);
+    EXPECT_THROW(opt->default_val("this is a string"), CLI::ValidationError);
+}
+
+TEST_F(TApp, BoolAndIntFlags) {
+
+    bool bflag{false};
+    int iflag{0};
+    unsigned int uflag{0};
+
+    app.add_flag("-b", bflag);
+    app.add_flag("-i", iflag);
+    app.add_flag("-u", uflag);
+
+    args = {"-b", "-i", "-u"};
+    run();
+    EXPECT_TRUE(bflag);
+    EXPECT_EQ(1, iflag);
+    EXPECT_EQ((unsigned int)1, uflag);
+
+    args = {"-b", "-b"};
+    ASSERT_NO_THROW(run());
+    EXPECT_TRUE(bflag);
+
+    bflag = false;
+
+    args = {"-iiiuu"};
+    run();
+    EXPECT_FALSE(bflag);
+    EXPECT_EQ(3, iflag);
+    EXPECT_EQ((unsigned int)2, uflag);
+}
+
+TEST_F(TApp, BoolOption) {
+    bool bflag{false};
+    app.add_option("-b", bflag);
+
+    args = {"-b", "false"};
+    run();
+    EXPECT_FALSE(bflag);
+
+    args = {"-b", "1"};
+    run();
+    EXPECT_TRUE(bflag);
+
+    args = {"-b", "-7"};
+    run();
+    EXPECT_FALSE(bflag);
+
+    // cause an out of bounds error internally
+    args = {"-b", "751615654161688126132138844896646748852"};
+    run();
+    EXPECT_TRUE(bflag);
+
+    args = {"-b", "-751615654161688126132138844896646748852"};
+    run();
+    EXPECT_FALSE(bflag);
+}
+
+TEST_F(TApp, vectorDefaults) {
+    std::vector<int> vals{4, 5};
+    auto opt = app.add_option("--long", vals, "", true);
+
+    args = {"--long", "[1,2,3]"};
+
+    run();
+
+    EXPECT_EQ(vals, std::vector<int>({1, 2, 3}));
+
+    args.clear();
+    run();
+    auto res = app["--long"]->as<std::vector<int>>();
+    EXPECT_EQ(res, std::vector<int>({4, 5}));
+
+    app.clear();
+    opt->expected(1)->take_last();
+    res = app["--long"]->as<std::vector<int>>();
+    EXPECT_EQ(res, std::vector<int>({5}));
+    opt->take_first();
+    res = app["--long"]->as<std::vector<int>>();
+    EXPECT_EQ(res, std::vector<int>({4}));
+
+    opt->expected(0, 1)->take_last();
+    run();
+
+    EXPECT_EQ(res, std::vector<int>({4}));
+    res = app["--long"]->as<std::vector<int>>();
+    EXPECT_EQ(res, std::vector<int>({5}));
+}
+
+TEST_F(TApp, CallbackBoolFlags) {
+
+    bool value{false};
+
+    auto func = [&value]() { value = true; };
+
+    auto cback = app.add_flag_callback("--val", func);
+    args = {"--val"};
+    run();
+    EXPECT_TRUE(value);
+    value = false;
+    args = {"--val=false"};
+    run();
+    EXPECT_FALSE(value);
+
+    EXPECT_THROW(app.add_flag_callback("hi", func), CLI::IncorrectConstruction);
+    cback->multi_option_policy(CLI::MultiOptionPolicy::Throw);
+    args = {"--val", "--val=false"};
+    EXPECT_THROW(run(), CLI::ArgumentMismatch);
+}
+
+TEST_F(TApp, pair_check) {
+    std::string myfile{"pair_check_file.txt"};
+    bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
+    EXPECT_TRUE(ok);
+
+    EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
+    std::pair<std::string, int> findex;
+
+    auto v0 = CLI::ExistingFile;
+    v0.application_index(0);
+    auto v1 = CLI::PositiveNumber;
+    v1.application_index(1);
+    app.add_option("--file", findex)->check(v0)->check(v1);
+
+    args = {"--file", myfile, "2"};
+
+    EXPECT_NO_THROW(run());
+
+    EXPECT_EQ(findex.first, myfile);
+    EXPECT_EQ(findex.second, 2);
+
+    args = {"--file", myfile, "-3"};
+
+    EXPECT_THROW(run(), CLI::ValidationError);
+
+    args = {"--file", myfile, "2"};
+    std::remove(myfile.c_str());
+    EXPECT_THROW(run(), CLI::ValidationError);
+}
+
+// this will require that modifying the multi-option policy for tuples be allowed which it isn't at present
+
+TEST_F(TApp, pair_check_take_first) {
+    std::string myfile{"pair_check_file2.txt"};
+    bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
+    EXPECT_TRUE(ok);
+
+    EXPECT_TRUE(CLI::ExistingFile(myfile).empty());
+    std::pair<std::string, int> findex;
+
+    auto opt = app.add_option("--file", findex)->check(CLI::ExistingFile)->check(CLI::PositiveNumber);
+    EXPECT_THROW(opt->get_validator(3), CLI::OptionNotFound);
+    opt->get_validator(0)->application_index(0);
+    opt->get_validator(1)->application_index(1);
+    opt->multi_option_policy(CLI::MultiOptionPolicy::TakeLast);
+    args = {"--file", "not_a_file.txt", "-16", "--file", myfile, "2"};
+    // should only check the last one
+    EXPECT_NO_THROW(run());
+
+    EXPECT_EQ(findex.first, myfile);
+    EXPECT_EQ(findex.second, 2);
+
+    opt->multi_option_policy(CLI::MultiOptionPolicy::TakeFirst);
+
+    EXPECT_THROW(run(), CLI::ValidationError);
+}
+
+TEST_F(TApp, VectorFixedString) {
+    std::vector<std::string> strvec;
+    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
+
+    CLI::Option *opt = app.add_option("-s,--string", strvec)->expected(3);
+    EXPECT_EQ(3, opt->get_expected());
+
+    args = {"--string", "mystring", "mystring2", "mystring3"};
+    run();
+    EXPECT_EQ(3u, app.count("--string"));
+    EXPECT_EQ(answer, strvec);
+}
+
+TEST_F(TApp, VectorDefaultedFixedString) {
+    std::vector<std::string> strvec{"one"};
+    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
+
+    CLI::Option *opt = app.add_option("-s,--string", strvec, "")->expected(3)->capture_default_str();
+    EXPECT_EQ(3, opt->get_expected());
+
+    args = {"--string", "mystring", "mystring2", "mystring3"};
+    run();
+    EXPECT_EQ(3u, app.count("--string"));
+    EXPECT_EQ(answer, strvec);
+}
+
+TEST_F(TApp, VectorIndexedValidator) {
+    std::vector<int> vvec;
+
+    CLI::Option *opt = app.add_option("-v", vvec);
+
+    args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
+    run();
+    EXPECT_EQ(4u, app.count("-v"));
+    EXPECT_EQ(4u, vvec.size());
+    opt->check(CLI::PositiveNumber.application_index(0));
+    opt->check((!CLI::PositiveNumber).application_index(1));
+    EXPECT_NO_THROW(run());
+    EXPECT_EQ(4u, vvec.size());
+    // v[3] would be negative
+    opt->check(CLI::PositiveNumber.application_index(3));
+    EXPECT_THROW(run(), CLI::ValidationError);
+}
+
+TEST_F(TApp, VectorUnlimString) {
+    std::vector<std::string> strvec;
+    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
+
+    CLI::Option *opt = app.add_option("-s,--string", strvec);
+    EXPECT_EQ(1, opt->get_expected());
+    EXPECT_EQ(CLI::detail::expected_max_vector_size, opt->get_expected_max());
+
+    args = {"--string", "mystring", "mystring2", "mystring3"};
+    run();
+    EXPECT_EQ(3u, app.count("--string"));
+    EXPECT_EQ(answer, strvec);
+
+    args = {"-s", "mystring", "mystring2", "mystring3"};
+    run();
+    EXPECT_EQ(3u, app.count("--string"));
+    EXPECT_EQ(answer, strvec);
+}
+
+// From https://github.com/CLIUtils/CLI11/issues/420
+TEST_F(TApp, stringLikeTests) {
+    struct nType {
+        explicit nType(const std::string &a_value) : m_value{a_value} {}
+
+        explicit operator std::string() const { return std::string{"op str"}; }
+
+        std::string m_value;
+    };
+
+    nType m_type{"abc"};
+    app.add_option("--type", m_type, "type")->capture_default_str();
+    run();
+
+    EXPECT_EQ(app["--type"]->as<std::string>(), "op str");
+    args = {"--type", "bca"};
+    run();
+    EXPECT_EQ(std::string(m_type), "op str");
+    EXPECT_EQ(m_type.m_value, "bca");
+}
+
+TEST_F(TApp, VectorExpectedRange) {
+    std::vector<std::string> strvec;
+
+    CLI::Option *opt = app.add_option("--string", strvec);
+    opt->expected(2, 4)->multi_option_policy(CLI::MultiOptionPolicy::Throw);
+
+    args = {"--string", "mystring", "mystring2", "mystring3"};
+    run();
+    EXPECT_EQ(3u, app.count("--string"));
+
+    args = {"--string", "mystring"};
+    EXPECT_THROW(run(), CLI::ArgumentMismatch);
+
+    args = {"--string", "mystring", "mystring2", "string2", "--string", "string4", "string5"};
+    EXPECT_THROW(run(), CLI::ArgumentMismatch);
+
+    EXPECT_EQ(opt->get_expected_max(), 4);
+    EXPECT_EQ(opt->get_expected_min(), 2);
+    opt->expected(4, 2); // just test the handling of reversed arguments
+    EXPECT_EQ(opt->get_expected_max(), 4);
+    EXPECT_EQ(opt->get_expected_min(), 2);
+    opt->expected(-5);
+    EXPECT_EQ(opt->get_expected_max(), 5);
+    EXPECT_EQ(opt->get_expected_min(), 5);
+    opt->expected(-5, 7);
+    EXPECT_EQ(opt->get_expected_max(), 7);
+    EXPECT_EQ(opt->get_expected_min(), 5);
+}
+
+TEST_F(TApp, VectorFancyOpts) {
+    std::vector<std::string> strvec;
+    std::vector<std::string> answer{"mystring", "mystring2", "mystring3"};
+
+    CLI::Option *opt = app.add_option("-s,--string", strvec)->required()->expected(3);
+    EXPECT_EQ(3, opt->get_expected());
+
+    args = {"--string", "mystring", "mystring2", "mystring3"};
+    run();
+    EXPECT_EQ(3u, app.count("--string"));
+    EXPECT_EQ(answer, strvec);
+
+    args = {"one", "two"};
+    EXPECT_THROW(run(), CLI::RequiredError);
+
+    EXPECT_THROW(run(), CLI::ParseError);
+}
+
+// #87
+TEST_F(TApp, CustomDoubleOption) {
+
+    std::pair<int, double> custom_opt;
+
+    auto opt = app.add_option("posit", [&custom_opt](CLI::results_t vals) {
+        custom_opt = {stol(vals.at(0)), stod(vals.at(1))};
+        return true;
+    });
+    opt->type_name("INT FLOAT")->type_size(2);
+
+    args = {"12", "1.5"};
+
+    run();
+    EXPECT_EQ(custom_opt.first, 12);
+    EXPECT_DOUBLE_EQ(custom_opt.second, 1.5);
+}
+
+// now with tuple support this is possible
+TEST_F(TApp, CustomDoubleOptionAlt) {
+
+    std::pair<int, double> custom_opt;
+
+    app.add_option("posit", custom_opt);
+
+    args = {"12", "1.5"};
+
+    run();
+    EXPECT_EQ(custom_opt.first, 12);
+    EXPECT_DOUBLE_EQ(custom_opt.second, 1.5);
+}
+
+// now with independent type sizes and expected this is possible
+TEST_F(TApp, vectorPair) {
+
+    std::vector<std::pair<int, std::string>> custom_opt;
+
+    auto opt = app.add_option("--dict", custom_opt);
+
+    args = {"--dict", "1", "str1", "--dict", "3", "str3"};
+
+    run();
+    ASSERT_EQ(custom_opt.size(), 2u);
+    EXPECT_EQ(custom_opt[0].first, 1);
+    EXPECT_EQ(custom_opt[1].second, "str3");
+
+    args = {"--dict", "1", "str1", "--dict", "3", "str3", "--dict", "-1", "str4"};
+    run();
+    ASSERT_EQ(custom_opt.size(), 3u);
+    EXPECT_EQ(custom_opt[2].first, -1);
+    EXPECT_EQ(custom_opt[2].second, "str4");
+    opt->check(CLI::PositiveNumber.application_index(0));
+
+    EXPECT_THROW(run(), CLI::ValidationError);
+}
+
+TEST_F(TApp, vectorPairFail) {
+
+    std::vector<std::pair<int, std::string>> custom_opt;
+
+    app.add_option("--dict", custom_opt);
+
+    args = {"--dict", "1", "str1", "--dict", "str3", "1"};
+
+    EXPECT_THROW(run(), CLI::ConversionError);
+}
+
+TEST_F(TApp, vectorPairTypeRange) {
+
+    std::vector<std::pair<int, std::string>> custom_opt;
+
+    auto opt = app.add_option("--dict", custom_opt);
+
+    opt->type_size(2, 1); // just test switched arguments
+    EXPECT_EQ(opt->get_type_size_min(), 1);
+    EXPECT_EQ(opt->get_type_size_max(), 2);
+
+    args = {"--dict", "1", "str1", "--dict", "3", "str3"};
+
+    run();
+    ASSERT_EQ(custom_opt.size(), 2u);
+    EXPECT_EQ(custom_opt[0].first, 1);
+    EXPECT_EQ(custom_opt[1].second, "str3");
+
+    args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
+    run();
+    ASSERT_EQ(custom_opt.size(), 3u);
+    EXPECT_TRUE(custom_opt[1].second.empty());
+    EXPECT_EQ(custom_opt[2].first, -1);
+    EXPECT_EQ(custom_opt[2].second, "str4");
+
+    opt->type_size(-2, -1); // test negative arguments
+    EXPECT_EQ(opt->get_type_size_min(), 1);
+    EXPECT_EQ(opt->get_type_size_max(), 2);
+    // this type size spec should run exactly as before
+    run();
+    ASSERT_EQ(custom_opt.size(), 3u);
+    EXPECT_TRUE(custom_opt[1].second.empty());
+    EXPECT_EQ(custom_opt[2].first, -1);
+    EXPECT_EQ(custom_opt[2].second, "str4");
+}
+
+// now with independent type sizes and expected this is possible
+TEST_F(TApp, vectorTuple) {
+
+    std::vector<std::tuple<int, std::string, double>> custom_opt;
+
+    auto opt = app.add_option("--dict", custom_opt);
+
+    args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
+
+    run();
+    ASSERT_EQ(custom_opt.size(), 2u);
+    EXPECT_EQ(std::get<0>(custom_opt[0]), 1);
+    EXPECT_EQ(std::get<1>(custom_opt[1]), "str3");
+    EXPECT_EQ(std::get<2>(custom_opt[1]), 2.7);
+
+    args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
+    run();
+    ASSERT_EQ(custom_opt.size(), 3u);
+    EXPECT_EQ(std::get<0>(custom_opt[2]), -1);
+    EXPECT_EQ(std::get<1>(custom_opt[2]), "str4");
+    EXPECT_EQ(std::get<2>(custom_opt[2]), -1.87);
+    opt->check(CLI::PositiveNumber.application_index(0));
+
+    EXPECT_THROW(run(), CLI::ValidationError);
+
+    args.back() = "haha";
+    args[9] = "45";
+    EXPECT_THROW(run(), CLI::ConversionError);
+}
+
+// now with independent type sizes and expected this is possible
+TEST_F(TApp, vectorVector) {
+
+    std::vector<std::vector<int>> custom_opt;
+
+    auto opt = app.add_option("--dict", custom_opt);
+
+    args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
+
+    run();
+    ASSERT_EQ(custom_opt.size(), 2u);
+    EXPECT_EQ(custom_opt[0].size(), 3u);
+    EXPECT_EQ(custom_opt[1].size(), 2u);
+
+    args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
+            "3",      "3", "3", "3", "3",      "3", "3", "3",      "3", "-3"};
+    run();
+    ASSERT_EQ(custom_opt.size(), 4u);
+    EXPECT_EQ(custom_opt[0].size(), 3u);
+    EXPECT_EQ(custom_opt[1].size(), 2u);
+    EXPECT_EQ(custom_opt[2].size(), 1u);
+    EXPECT_EQ(custom_opt[3].size(), 10u);
+    opt->check(CLI::PositiveNumber.application_index(9));
+
+    EXPECT_THROW(run(), CLI::ValidationError);
+    args.pop_back();
+    EXPECT_NO_THROW(run());
+
+    args.back() = "haha";
+    EXPECT_THROW(run(), CLI::ConversionError);
+
+    args = {"--dict", "1", "2", "4", "%%", "3", "1", "%%", "3", "%%", "3", "3", "3", "3", "3", "3", "3", "3", "3", "3"};
+    run();
+    ASSERT_EQ(custom_opt.size(), 4u);
+}
+
+// now with independent type sizes and expected this is possible
+TEST_F(TApp, vectorVectorFixedSize) {
+
+    std::vector<std::vector<int>> custom_opt;
+
+    auto opt = app.add_option("--dict", custom_opt)->type_size(4);
+
+    args = {"--dict", "1", "2", "4", "3", "--dict", "3", "1", "2", "8"};
+
+    run();
+    ASSERT_EQ(custom_opt.size(), 2u);
+    EXPECT_EQ(custom_opt[0].size(), 4u);
+    EXPECT_EQ(custom_opt[1].size(), 4u);
+
+    args = {"--dict", "1", "2", "4", "--dict", "3", "1", "7", "6"};
+    EXPECT_THROW(run(), CLI::ConversionError);
+    // this should reset it
+    opt->type_size(CLI::detail::expected_max_vector_size);
+    opt->type_size(1, CLI::detail::expected_max_vector_size);
+    EXPECT_NO_THROW(run());
+    ASSERT_EQ(custom_opt.size(), 2U);
+}
+
+// now with independent type sizes and expected this is possible
+TEST_F(TApp, tuplePair) {
+    std::tuple<std::pair<int, double>> custom_opt;
+
+    app.add_option("--pr", custom_opt);
+
+    args = {"--pr", "1", "2"};
+
+    run();
+    EXPECT_EQ(std::get<0>(custom_opt).first, 1);
+    EXPECT_EQ(std::get<0>(custom_opt).second, 2.0);
+}
+// now with independent type sizes and expected this is possible
+TEST_F(TApp, tupleintPair) {
+    std::tuple<int, std::pair<int, double>> custom_opt;
+
+    app.add_option("--pr", custom_opt);
+
+    args = {"--pr", "3", "1", "2"};
+
+    run();
+    EXPECT_EQ(std::get<0>(custom_opt), 3);
+    EXPECT_EQ(std::get<1>(custom_opt).first, 1);
+    EXPECT_EQ(std::get<1>(custom_opt).second, 2.0);
+}
+
+static_assert(CLI::detail::is_mutable_container<std::set<std::string>>::value, "set should be a container");
+static_assert(CLI::detail::is_mutable_container<std::map<std::string, std::string>>::value,
+              "map should be a container");
+static_assert(CLI::detail::is_mutable_container<std::unordered_map<std::string, double>>::value,
+              "unordered_map should be a container");
+
+static_assert(CLI::detail::is_mutable_container<std::list<std::pair<int, std::string>>>::value,
+              "list should be a container");
+
+static_assert(CLI::detail::type_count<std::set<std::string>>::value == 1, "set should have a type size of 1");
+static_assert(CLI::detail::type_count<std::set<std::tuple<std::string, int, int>>>::value == 3,
+              "tuple set should have size of 3");
+static_assert(CLI::detail::type_count<std::map<std::string, std::string>>::value == 2,
+              "map should have a type size of 2");
+static_assert(CLI::detail::type_count<std::unordered_map<std::string, double>>::value == 2,
+              "unordered_map should have a type size of 2");
+
+static_assert(CLI::detail::type_count<std::list<std::pair<int, std::string>>>::value == 2,
+              "list<int,string> should have a type size of 2");
+static_assert(CLI::detail::type_count<std::map<std::string, std::pair<int, std::string>>>::value == 3,
+              "map<string,pair<int,string>> should have a type size of 3");
+
+template <class T> class TApp_container_single : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_single() : TApp(){};
+};
+
+using containerTypes_single =
+    ::testing::Types<std::vector<int>, std::deque<int>, std::set<int>, std::list<int>, std::unordered_set<int>>;
+
+TYPED_TEST_SUITE(TApp_container_single, containerTypes_single, );
+
+TYPED_TEST(TApp_container_single, containerInt) {
+
+    auto &cv = TApp_container_single<TypeParam>::cval;
+    CLI::Option *opt = (TApp::app).add_option("-v", cv);
+
+    TApp::args = {"-v", "1", "-1", "-v", "3", "-v", "-976"};
+    TApp::run();
+    EXPECT_EQ(4u, (TApp::app).count("-v"));
+    EXPECT_EQ(4u, cv.size());
+    opt->check(CLI::PositiveNumber.application_index(0));
+    opt->check((!CLI::PositiveNumber).application_index(1));
+    EXPECT_NO_THROW(TApp::run());
+    EXPECT_EQ(4u, cv.size());
+    // v[3] would be negative
+    opt->check(CLI::PositiveNumber.application_index(3));
+    EXPECT_THROW(TApp::run(), CLI::ValidationError);
+}
+
+template <class T> class TApp_container_pair : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_pair() : TApp(){};
+};
+
+using isp = std::pair<int, std::string>;
+using containerTypes_pair = ::testing::Types<std::vector<isp>,
+                                             std::deque<isp>,
+                                             std::set<isp>,
+                                             std::list<isp>,
+                                             std::map<int, std::string>,
+                                             std::unordered_map<int, std::string>>;
+
+TYPED_TEST_SUITE(TApp_container_pair, containerTypes_pair, );
+
+TYPED_TEST(TApp_container_pair, containerPair) {
+
+    auto &cv = TApp_container_pair<TypeParam>::cval;
+    (TApp::app).add_option("--dict", cv);
+
+    TApp::args = {"--dict", "1", "str1", "--dict", "3", "str3"};
+
+    TApp::run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    TApp::args = {"--dict", "1", "str1", "--dict", "3", "--dict", "-1", "str4"};
+    TApp::run();
+    EXPECT_EQ(cv.size(), 3u);
+}
+
+template <class T> class TApp_container_tuple : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_tuple() : TApp(){};
+};
+
+using tup_obj = std::tuple<int, std::string, double>;
+using containerTypes_tuple = ::testing::Types<std::vector<tup_obj>,
+                                              std::deque<tup_obj>,
+                                              std::set<tup_obj>,
+                                              std::list<tup_obj>,
+                                              std::map<int, std::pair<std::string, double>>,
+                                              std::unordered_map<int, std::tuple<std::string, double>>>;
+
+TYPED_TEST_SUITE(TApp_container_tuple, containerTypes_tuple, );
+
+TYPED_TEST(TApp_container_tuple, containerTuple) {
+
+    auto &cv = TApp_container_tuple<TypeParam>::cval;
+    (TApp::app).add_option("--dict", cv);
+
+    TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7"};
+
+    TApp::run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    TApp::args = {"--dict", "1", "str1", "4.3", "--dict", "3", "str3", "2.7", "--dict", "-1", "str4", "-1.87"};
+    TApp::run();
+    EXPECT_EQ(cv.size(), 3u);
+}
+
+using icontainer1 = std::vector<int>;
+using icontainer2 = std::list<int>;
+using icontainer3 = std::set<int>;
+using icontainer4 = std::pair<int, std::vector<int>>;
+
+using containerTypes_container = ::testing::Types<std::vector<icontainer1>,
+                                                  std::list<icontainer1>,
+                                                  std::set<icontainer1>,
+                                                  std::deque<icontainer1>,
+                                                  std::vector<icontainer2>,
+                                                  std::list<icontainer2>,
+                                                  std::set<icontainer2>,
+                                                  std::deque<icontainer2>,
+                                                  std::vector<icontainer3>,
+                                                  std::list<icontainer3>,
+                                                  std::set<icontainer3>,
+                                                  std::deque<icontainer3>>;
+
+template <class T> class TApp_container_container : public TApp {
+  public:
+    using container_type = T;
+    container_type cval{};
+    TApp_container_container() : TApp(){};
+};
+
+TYPED_TEST_SUITE(TApp_container_container, containerTypes_container, );
+
+TYPED_TEST(TApp_container_container, containerContainer) {
+
+    auto &cv = TApp_container_container<TypeParam>::cval;
+    (TApp::app).add_option("--dict", cv);
+
+    TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
+
+    TApp::run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    TApp::args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "--dict",
+                  "3",      "3", "3", "3", "3",      "3", "3", "3",      "3", "-3"};
+    TApp::run();
+    EXPECT_EQ(cv.size(), 4u);
+}
+
+TEST_F(TApp, containerContainer) {
+
+    std::vector<icontainer4> cv;
+    app.add_option("--dict", cv);
+
+    args = {"--dict", "1", "2", "4", "--dict", "3", "1"};
+
+    run();
+    EXPECT_EQ(cv.size(), 2u);
+
+    args = {"--dict", "1", "2", "4", "--dict", "3", "1", "--dict", "3", "",  "--dict",
+            "3",      "3", "3", "3", "3",      "3", "3", "3",      "3", "-3"};
+    run();
+    EXPECT_EQ(cv.size(), 4u);
+}
+
+TEST_F(TApp, unknownContainerWrapper) {
+
+    class vopt {
+      public:
+        vopt() = default;
+        vopt(const std::vector<double> &vdub) : val_{vdub} {};
+        std::vector<double> val_{};
+    };
+
+    vopt cv;
+    app.add_option<vopt, std::vector<double>>("--vv", cv);
+
+    args = {"--vv", "1", "2", "4"};
+
+    run();
+    EXPECT_EQ(cv.val_.size(), 3u);
+    args = {"--vv", ""};
+
+    run();
+    EXPECT_TRUE(cv.val_.empty());
+}
+
+TEST_F(TApp, tupleTwoVectors) {
+
+    std::tuple<std::vector<int>, std::vector<int>> cv;
+    app.add_option("--vv", cv);
+
+    args = {"--vv", "1", "2", "4"};
+
+    run();
+    EXPECT_EQ(std::get<0>(cv).size(), 3U);
+    EXPECT_TRUE(std::get<1>(cv).empty());
+
+    args = {"--vv", "1", "2", "%%", "4", "4", "5"};
+
+    run();
+    EXPECT_EQ(std::get<0>(cv).size(), 2U);
+    EXPECT_EQ(std::get<1>(cv).size(), 3U);
+}
diff --git a/tests/OptionalTest.cpp b/tests/OptionalTest.cpp
index 598d16c55..6a11839dc 100644
--- a/tests/OptionalTest.cpp
+++ b/tests/OptionalTest.cpp
@@ -1,3 +1,4 @@
+#include <complex>
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
@@ -72,6 +73,44 @@ TEST_F(TApp, StdOptionalTest) {
     EXPECT_EQ(*opt, 3);
 }
 
+TEST_F(TApp, StdOptionalVectorEmptyDirect) {
+    std::optional<std::vector<int>> opt;
+    app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
+    // app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-v"};
+    opt = std::vector<int>{4, 3};
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-v", "1", "4", "5"};
+    run();
+    EXPECT_TRUE(opt);
+    std::vector<int> expV{1, 4, 5};
+    EXPECT_EQ(*opt, expV);
+}
+
+TEST_F(TApp, StdOptionalComplexDirect) {
+    std::optional<std::complex<double>> opt;
+    app.add_option("-c,--complex", opt)->type_size(0, 2);
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-c"};
+    opt = std::complex<double>{4.0, 3.0};
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-c", "1+2j"};
+    run();
+    EXPECT_TRUE(opt);
+    std::complex<double> val{1, 2};
+    EXPECT_EQ(*opt, val);
+    args = {"-c", "3", "-4"};
+    run();
+    EXPECT_TRUE(opt);
+    std::complex<double> val2{3, -4};
+    EXPECT_EQ(*opt, val2);
+}
+
 #ifdef _MSC_VER
 #pragma warning(default : 4244)
 #endif
@@ -165,11 +204,16 @@ TEST_F(TApp, BoostOptionalStringTest) {
     EXPECT_TRUE(opt);
     EXPECT_EQ(*opt, "strv");
 }
+namespace boost {
+using CLI::enums::operator<<;
+}
 
 TEST_F(TApp, BoostOptionalEnumTest) {
+
     enum class eval : char { val0 = 0, val1 = 1, val2 = 2, val3 = 3, val4 = 4 };
-    boost::optional<eval> opt;
+    boost::optional<eval> opt, opt2;
     auto optptr = app.add_option<decltype(opt), eval>("-v,--val", opt);
+    app.add_option_no_stream("-e,--eval", opt2);
     optptr->capture_default_str();
 
     auto dstring = optptr->get_default_str();
@@ -206,6 +250,7 @@ TEST_F(TApp, BoostOptionalVector) {
 TEST_F(TApp, BoostOptionalVectorEmpty) {
     boost::optional<std::vector<int>> opt;
     app.add_option<decltype(opt), std::vector<int>>("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
+    // app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
     run();
     EXPECT_FALSE(opt);
     args = {"-v"};
@@ -219,6 +264,44 @@ TEST_F(TApp, BoostOptionalVectorEmpty) {
     EXPECT_EQ(*opt, expV);
 }
 
+TEST_F(TApp, BoostOptionalVectorEmptyDirect) {
+    boost::optional<std::vector<int>> opt;
+    app.add_option_no_stream("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
+    // app.add_option("-v,--vec", opt)->expected(0, 3)->allow_extra_args();
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-v"};
+    opt = std::vector<int>{4, 3};
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-v", "1", "4", "5"};
+    run();
+    EXPECT_TRUE(opt);
+    std::vector<int> expV{1, 4, 5};
+    EXPECT_EQ(*opt, expV);
+}
+
+TEST_F(TApp, BoostOptionalComplexDirect) {
+    boost::optional<std::complex<double>> opt;
+    app.add_option("-c,--complex", opt)->type_size(0, 2);
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-c"};
+    opt = std::complex<double>{4.0, 3.0};
+    run();
+    EXPECT_FALSE(opt);
+    args = {"-c", "1+2j"};
+    run();
+    EXPECT_TRUE(opt);
+    std::complex<double> val{1, 2};
+    EXPECT_EQ(*opt, val);
+    args = {"-c", "3", "-4"};
+    run();
+    EXPECT_TRUE(opt);
+    std::complex<double> val2{3, -4};
+    EXPECT_EQ(*opt, val2);
+}
+
 #endif
 
 #if !CLI11_OPTIONAL
diff --git a/tests/TrueFalseTest.cpp b/tests/TrueFalseTest.cpp
index a93336ed1..045bd36f0 100644
--- a/tests/TrueFalseTest.cpp
+++ b/tests/TrueFalseTest.cpp
@@ -1,7 +1,7 @@
 #include "app_helper.hpp"
 
 /// This allows a set of strings to be run over by a test
-struct TApp_TBO : public TApp, public ::testing::WithParamInterface<const char *> {};
+struct TApp_TBO : public TApp_base, testing::TestWithParam<const char *> {};
 
 TEST_P(TApp_TBO, TrueBoolOption) {
     bool value{false};  // Not used, but set just in case
@@ -13,10 +13,10 @@ TEST_P(TApp_TBO, TrueBoolOption) {
 }
 
 // Change to INSTANTIATE_TEST_SUITE_P in GTest master
-INSTANTIATE_TEST_CASE_P(TrueBoolOptions, TApp_TBO, ::testing::Values("true", "on", "True", "ON"), );
+INSTANTIATE_TEST_SUITE_P(TrueBoolOptions_test, TApp_TBO, testing::Values("true", "on", "True", "ON"));
 
 /// This allows a set of strings to be run over by a test
-struct TApp_FBO : public TApp, public ::testing::WithParamInterface<const char *> {};
+struct TApp_FBO : public TApp_base, public ::testing::TestWithParam<const char *> {};
 
 TEST_P(TApp_FBO, FalseBoolOptions) {
     bool value{true};  // Not used, but set just in case
@@ -27,4 +27,4 @@ TEST_P(TApp_FBO, FalseBoolOptions) {
     EXPECT_FALSE(value);
 }
 
-INSTANTIATE_TEST_CASE_P(FalseBoolOptions, TApp_FBO, ::testing::Values("false", "off", "False", "OFF"), );
+INSTANTIATE_TEST_SUITE_P(FalseBoolOptions_test, TApp_FBO, ::testing::Values("false", "off", "False", "OFF"));
diff --git a/tests/app_helper.hpp b/tests/app_helper.hpp
index cbbd61178..7c1262b5a 100644
--- a/tests/app_helper.hpp
+++ b/tests/app_helper.hpp
@@ -11,10 +11,11 @@
 
 using input_t = std::vector<std::string>;
 
-struct TApp : public ::testing::Test {
+class TApp_base {
+  public:
     CLI::App app{"My Test Program"};
     input_t args{};
-
+    virtual ~TApp_base() = default;
     void run() {
         // It is okay to re-parse - clear is called automatically before a parse.
         input_t newargs = args;
@@ -23,6 +24,8 @@ struct TApp : public ::testing::Test {
     }
 };
 
+class TApp : public TApp_base, public ::testing::Test {};
+
 class TempFile {
     std::string _name{};