diff --git a/README.md b/README.md
index f3ece0dc7..27af1a34b 100644
--- a/README.md
+++ b/README.md
@@ -111,7 +111,7 @@ After I wrote this, I also found the following libraries:
 | [Clara][]               | Simple library built for the excellent [Catch][] testing framework. Unique syntax, limited scope.                                                                                    |
 | [Argh!][]               | Very minimalistic C++11 parser, single header. Don't have many features. No help generation?!?! At least it's exception-free.                                                        |
 | [CLI][]                 | Custom language and parser. Huge build-system overkill for very little benefit. Last release in 2009, but still occasionally active.  |
-|[argparse][] | C++17 single file argument parser. Design seems similar to CLI11 in some ways. |
+| [argparse][] | C++17 single file argument parser. Design seems similar to CLI11 in some ways. |
 
 See [Awesome C++][] for a less-biased list of parsers. You can also find other single file libraries at [Single file libs][].
 
@@ -194,7 +194,7 @@ 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(up to 5 elements) and tuple like structures such as 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🚧.  
                help_string="")
 
 app.add_option_function<type>(option_name,
@@ -202,7 +202,7 @@ app.add_option_function<type>(option_name,
                help_string="")
 
 app.add_complex(... // Special case: support for complex numbers
-//🚧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.    
+//🚧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
                help_string="")
@@ -261,7 +261,7 @@ otherwise the output would default to a string.  The add_option can be used with
 
 Type such as optional<int>, optional<double>, and optional<string> are supported directly, other optional types can be added using the two parameter template.  See [CLI11 Internals][] for information on how this could done and how you can add your own converters for additional  types.
 
-Vector types can also be used int the two parameter template overload
+Vector types can also be used in the two parameter template overload
 ```
 std::vector<double> v1;
 app.add_option<std::vector<double>,int>("--vs",v1);
diff --git a/include/CLI/App.hpp b/include/CLI/App.hpp
index 43ceb6538..fddb01b86 100644
--- a/include/CLI/App.hpp
+++ b/include/CLI/App.hpp
@@ -1859,8 +1859,14 @@ class App {
             return detail::Classifier::SUBCOMMAND;
         if(detail::split_long(current, dummy1, dummy2))
             return detail::Classifier::LONG;
-        if(detail::split_short(current, dummy1, dummy2))
+        if(detail::split_short(current, dummy1, dummy2)) {
+            if(dummy1[0] >= '0' && dummy1[0] <= '9') {
+                if(get_option_no_throw(std::string{'-', dummy1[0]}) == nullptr) {
+                    return detail::Classifier::NONE;
+                }
+            }
             return detail::Classifier::SHORT;
+        }
         if((allow_windows_style_options_) && (detail::split_windows_style(current, dummy1, dummy2)))
             return detail::Classifier::WINDOWS;
         if((current == "++") && !name_.empty() && parent_ != nullptr)
@@ -2314,7 +2320,7 @@ class App {
                            (opt->get_items_expected() < 0 && opt->count() == 0lu)) {
                             if(validate_positionals_) {
                                 std::string pos = positional;
-                                pos = opt->_validate(pos);
+                                pos = opt->_validate(pos, 0);
                                 if(!pos.empty()) {
                                     continue;
                                 }
@@ -2334,7 +2340,7 @@ class App {
                (static_cast<int>(opt->count()) < opt->get_items_expected() || opt->get_items_expected() < 0)) {
                 if(validate_positionals_) {
                     std::string pos = positional;
-                    pos = opt->_validate(pos);
+                    pos = opt->_validate(pos, 0);
                     if(!pos.empty()) {
                         continue;
                     }
diff --git a/include/CLI/Option.hpp b/include/CLI/Option.hpp
index 5c1a2a258..8d9806770 100644
--- a/include/CLI/Option.hpp
+++ b/include/CLI/Option.hpp
@@ -408,8 +408,17 @@ class Option : public OptionBase<Option> {
         if((validator_name.empty()) && (!validators_.empty())) {
             return &(validators_.front());
         }
-        throw OptionNotFound(std::string("Validator ") + validator_name + " Not Found");
+        throw OptionNotFound(std::string{"Validator "} + validator_name + " Not Found");
     }
+
+    /// Get a Validator by index NOTE: this may not be the order of definition
+    Validator *get_validator(int index) {
+        if(index >= 0 && index < static_cast<int>(validators_.size())) {
+            return &(validators_[index]);
+        }
+        throw OptionNotFound("Validator index is not valid");
+    }
+
     /// Sets required options
     Option *needs(Option *opt) {
         auto tup = needs_.insert(opt);
@@ -679,8 +688,17 @@ class Option : public OptionBase<Option> {
 
         // Run the validators (can change the string)
         if(!validators_.empty()) {
+            int index = 0;
+            // this is not available until multi_option_policy with type_size_>0 is enabled and functional
+            // if(type_size_ > 0 && multi_option_policy_ == CLI::MultiOptionPolicy::TakeLast) {
+            //    index = type_size_ - static_cast<int>(results_.size());
+            //}
+            if(type_size_ < 0 && multi_option_policy_ == CLI::MultiOptionPolicy::TakeLast) { // for vector operations
+                index = expected_ - static_cast<int>(results_.size());
+            }
             for(std::string &result : results_) {
-                auto err_msg = _validate(result);
+                auto err_msg = _validate(result, index);
+                ++index;
                 if(!err_msg.empty())
                     throw ValidationError(get_name(), err_msg);
             }
@@ -977,16 +995,19 @@ class Option : public OptionBase<Option> {
 
   private:
     // Run a result through the validators
-    std::string _validate(std::string &result) {
+    std::string _validate(std::string &result, int index) {
         std::string err_msg;
         for(const auto &vali : validators_) {
-            try {
-                err_msg = vali(result);
-            } catch(const ValidationError &err) {
-                err_msg = err.what();
+            auto v = vali.get_application_index();
+            if(v == -1 || v == index) {
+                try {
+                    err_msg = vali(result);
+                } catch(const ValidationError &err) {
+                    err_msg = err.what();
+                }
+                if(!err_msg.empty())
+                    break;
             }
-            if(!err_msg.empty())
-                break;
         }
         return err_msg;
     }
diff --git a/include/CLI/TypeTools.hpp b/include/CLI/TypeTools.hpp
index b8ea09ae9..66a2909fe 100644
--- a/include/CLI/TypeTools.hpp
+++ b/include/CLI/TypeTools.hpp
@@ -137,12 +137,14 @@ struct pair_adaptor<
 // check for constructibility from a specific type and copy assignable used in the parse detection
 template <typename T, typename C> class is_direct_constructible {
     template <typename TT, typename CC>
-    static auto test(int) -> decltype(TT{std::declval<CC>()}, std::is_move_assignable<TT>());
+    static auto test(int, std::true_type) -> decltype(TT{std::declval<CC>()}, std::is_move_assignable<TT>());
+
+    template <typename TT, typename CC> static auto test(int, std::false_type) -> std::false_type;
 
     template <typename, typename> static auto test(...) -> std::false_type;
 
   public:
-    static constexpr bool value = decltype(test<T, C>(0))::value;
+    static constexpr bool value = decltype(test<T, C>(0, typename std::is_constructible<T, C>::type()))::value;
 };
 #ifdef __GNUC__
 #pragma GCC diagnostic pop
@@ -363,28 +365,28 @@ template <typename T> struct uncommon_type {
 
 /// Assignable from double or int
 template <typename T>
-struct classify_object<
-    T,
-    typename std::enable_if<uncommon_type<T>::value && is_direct_constructible<T, double>::value &&
-                            is_direct_constructible<T, int>::value && type_count<T>::value == 1>::type> {
+struct classify_object<T,
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               is_direct_constructible<T, double>::value &&
+                                               is_direct_constructible<T, int>::value>::type> {
     static constexpr objCategory value{number_constructible};
 };
 
 /// Assignable from int
 template <typename T>
-struct classify_object<
-    T,
-    typename std::enable_if<uncommon_type<T>::value && !is_direct_constructible<T, double>::value &&
-                            is_direct_constructible<T, int>::value && type_count<T>::value == 1>::type> {
+struct classify_object<T,
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               !is_direct_constructible<T, double>::value &&
+                                               is_direct_constructible<T, int>::value>::type> {
     static constexpr objCategory value{integer_constructible};
 };
 
 /// Assignable from double
 template <typename T>
-struct classify_object<
-    T,
-    typename std::enable_if<uncommon_type<T>::value && is_direct_constructible<T, double>::value &&
-                            !is_direct_constructible<T, int>::value && type_count<T>::value == 1>::type> {
+struct classify_object<T,
+                       typename std::enable_if<uncommon_type<T>::value && type_count<T>::value == 1 &&
+                                               is_direct_constructible<T, double>::value &&
+                                               !is_direct_constructible<T, int>::value>::type> {
     static constexpr objCategory value{double_constructible};
 };
 
@@ -392,9 +394,9 @@ struct classify_object<
 template <typename T>
 struct classify_object<
     T,
-    typename std::enable_if<(is_tuple_like<T>::value && uncommon_type<T>::value &&
-                             !is_direct_constructible<T, double>::value && !is_direct_constructible<T, int>::value) ||
-                            type_count<T>::value >= 2>::type> {
+    typename std::enable_if<type_count<T>::value >= 2 || (is_tuple_like<T>::value && uncommon_type<T>::value &&
+                                                          !is_direct_constructible<T, double>::value &&
+                                                          !is_direct_constructible<T, int>::value)>::type> {
     static constexpr objCategory value{tuple_value};
 };
 
@@ -454,54 +456,39 @@ constexpr const char *type_name() {
     return type_name<typename T::value_type>();
 }
 
-/// Print name for tuple types
+/// Print name for single element tuple types
 template <
     typename T,
     enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value == 1, detail::enabler> = detail::dummy>
 std::string type_name() {
     return type_name<typename std::tuple_element<0, T>::type>();
 }
-/// Print type name for 2 element tuples
-template <
-    typename T,
-    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value == 2, detail::enabler> = detail::dummy>
-std::string type_name() {
-    return std::string("[") + type_name<typename std::tuple_element<0, T>::type>() + "," +
-           type_name<typename std::tuple_element<1, T>::type>() + "]";
-}
 
-/// Print type name for 3 element tuples
-template <
-    typename T,
-    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value == 3, detail::enabler> = detail::dummy>
-std::string type_name() {
-    return std::string("[") + type_name<typename std::tuple_element<0, T>::type>() + "," +
-           type_name<typename std::tuple_element<1, T>::type>() + "," +
-           type_name<typename std::tuple_element<2, T>::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() {
+    return std::string{};
 }
 
-/// Print type name for 4 element tuples
-template <
-    typename T,
-    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value == 4, detail::enabler> = detail::dummy>
-std::string type_name() {
-    return std::string("[") + type_name<typename std::tuple_element<0, T>::type>() + "," +
-           type_name<typename std::tuple_element<1, T>::type>() + "," +
-           type_name<typename std::tuple_element<2, T>::type>() + "," +
-           type_name<typename std::tuple_element<3, T>::type>() + "]";
+/// 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>();
+    if(str.back() == ',')
+        str.pop_back();
+    return str;
 }
 
-/// Print type name for 5 element tuples
+/// Print type name for tuples with 2 or more elements
 template <
     typename T,
-    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value == 5, detail::enabler> = detail::dummy>
+    enable_if_t<classify_object<T>::value == tuple_value && type_count<T>::value >= 2, detail::enabler> = detail::dummy>
 std::string type_name() {
-    return std::string("[") + type_name<typename std::tuple_element<0, T>::type>() + "," +
-           type_name<typename std::tuple_element<1, T>::type>() + "," +
-           type_name<typename std::tuple_element<2, T>::type>() + "," +
-           type_name<typename std::tuple_element<3, T>::type>() + "," +
-           type_name<typename std::tuple_element<4, T>::type>() + "]";
+    auto tname = std::string(1, '[') + tuple_name<T, 0>();
+    tname.push_back(']');
+    return tname;
 }
+
 // Lexical cast
 
 /// Convert a flag into an integer value  typically binary flags
@@ -777,101 +764,34 @@ bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
     return (!output.empty()) && retval;
 }
 
-/// Conversion for single element tuple and single element tuple conversion type
-template <class T,
-          class XC,
-          enable_if_t<type_count<T>::value == 1 && is_tuple_like<T>::value && is_tuple_like<XC>::value,
-                      detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    static_assert(type_count<T>::value == type_count<XC>::value,
-                  "when using converting to tuples different cross conversion are not possible");
-
-    bool retval = lexical_assign<typename std::tuple_element<0, T>::type, typename std::tuple_element<0, XC>::type>(
-        strings[0], std::get<0>(output));
-    return retval;
-}
-
-/// Conversion for single element tuple and single defined type
-template <class T,
-          class XC,
-          enable_if_t<type_count<T>::value == 1 && is_tuple_like<T>::value && !is_tuple_like<XC>::value,
-                      detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    static_assert(type_count<T>::value == type_count<XC>::value,
-                  "when using converting to tuples different cross conversion are not possible");
-
-    bool retval = lexical_assign<typename std::tuple_element<0, T>::type, XC>(strings[0], std::get<0>(output));
-    return retval;
-}
-
-/// conversion for two element tuple
-template <class T, class XC, enable_if_t<type_count<T>::value == 2, detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    static_assert(type_count<T>::value == type_count<XC>::value,
-                  "when using converting to tuples different cross conversion are not possible");
-
-    bool retval = lexical_cast(strings[0], std::get<0>(output));
-    if(strings.size() > 1) {
-        retval &= lexical_cast(strings[1], std::get<1>(output));
-    }
-    return retval;
-}
-
-/// conversion for three element tuple
-template <class T, class XC, enable_if_t<type_count<T>::value == 3, detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    static_assert(type_count<T>::value == type_count<XC>::value,
-                  "when using converting to tuples different cross conversion are not possible");
-
-    bool retval = lexical_cast(strings[0], std::get<0>(output));
-    if(strings.size() > 1) {
-        retval &= lexical_cast(strings[1], std::get<1>(output));
-    }
-    if(strings.size() > 2) {
-        retval &= lexical_cast(strings[2], std::get<2>(output));
-    }
-    return retval;
+/// 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 &) {
+    return true;
 }
-
-/// conversion for four element tuple
-template <class T, class XC, enable_if_t<type_count<T>::value == 4, detail::enabler> = detail::dummy>
-bool lexical_conversion(const std::vector<std ::string> &strings, T &output) {
-    static_assert(type_count<T>::value == type_count<XC>::value,
-                  "when using converting to tuples different cross conversion are not possible");
-
-    bool retval = lexical_cast(strings[0], std::get<0>(output));
-    if(strings.size() > 1) {
-        retval &= lexical_cast(strings[1], std::get<1>(output));
-    }
-    if(strings.size() > 2) {
-        retval &= lexical_cast(strings[2], std::get<2>(output));
-    }
-    if(strings.size() > 3) {
-        retval &= lexical_cast(strings[3], std::get<3>(output));
+/// 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) {
+    bool retval = true;
+    if(strings.size() > I) {
+        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));
     }
+    retval &= tuple_conversion<T, XC, I + 1>(strings, output);
     return retval;
 }
 
-/// conversion for five element tuple
-template <class T, class XC, enable_if_t<type_count<T>::value == 5, detail::enabler> = detail::dummy>
+/// 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) {
-    static_assert(type_count<T>::value == type_count<XC>::value,
-                  "when using converting to tuples different cross conversion are not possible");
-
-    bool retval = lexical_cast(strings[0], std::get<0>(output));
-    if(strings.size() > 1) {
-        retval &= lexical_cast(strings[1], std::get<1>(output));
-    }
-    if(strings.size() > 2) {
-        retval &= lexical_cast(strings[2], std::get<2>(output));
-    }
-    if(strings.size() > 3) {
-        retval &= lexical_cast(strings[3], std::get<3>(output));
-    }
-    if(strings.size() > 4) {
-        retval &= lexical_cast(strings[4], std::get<4>(output));
-    }
-    return retval;
+    static_assert(
+        !is_tuple_like<XC>::value || type_count<T>::value == type_count<XC>::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);
 }
 
 /// Sum a vector of flag representations
diff --git a/include/CLI/Validators.hpp b/include/CLI/Validators.hpp
index 51b46762e..e3736845d 100644
--- a/include/CLI/Validators.hpp
+++ b/include/CLI/Validators.hpp
@@ -43,6 +43,8 @@ class Validator {
     std::function<std::string(std::string &)> func_{[](std::string &) { return std::string{}; }};
     /// The name for search purposes of the Validator
     std::string name_;
+    /// A Validator will only apply to an indexed value (-1 is all elements)
+    int application_index_ = -1;
     /// Enable for Validator to allow it to be disabled if need be
     bool active_{true};
     /// specify that a validator should not modify the input
@@ -52,7 +54,7 @@ class Validator {
     Validator() = default;
     /// Construct a Validator with just the description string
     explicit Validator(std::string validator_desc) : desc_function_([validator_desc]() { return validator_desc; }) {}
-    // Construct Validator from basic information
+    /// Construct Validator from basic information
     Validator(std::function<std::string(std::string &)> op, std::string validator_desc, std::string validator_name = "")
         : desc_function_([validator_desc]() { return validator_desc; }), func_(std::move(op)),
           name_(std::move(validator_name)) {}
@@ -88,6 +90,12 @@ class Validator {
         desc_function_ = [validator_desc]() { return validator_desc; };
         return *this;
     }
+    /// Specify the type string
+    Validator description(std::string validator_desc) const {
+        Validator newval(*this);
+        newval.desc_function_ = [validator_desc]() { return validator_desc; };
+        return newval;
+    }
     /// Generate type description information for the Validator
     std::string get_description() const {
         if(active_) {
@@ -100,6 +108,12 @@ class Validator {
         name_ = std::move(validator_name);
         return *this;
     }
+    /// Specify the type string
+    Validator name(std::string validator_name) const {
+        Validator newval(*this);
+        newval.name_ = std::move(validator_name);
+        return newval;
+    }
     /// Get the name of the Validator
     const std::string &get_name() const { return name_; }
     /// Specify whether the Validator is active or not
@@ -107,13 +121,31 @@ class Validator {
         active_ = active_val;
         return *this;
     }
+    /// Specify whether the Validator is active or not
+    Validator active(bool active_val = true) const {
+        Validator newval(*this);
+        newval.active_ = active_val;
+        return newval;
+    }
 
     /// Specify whether the Validator can be modifying or not
     Validator &non_modifying(bool no_modify = true) {
         non_modifying_ = no_modify;
         return *this;
     }
-
+    /// Specify the application index of a validator
+    Validator &application_index(int app_index) {
+        application_index_ = app_index;
+        return *this;
+    };
+    /// Specify the application index of a validator
+    Validator application_index(int app_index) const {
+        Validator newval(*this);
+        newval.application_index_ = app_index;
+        return newval;
+    };
+    /// Get the current value of the application index
+    int get_application_index() const { return application_index_; }
     /// Get a boolean if the validator is active
     bool get_active() const { return active_; }
 
@@ -141,6 +173,7 @@ class Validator {
         };
 
         newval.active_ = (active_ & other.active_);
+        newval.application_index_ = application_index_;
         return newval;
     }
 
@@ -164,6 +197,7 @@ class Validator {
             return std::string("(") + s1 + ") OR (" + s2 + ")";
         };
         newval.active_ = (active_ & other.active_);
+        newval.application_index_ = application_index_;
         return newval;
     }
 
@@ -186,6 +220,7 @@ class Validator {
             return std::string{};
         };
         newval.active_ = active_;
+        newval.application_index_ = application_index_;
         return newval;
     }
 
@@ -201,10 +236,10 @@ class Validator {
             if((f1.empty()) || (f2.empty())) {
                 return f1 + f2;
             }
-            return std::string("(") + f1 + ")" + merger + "(" + f2 + ")";
+            return std::string(1, '(') + f1 + ')' + merger + '(' + f2 + ')';
         };
     }
-};
+}; // namespace CLI
 
 /// Class wrapping some of the accessors of Validator
 class CustomValidator : public Validator {
diff --git a/tests/AppTest.cpp b/tests/AppTest.cpp
index f7334f4dc..8037cae2f 100644
--- a/tests/AppTest.cpp
+++ b/tests/AppTest.cpp
@@ -800,6 +800,19 @@ TEST_F(TApp, TakeLastOptMulti) {
     EXPECT_EQ(vals, std::vector<int>({2, 3}));
 }
 
+TEST_F(TApp, TakeLastOptMultiCheck) {
+    std::vector<int> vals;
+    auto opt = app.add_option("--long", vals)->expected(2)->take_last();
+
+    opt->check(CLI::Validator(CLI::PositiveNumber).application_index(0));
+    opt->check((!CLI::PositiveNumber).application_index(1));
+    args = {"--long", "-1", "2", "-3"};
+
+    EXPECT_NO_THROW(run());
+
+    EXPECT_EQ(vals, std::vector<int>({2, -3}));
+}
+
 TEST_F(TApp, TakeFirstOptMulti) {
     std::vector<int> vals;
     app.add_option("--long", vals)->expected(2)->take_first();
@@ -1064,8 +1077,9 @@ TEST_F(TApp, PositionalValidation) {
     std::string options;
     std::string foo;
 
-    app.add_option("bar", options)->check(CLI::Number);
-    app.add_option("foo", foo);
+    app.add_option("bar", options)->check(CLI::Number.name("valbar"));
+    // disable the check on foo
+    app.add_option("foo", foo)->check(CLI::Number.active(false));
     app.validate_positionals();
     args = {"1", "param1"};
     run();
@@ -1074,10 +1088,12 @@ TEST_F(TApp, PositionalValidation) {
     EXPECT_EQ(foo, "param1");
 
     args = {"param1", "1"};
-    run();
+    EXPECT_NO_THROW(run());
 
     EXPECT_EQ(options, "1");
     EXPECT_EQ(foo, "param1");
+
+    EXPECT_NE(app.get_option("bar")->get_validator("valbar"), nullptr);
 }
 
 TEST_F(TApp, PositionalNoSpaceLong) {
@@ -1591,6 +1607,63 @@ 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"};
@@ -1617,6 +1690,24 @@ TEST_F(TApp, VectorDefaultedFixedString) {
     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;
@@ -2118,6 +2209,20 @@ TEST_F(TApp, CustomDoubleOption) {
     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);
+}
+
 // #128
 TEST_F(TApp, RepeatingMultiArgumentOptions) {
     std::vector<std::string> entries;
diff --git a/tests/HelpTest.cpp b/tests/HelpTest.cpp
index 2ca7655ad..229d441b0 100644
--- a/tests/HelpTest.cpp
+++ b/tests/HelpTest.cpp
@@ -798,6 +798,16 @@ TEST(THelp, ValidatorsText) {
     EXPECT_THAT(help, HasSubstr("UINT:INT in [0 - 12]")); // Loses UINT
 }
 
+TEST(THelp, ValidatorsTextCustom) {
+    CLI::App app;
+
+    std::string filename;
+    app.add_option("--f1", filename)->check(CLI::ExistingFile.description("Existing file"));
+
+    std::string help = app.help();
+    EXPECT_THAT(help, HasSubstr("Existing file"));
+}
+
 TEST(THelp, ValidatorsNonPathText) {
     CLI::App app;
 
diff --git a/tests/HelpersTest.cpp b/tests/HelpersTest.cpp
index 80a663222..778046c9f 100644
--- a/tests/HelpersTest.cpp
+++ b/tests/HelpersTest.cpp
@@ -836,6 +836,9 @@ TEST(Types, TypeName) {
     tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double, unsigned int, std::string>>();
     EXPECT_EQ("[INT,TEXT,FLOAT,UINT,TEXT]", tuple_name);
 
+    tuple_name = CLI::detail::type_name<std::array<int, 10>>();
+    EXPECT_EQ("[INT,INT,INT,INT,INT,INT,INT,INT,INT,INT]", tuple_name);
+
     std::string text_name = CLI::detail::type_name<std::string>();
     EXPECT_EQ("TEXT", text_name);
 
@@ -1005,7 +1008,8 @@ TEST(Types, LexicalConversionVectorDouble) {
 
 static_assert(!CLI::detail::is_tuple_like<std::vector<double>>::value, "vector should not be like a tuple");
 static_assert(CLI::detail::is_tuple_like<std::pair<double, double>>::value, "pair of double should be like a tuple");
-static_assert(CLI::detail::is_tuple_like<std::array<double, 4>>::value, "std::array should be like a tuple");
+static_assert(CLI::detail::is_tuple_like<std::array<double, 4>>::value, "std::array<double,4> should be like a tuple");
+static_assert(CLI::detail::is_tuple_like<std::array<int, 10>>::value, "std::array<int,10> should be like a tuple");
 static_assert(!CLI::detail::is_tuple_like<std::string>::value, "std::string should not be like a tuple");
 static_assert(!CLI::detail::is_tuple_like<double>::value, "double should not be like a tuple");
 static_assert(CLI::detail::is_tuple_like<std::tuple<double, int, double>>::value, "tuple should look like a tuple");
@@ -1071,7 +1075,40 @@ TEST(Types, LexicalConversionTuple5) {
     EXPECT_FALSE(res);
 }
 
-TEST(Types, LexicalConversionXomplwz) {
+TEST(Types, LexicalConversionTuple10) {
+    CLI::results_t input = {"9", "19", "18", "5", "235235", "9", "19", "18", "5", "235235"};
+    std::array<unsigned int, 10> x;
+    bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
+    EXPECT_TRUE(res);
+    EXPECT_EQ(std::get<1>(x), 19u);
+    EXPECT_EQ(x[0], 9u);
+    EXPECT_EQ(x[2], 18u);
+    EXPECT_EQ(x[3], 5u);
+    EXPECT_EQ(x[4], 235235u);
+    EXPECT_EQ(x[9], 235235u);
+    input[3] = "hippo";
+    res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
+    EXPECT_FALSE(res);
+}
+
+TEST(Types, LexicalConversionTuple10XC) {
+    CLI::results_t input = {"9", "19", "18", "5", "235235", "9", "19", "18", "5", "235235"};
+    std::array<double, 10> x;
+    bool res = CLI::detail::lexical_conversion<decltype(x), std::array<unsigned int, 10>>(input, x);
+
+    EXPECT_TRUE(res);
+    EXPECT_EQ(std::get<1>(x), 19.0);
+    EXPECT_EQ(x[0], 9.0);
+    EXPECT_EQ(x[2], 18.0);
+    EXPECT_EQ(x[3], 5.0);
+    EXPECT_EQ(x[4], 235235.0);
+    EXPECT_EQ(x[9], 235235.0);
+    input[3] = "19.7";
+    res = CLI::detail::lexical_conversion<decltype(x), std::array<unsigned int, 10>>(input, x);
+    EXPECT_FALSE(res);
+}
+
+TEST(Types, LexicalConversionComplex) {
     CLI::results_t input = {"5.1", "3.5"};
     std::complex<double> x;
     bool res = CLI::detail::lexical_conversion<std::complex<double>, std::array<double, 2>>(input, x);