diff --git a/include/argparse.hpp b/include/argparse.hpp
index 6f66acf..e13f88c 100644
--- a/include/argparse.hpp
+++ b/include/argparse.hpp
@@ -17,6 +17,7 @@
 //     11. all api test
 //     12. top100 linux command test
 //     13. subcommand support
+//     14. throw execption
 
 #include <algorithm>
 #include <cassert>
@@ -33,6 +34,29 @@
 #include <vector>
 
 namespace argparse {
+
+class bad_value_access : public std::exception {
+ public:
+  explicit bad_value_access(std::string msg):msg(std::move(msg)) { }
+  const char* what() const noexcept override {
+    return msg.c_str();
+  }
+
+ private:
+  std::string msg;
+};
+
+class invalid_argument : public std::invalid_argument {
+ public:
+ invalid_argument(const char* msg): std::invalid_argument(msg){}
+ invalid_argument(std::string const& msg): std::invalid_argument(msg){}
+};
+
+template <typename = std::string, char delim = ','>
+class list_split_by;
+template <typename = std::string, typename = std::string, char delim = '='>
+class pair_split_by;
+
 namespace {
 
 template <typename T>
@@ -42,10 +66,96 @@ template <typename T>
 struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
 
 template <typename T>
-using is_reference_wrapper_t = typename is_reference_wrapper<T>::type;
+inline constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;
 
 template <typename T>
-inline constexpr bool is_reference_wrapper_v = is_reference_wrapper<T>::value;
+struct is_vector: std::false_type{};
+template <typename T>
+struct is_vector<std::vector<T>>: std::true_type{};
+template <typename T>
+inline constexpr bool is_vector_v = is_vector<T>::value;
+
+template <typename T>
+struct is_pair: std::false_type{};
+template <typename T,typename U>
+struct is_pair<std::pair<T, U>>: std::true_type {};
+template <typename T>
+inline constexpr bool is_pair_v = is_pair<T>::value;
+
+template <typename T>
+struct is_map: std::false_type{};
+template <typename T,typename U>
+struct is_map<std::map<T, U>>: std::true_type {};
+template <typename T>
+inline constexpr bool is_map_v = is_map<T>::value;
+
+template <typename T>
+struct is_need_split: std::false_type{};
+template <typename T, typename U>
+struct is_need_split<std::pair<T, U>>: std::true_type{};
+template <typename T, typename U>
+struct is_need_split<std::vector<std::pair<T, U>>>: std::true_type{};
+template <typename T, typename U>
+struct is_need_split<std::map<T, U>>: std::true_type{};
+template <typename T>
+struct is_need_split<std::vector<std::vector<T>>>: std::true_type{};
+template <typename T>
+inline constexpr bool is_need_split_v = is_need_split<T>::value;
+
+template <typename T>
+struct default_delimiter: std::integral_constant<char, '='>{};
+template <typename T>
+struct default_delimiter<std::vector<std::vector<T>>>: std::integral_constant<char, ','>{};
+template <typename T>
+inline constexpr char default_delimiter_v = default_delimiter<T>::value;
+
+template <typename T>
+struct is_list_split_by: std::false_type{};
+template <typename T, char delim>
+struct is_list_split_by<list_split_by<T, delim>>: std::true_type{};
+template <typename T>
+inline constexpr bool is_list_split_by_v = is_list_split_by<T>::value;
+
+template <typename T>
+struct is_pair_split_by: std::false_type{};
+template <typename T, typename U, char delim>
+struct is_pair_split_by<pair_split_by<T, U, delim>>: std::true_type{};
+template <typename T>
+inline constexpr bool is_pair_split_by_v = is_pair_split_by<T>::value;
+
+template <typename T, typename = void>
+struct is_transformable_type: std::false_type{};
+
+template <typename T>
+struct is_transformable_type<T, std::enable_if_t<
+    std::is_same_v<bool, T> ||
+    std::is_same_v<int, T> ||
+    std::is_same_v<double, T> ||
+    std::is_same_v<std::string, T>
+>>: std::true_type{};
+
+template <typename T, char delim>
+struct is_transformable_type<list_split_by<T, delim>, std::enable_if_t<
+    std::is_same_v<bool, T> ||
+    std::is_same_v<int, T> ||
+    std::is_same_v<double, T> ||
+    std::is_same_v<std::string, T>
+>>: std::true_type{};
+
+template <typename T,typename U, char delim>
+struct is_transformable_type<pair_split_by<T, U, delim>, std::enable_if_t<
+    (std::is_same_v<bool, T> || std::is_same_v<int, T> || std::is_same_v<double, T> || std::is_same_v<std::string, T>) &&
+    ( std::is_same_v<bool, U> || std::is_same_v<int, U> || std::is_same_v<double, U> || std::is_same_v<std::string, U>)
+>>: std::true_type{};
+
+template <typename T,typename U>
+struct is_transformable_type<std::pair<T, U>, std::enable_if_t<
+    (std::is_same_v<bool, T> || std::is_same_v<int, T> || std::is_same_v<double, T> || std::is_same_v<std::string, T>) &&
+    ( std::is_same_v<bool, U> || std::is_same_v<int, U> || std::is_same_v<double, U> || std::is_same_v<std::string, U>)
+>>: std::true_type{};
+
+template <typename T>
+inline constexpr bool is_transformable_type_v = is_transformable_type<T>::value;
 
 template <typename T, typename = void>
 struct is_flag_bindable_value : std::false_type {};
@@ -56,8 +166,6 @@ struct is_flag_bindable_value<
     std::enable_if_t<std::is_same_v<bool, T> || std::is_same_v<int, T>>>
     : std::true_type {};
 
-template <typename T>
-using is_flag_bindable_value_t = typename is_flag_bindable_value<T>::type;
 template <typename T>
 inline constexpr bool is_flag_bindable_value_v =
     is_flag_bindable_value<T>::value;
@@ -68,76 +176,40 @@ struct is_option_bindable_value : std::false_type {};
 template <typename T>
 struct is_option_bindable_value<
     T,
-    std::enable_if_t<std::is_same_v<bool, T> || std::is_same_v<int, T> ||
-                     std::is_same_v<double, T> ||
-                     std::is_same_v<std::string, T> ||
-                     std::is_same_v<std::vector<std::string>, T> ||
-                     std::is_same_v<std::map<std::string, std::string>, T>>>
+    std::enable_if_t<is_transformable_type_v<T>>>
     : std::true_type {};
 
 template <typename T>
-using is_option_bindable_value_t = typename is_option_bindable_value<T>::type;
-template <typename T>
-inline constexpr bool is_option_bindable_value_v =
-    is_option_bindable_value<T>::value;
-
-template <typename T, typename = void>
-struct is_bindable_value : std::false_type {};
+struct is_option_bindable_value<
+    std::vector<T>,
+    std::enable_if_t<is_transformable_type_v<T>>>
+    : std::true_type {};
 
-template <typename T>
-struct is_bindable_value<
-    T,
-    std::enable_if_t<std::is_same_v<bool, T> || std::is_same_v<int, T> ||
-                     std::is_same_v<double, T> ||
-                     std::is_same_v<std::string, T> ||
-                     std::is_same_v<std::vector<std::string>, T> ||
-                     std::is_same_v<std::map<std::string, std::string>, T>>>
+template <typename T, typename U>
+struct is_option_bindable_value<
+    std::map<T, U>,
+    std::enable_if_t<is_transformable_type_v<T> && is_transformable_type_v<U>>>
     : std::true_type {};
 
 template <typename T>
-using is_bindable_value_t = typename is_bindable_value<T>::type;
-template <typename T>
-inline constexpr bool is_bindable_value_v = is_bindable_value<T>::value;
+inline constexpr bool is_option_bindable_value_v =
+    is_option_bindable_value<T>::value;
 
 template <typename T, typename = void>
 struct is_position_bindable_value : std::false_type {};
 
 template <typename T>
-struct is_position_bindable_value<
-    T,
-    std::enable_if_t<std::is_same_v<std::string, T> ||
-                     std::is_same_v<std::vector<std::string>, T> ||
-                     std::is_same_v<std::map<std::string, std::string>, T>>>
-    : std::true_type {};
+struct is_position_bindable_value<T, std::enable_if_t<is_transformable_type_v<T>>> : std::true_type {};
 
 template <typename T>
-using is_position_bindable_value_t =
-    typename is_position_bindable_value<T>::type;
+struct is_position_bindable_value<std::vector<T>, std::enable_if_t<is_transformable_type_v<T>>> : std::true_type {};
+
 template <typename T>
 inline constexpr bool is_position_bindable_value_v =
     is_position_bindable_value<T>::value;
 
-// element_size_is_2
 template <typename T>
-struct element_size_is_2 : public std::false_type {};
-
-template <typename T, typename U>
-struct element_size_is_2<std::pair<T, U>> : public std::true_type {};
-
-template <typename T, typename U>
-struct element_size_is_2<std::tuple<T, U>> : public std::true_type {};
-
-template <typename T>
-struct element_size_is_2<std::array<T, 2>> : public std::true_type {};
-
-template <typename T>
-inline constexpr bool element_size_is_2_v = element_size_is_2<T>::value;
-
-template <typename T>
-inline constexpr bool is_bindable_noncontainer_value_v =
-    std::is_same_v<bool, T> || std::is_same_v<int, T> ||
-    std::is_same_v<double, T> || std::is_same_v<std::string, T> ||
-    element_size_is_2_v<T>;
+inline constexpr bool is_bindable_value_v = is_flag_bindable_value_v<T> || is_option_bindable_value_v<T> || is_position_bindable_value_v<T>;
 
 // overloaded
 template <typename... T>
@@ -155,18 +227,36 @@ struct is_option_bindable_container : std::false_type {};
 template <typename T>
 struct is_option_bindable_container<
     std::vector<T>,
-    std::enable_if_t<is_bindable_noncontainer_value_v<T>>> : std::true_type {};
+    std::enable_if_t<is_transformable_type_v<T>>> : std::true_type {};
 
 template <typename T, typename U>
 struct is_option_bindable_container<
     std::map<T, U>,
-    std::enable_if_t<is_bindable_noncontainer_value_v<T> &&
-                     is_bindable_noncontainer_value_v<U>>> : std::true_type {};
+    std::enable_if_t<is_transformable_type_v<T>>> : std::true_type {};
 
 template <typename T>
 constexpr bool is_option_bindable_container_v =
     is_option_bindable_container<T>::value;
 
+
+template <typename T1, typename T2>
+struct merge_variant;
+template <typename T1, typename... T2>
+struct merge_variant<std::variant<T1>, std::variant<T2...>>{ using type = std::variant<T1, T2...>; };
+template <typename T0, typename... T1, typename... T2>
+struct merge_variant<std::variant<T0, T1...>, std::variant<T2...>>{ using type = typename merge_variant<std::variant<T1...>, std::variant<T0, T2...>>::type; };
+template <typename... T>
+struct make_variant_type {
+  using type1 = typename merge_variant<std::variant<T...>, std::variant<std::reference_wrapper<T>...>>::type;
+  using type2 = typename merge_variant<std::variant<std::vector<T>...>, std::variant<std::reference_wrapper<std::vector<T>>...>>::type;
+  using type3 = typename merge_variant<std::variant<std::pair<std::string, T>...>, std::variant<std::reference_wrapper<std::pair<std::string, T>>...>>::type;
+  using type4 = typename merge_variant<std::variant<std::vector<std::pair<std::string, T>>...>, std::variant<std::reference_wrapper<std::vector<std::pair<std::string, T>>>...>>::type;
+  using type5 = typename merge_variant<std::variant<std::map<std::string, T>...>, std::variant<std::reference_wrapper<std::map<std::string, T>>...>>::type;
+
+  using type = typename merge_variant<typename merge_variant<typename merge_variant<typename merge_variant<type1, type2>::type, type3>::type, type4>::type, type5>::type;
+};
+
+
 //**********************************
 namespace StringUtil {
 inline bool startswith(std::string const& str, std::string const& prefix) {
@@ -215,112 +305,135 @@ inline bool is_position_arg(std::string const& str) {
 }  // namespace StringUtil
 
 // bool
-template <typename T, std::enable_if_t<std::is_same_v<bool, T>, int> = 0>
-std::tuple<int, std::string, T> transform_value(std::string const& from) {
+template <typename T, std::enable_if_t<std::is_same_v<bool, T>, bool> = true>
+void transform_value(std::string const& from, T& to) {
   std::string lower_from;
   std::transform(from.begin(), from.end(), std::back_inserter(lower_from),
                  [](unsigned char c) { return std::tolower(c); });
   if (lower_from == "true") {
-    return {0, "", true};
+    to = true;
   } else if (lower_from == "false") {
-    return {0, "", false};
+    to = false;
   } else {
     std::stringstream ss;
-    ss << "'" << from << "' must be one of 'true' or 'false'";
-    return {1, ss.str(), false};
+    ss << "'" << from << "' is neither 'true' nor 'false'";
+    throw bad_value_access(ss.str());
   }
 }
 
-// int
 template <typename T,
           std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<bool, T>,
-                           int> = 0>
-std::tuple<int, std::string, T> transform_value(std::string const& from) {
-  T to{};
+                           bool> = true>
+void transform_value(std::string const& from, T& to) {
   auto [ptr, ec] = std::from_chars(from.data(), from.data() + from.size(), to);
   if (ec == std::errc::invalid_argument) {
     std::stringstream ss;
     ss << "'" << from << "' not invalid number";
-    return {1, ss.str(), to};
+    throw bad_value_access(ss.str());
   } else if (ec != std::errc{}) {
     std::stringstream ss;
     ss << "'" << from << "'  can't convert to a number";
-    return {1, ss.str(), to};
+    throw bad_value_access(ss.str());
   }
-  return {0, "", to};
 }
 
-// double
-template <typename T, std::enable_if_t<std::is_same_v<double, T>, int> = 0>
-std::tuple<int, std::string, T> transform_value(std::string const& from) {
-  std::size_t pos{};
-  T to{std::stod(from, &pos)};
-  if (pos == std::string::npos) {
-    return {0, "", to};
-  }
-  {
-    std::stringstream ss;
-    ss << "'" << from << "' not invalid double value";
-    return {1, ss.str(), to};
+template <typename T, std::enable_if_t<std::is_same_v<double, T>, bool> = true>
+void transform_value(std::string const& from, T& to) {
+  try {
+    to = std::stod(from, nullptr);
+  } catch (std::invalid_argument const &e) {
+    throw invalid_argument(e.what());
   }
 }
 
 // std::string
-template <typename T, std::enable_if_t<std::is_same_v<std::string, T>, int> = 0>
-std::tuple<int, std::string, T> transform_value(std::string const& from) {
-  return {0, "", from};
+template <typename T, std::enable_if_t<std::is_same_v<std::string, T>, bool> = true>
+void transform_value(std::string const& from, T& to) {
+  to = from;
 }
 
-// std::pair<K, V>, std::array<T, 2>, std::tuple<K,V>
-template <typename T, std::enable_if_t<element_size_is_2_v<T>, int> = 0>
-std::tuple<int, std::string, T> transform_value(std::string const& from) {
-  auto it = from.find('=');
-  if (it != std::string::npos) {
-    auto key_str = from.substr(0, it);
-    auto value_str = from.substr(it + 1);
-    auto [err_k, msg_k, val_k] = transform_value<
-        typename std::decay<decltype(std::get<0>(std::declval<T&>()))>::type>(
-        key_str);
-    auto [err_v, msg_v, val_v] = transform_value<
-        typename std::decay<decltype(std::get<1>(std::declval<T&>()))>::type>(
-        value_str);
-    return {0, "", {val_k, val_v}};
-  } else {
-    std::stringstream ss;
-    ss << "'" << from << "' is not a '=' separated string";
-    return {1, ss.str(), {}};
+template<typename T, std::enable_if_t<is_list_split_by_v<T>, bool> = true>
+void transform_value(std::string const& from , T& to) {
+  to.split(from);
+}
+
+template<typename T, std::enable_if_t<is_pair_split_by_v<T>, bool> = true>
+void transform_value(std::string const& from , T& to) {
+  to.split(from);
+}
+
+template<typename T, std::enable_if_t<is_pair_v<T>, bool> = true>
+void transform_value(std::string const& from , T& to, char delimiter = '=') {
+  auto index = from.find(delimiter);
+  if (index != std::string::npos) {
+    transform_value(from.substr(0, index), to.first);
+    transform_value(from.substr(index+1), to.second);
   }
 }
 
 // container
 template <typename T,
           std::enable_if_t<is_option_bindable_container_v<T>, bool> = true>
-std::pair<int, std::string> insert_or_replace_value(
+void insert_or_replace_value(
     T& bind_value,
-    std::string const& option_val) {
+    std::string const& option_val, char delimiter = '=') {
+  if (option_val.empty()) {
+    return;
+  }
   std::insert_iterator<T> it(bind_value, bind_value.end());  // insert to end
-  auto [ec, error_msg, result] =
-      transform_value<typename T::value_type>(option_val);
-  if (ec == 0) {
+  if constexpr (is_pair_v<typename T::value_type>) {
+    using writable_pair = typename std::pair<typename std::remove_const_t<typename T::value_type::first_type>, typename T::value_type::second_type>;
+    writable_pair result;
+    transform_value<writable_pair>(option_val, result, delimiter);
+    *it = std::move(result);
+  } else {
+    typename T::value_type result;
+    transform_value<typename T::value_type>(option_val, result);
     *it = std::move(result);
   }
-  return {ec, error_msg};
 }
 
 // non-container
 template <typename T,
           std::enable_if_t<!is_option_bindable_container_v<T>, bool> = false>
-std::pair<int, std::string> insert_or_replace_value(
+void insert_or_replace_value(
     T& bind_value,
-    std::string const& option_val) {
-  auto [ec, error_msg, result] = transform_value<T>(option_val);
-  if (ec == 0) {
-    bind_value = std::move(result);
+    std::string const& option_val, char delimiter = '=') {
+  if (option_val.empty()) {
+    return;
   }
-  return {ec, error_msg};
+  T result;
+  if constexpr (is_pair_v<T>) {
+    transform_value<T>(option_val, result, delimiter);
+  } else {
+    transform_value<T>(option_val, result);
+  }
+  bind_value = std::move(result);
 }
 }  // namespace
 
+template<typename T/* = std::string*/, char delim/* = ','*/>
+class list_split_by : public std::vector<T> {
+ public:
+   void split(std::string const& from) {
+     auto ret = argparse::StringUtil::split(from, delim);
+     std::transform(begin(ret), end(ret), std::back_inserter(*this), [](std::string const& v) -> T { T ret{}; transform_value(v, ret); return ret;});
+   }
+};
+
+template<typename T/* = std::string*/, typename U/* = std::string*/, char delim>
+class pair_split_by : public std::pair<T, U> {
+ public:
+   void split(std::string const& from) {
+     auto index = from.find(delim);
+     if (index != std::string::npos) {
+       transform_value(from.substr(0, index), this->first);
+       transform_value(from.substr(index+1), this->second);
+     }
+   }
+};
+
+
 class Base {
   template <typename T>
   class DefaultValueVisitor {
@@ -334,14 +447,14 @@ class Base {
                                            decltype(default_value)>) {
           val.get() = default_value;
         } else {
-          assert(false);
+          throw std::bad_variant_access();
         }
       } else {
         if constexpr (std::is_assignable_v<decltype(val),
                                            decltype(default_value)>) {
           val = default_value;
         } else {
-          assert(false);
+          throw std::bad_variant_access();
         }
       }
     }
@@ -352,10 +465,13 @@ class Base {
   friend class ArgParser;
 
  public:
+  enum class Type { FLAG, ALIAS_FLAG, OPTION, POSITIONAL };
   virtual ~Base() = default;
-  [[nodiscard]] virtual bool is_flag() const = 0;
-  [[nodiscard]] virtual bool is_option() const = 0;
-  [[nodiscard]] virtual bool is_positional() const = 0;
+  Base::Type virtual type() const = 0;
+  bool is_flag() { return Type::FLAG == this->type() || is_alias_flag(); };
+  bool is_alias_flag() { return Type::ALIAS_FLAG == this->type(); };
+  bool is_option() { return Type::OPTION == this->type(); };
+  bool is_positional() { return Type::POSITIONAL == this->type(); };
 
   template <typename T, typename = std::enable_if_t<is_bindable_value_v<T>>>
   T const& as() const {
@@ -371,20 +487,20 @@ class Base {
       if constexpr (is_flag_bindable_value_v<T>) {
         value = std::ref(bind_val);
       } else {
-        assert(false);
+        throw std::bad_variant_access();
       }
     } else if (is_option()) {
       if constexpr (is_option_bindable_value_v<T>) {
         value = std::ref(bind_val);
       } else {
-        assert(false);
+        throw std::bad_variant_access();
       }
       assert(is_option_bindable_value_v<T>);
     } else if (is_positional()) {
       if constexpr (is_position_bindable_value_v<T>) {
         value = std::ref(bind_val);
       } else {
-        assert(false);
+        throw std::bad_variant_access();
       }
     }
     return *this;
@@ -424,10 +540,8 @@ class Base {
 
   virtual void hit(char short_name) = 0;
   virtual void hit(std::string const& long_name) = 0;
-  virtual std::pair<int, std::string> hit(char short_name,
-                                          std::string const& val) = 0;
-  virtual std::pair<int, std::string> hit(std::string const& long_name,
-                                          std::string const& val) = 0;
+  virtual void hit(char short_name, std::string const& val) = 0;
+  virtual void hit(std::string const& long_name, std::string const& val) = 0;
   [[nodiscard]] virtual std::string usage() const = 0;
 
   [[nodiscard]] virtual bool contains(std::string const& name) const {
@@ -436,17 +550,17 @@ class Base {
   }
   std::vector<std::string> flag_and_option_names;
   std::string help_msg;
-  std::variant<std::reference_wrapper<bool>,
-               std::reference_wrapper<int>,
-               bool,
-               int,
-               std::reference_wrapper<std::string>,
-               std::reference_wrapper<std::vector<std::string>>,
-               std::reference_wrapper<std::map<std::string, std::string>>,
-               std::string,
-               std::vector<std::string>,
-               std::map<std::string, std::string>>
-      value;
+  using type2 = std::variant<
+               std::reference_wrapper<list_split_by<>>,
+               list_split_by<>,
+               std::reference_wrapper<pair_split_by<>>,
+               pair_split_by<>,
+               std::reference_wrapper<std::vector<pair_split_by<>>>,
+               std::vector<pair_split_by<>>
+                   >;
+  using mytype = merge_variant<make_variant_type<bool, int, double, std::string>::type, type2>::type;
+
+      mytype value;
   int hit_count{0};
 };
 class ArgParser;
@@ -454,8 +568,8 @@ class Flag : public Base {
   friend class ArgParser;
 
   template <typename ShortOrLong>
-  struct ValueVisitor {
-    ValueVisitor(Flag const& obj, ShortOrLong const& flag)
+  struct FlagValueVisitor {
+    FlagValueVisitor(Flag const& obj, ShortOrLong const& flag)
         : flagObj{obj}, flag{flag} {}
     void operator()(bool& x) {
       if (flagObj.negate_contains(flag)) {
@@ -511,9 +625,7 @@ class Flag : public Base {
   };
 
  public:
-  [[nodiscard]] bool is_flag() const override { return true; };
-  [[nodiscard]] bool is_option() const override { return false; };
-  [[nodiscard]] bool is_positional() const override { return false; };
+  Base::Type type() const override { return Base::Type::FLAG; };
 
  protected:
   template <typename T,
@@ -552,14 +664,11 @@ class Flag : public Base {
 
   void hit(char const flag) override { hit(std::string(1, flag)); }
   void hit(std::string const& flag) override { hit_impl(flag); }
-  std::pair<int, std::string> hit(char const flag,
-                                  std::string const& val) override {
-    return hit(std::string(1, flag), val);
+  void hit(char const flag, std::string const& val) override {
+    hit(std::string(1, flag), val);
   }
-  std::pair<int, std::string> hit(std::string const& flag,
-                                  std::string const& val) override {
+  void hit(std::string const& flag, std::string const& val) override {
     assert(false);
-    return {1, "flag not hold a value"};
   }
 
   [[nodiscard]] std::string usage() const override {
@@ -621,36 +730,38 @@ class Flag : public Base {
   template <typename ShortOrLong>
   void hit_impl(ShortOrLong const& flag) {
     hit_count++;
-    std::visit(ValueVisitor(*this, flag), value);
+    std::visit(FlagValueVisitor(*this, flag), value);
   }
 
  private:
   std::vector<std::string> negate_flag_names{};
 };
 
-class Option : public Base {
-  friend class ArgParser;
-
-  struct ValueVisitor {
-    explicit ValueVisitor(std::string const& opt_val) : opt_val(opt_val) {}
-    template <typename T,
-              std::enable_if_t<is_option_bindable_value_v<T>, bool> = true>
-    std::pair<int, std::string> operator()(T& x) {
-      return insert_or_replace_value(x, opt_val);
-    }
-    template <typename T,
-              std::enable_if_t<is_option_bindable_value_v<T>, bool> = true>
-    std::pair<int, std::string> operator()(std::reference_wrapper<T>& x) {
-      return insert_or_replace_value(x.get(), opt_val);
-    }
+class AliasFlag: public Flag {
+  friend  class ArgParser;
+ public:
+  Base::Type type() const override { return Base::Type::ALIAS_FLAG; };
+ protected:
+  std::unique_ptr<AliasFlag> static make_flag(std::string const& flag_desc, std::string const& option_name, std::string const& option_value) {
+    return std::unique_ptr<AliasFlag>(new AliasFlag(flag_desc, option_name, option_value));
+  }
+  explicit AliasFlag(std::string const& flag_desc, std::string const& option_name, std::string const& option_value):Flag(flag_desc, Base::identity<bool>{}),option_name(option_name), option_value(option_value){}
+  void hit(char const flag) override {
+    Flag::hit(flag);
+  }
+  void hit(std::string const& flag) override {
+    Flag::hit(flag);
+  }
 
-    std::string const& opt_val;
-  };
+ private:
+  std::string option_name;
+  std::string option_value;
+};
 
+class Option : public Base {
+  friend class ArgParser;
  public:
-  [[nodiscard]] bool is_flag() const override { return false; };
-  [[nodiscard]] bool is_option() const override { return true; };
-  [[nodiscard]] bool is_positional() const override { return false; };
+  Base::Type type() const override { return Base::Type::OPTION; };
 
  protected:
   template <typename T,
@@ -714,11 +825,10 @@ class Option : public Base {
     return ss.str();
   }
 
-  std::pair<int, std::string> hit(std::string const&,
-                                  std::string const& val) override {
+  void hit(std::string const&, std::string const& val) override {
     return hit_impl(val);
   }
-  std::pair<int, std::string> hit(char, std::string const& val) override {
+  void hit(char, std::string const& val) override {
     return hit_impl(val);
   }
   void hit(std::string const& flag) override { assert(false); }
@@ -739,22 +849,30 @@ class Option : public Base {
     }
   }
 
-  std::pair<int, std::string> hit_impl(std::string const& opt_val) {
+  void hit_impl(std::string const& opt_val) {
     hit_count++;
-    return std::visit(ValueVisitor(opt_val), value);
+    std::visit(
+        [&opt_val, this](auto &x) {
+          using T = std::remove_reference_t<decltype(x)>;
+          if constexpr (is_reference_wrapper_v<T>) {
+            insert_or_replace_value(x.get(), opt_val, delimiter);
+          } else {
+            insert_or_replace_value(x, opt_val, delimiter);
+          }
+        }
+        , value);
   }
 
  private:
   std::string val_help_msg;
+  char delimiter{'\0'};
 };
 
 class Positional : public Base {
   friend class ArgParser;
 
  public:
-  [[nodiscard]] bool is_flag() const override { return false; };
-  [[nodiscard]] bool is_option() const override { return false; };
-  [[nodiscard]] bool is_positional() const override { return true; };
+  Base::Type type() const override { return Base::Type::POSITIONAL; };
 
  protected:
   template <typename T>
@@ -770,46 +888,28 @@ class Positional : public Base {
 
   void hit(char short_name) override { assert(false); };
   void hit(std::string const& long_name) override { assert(false); };
-  std::pair<int, std::string> hit(char short_name,
+  void hit(char short_name,
                                   std::string const& val) override {
     assert(false);
-    return {1, "flag not a value"};
   };
-  std::pair<int, std::string> hit(std::string const& long_name,
+  void hit(std::string const& long_name,
                                   std::string const& val) override {
     std::visit(
         overloaded{[&val, this](auto& v) {
           using type = std::remove_reference_t<decltype(v)>;
-          if constexpr (std::is_same_v<std::string, type>) {
-            v = val;
-            can_set_value = false;
-          } else if constexpr (std::is_same_v<std::vector<std::string>, type>) {
-            v.push_back(val);
-            can_set_value = true;
-          } else if constexpr (std::is_same_v<
-                                   std::map<std::string, std::string>, type>) {
-            // TODO:
-            assert(false);
-          } else if constexpr (std::is_same_v<
-                                   std::reference_wrapper<std::string>, type>) {
-            v.get() = val;
-            can_set_value = false;
-          } else if constexpr (std::is_same_v<std::reference_wrapper<
-                                                  std::vector<std::string>>,
-                                              type>) {
-            v.get().push_back(val);
-            can_set_value = true;
-          } else if constexpr (std::is_same_v<std::reference_wrapper<std::map<
-                                                  std::string, std::string>>,
-                                              type>) {
-            // TODO:
-            assert(false);
+          if constexpr (is_reference_wrapper_v<type>) {
+            insert_or_replace_value(v.get(), val, delimiter);
+            if constexpr (!is_option_bindable_container_v<typename type::type>) {
+              can_set_value = false;
+            }
           } else {
-            assert(false);
+            insert_or_replace_value(v, val, delimiter);
+            if constexpr (!is_option_bindable_container_v<type>) {
+              can_set_value = false;
+            }
           }
         }},
         value);
-    return {0, ""};
   };
 
   [[nodiscard]] std::string usage() const override { return ""; };
@@ -827,6 +927,7 @@ class Positional : public Base {
     flag_and_option_names.push_back(name);
   }
   bool can_set_value{true};
+  char delimiter{'\0'};
 };
 
 class ArgParser {
@@ -847,13 +948,13 @@ class ArgParser {
     PositionValueVisitor(std::string const& opt_val) : opt_val(opt_val) {}
     template <typename T,
               std::enable_if_t<is_option_bindable_value_v<T>, bool> = true>
-    std::pair<int, std::string> operator()(T& x) {
-      return insert_or_replace_value(x, opt_val);
+    void operator()(T& x) {
+      insert_or_replace_value(x, opt_val);
     }
     template <typename T,
               std::enable_if_t<is_option_bindable_value_v<T>, bool> = true>
-    std::pair<int, std::string> operator()(std::reference_wrapper<T>& x) {
-      return insert_or_replace_value(x.get(), opt_val);
+    void operator()(std::reference_wrapper<T>& x) {
+      insert_or_replace_value(x.get(), opt_val);
     }
 
     std::string const& opt_val;
@@ -886,9 +987,15 @@ class ArgParser {
     all_options.push_back(std::move(x));
     return *p;
   }
+  AliasFlag& add_alias_flag(std::string const& flag_desc, std::string const& option_name, std::string const& option_value) {
+    auto x = AliasFlag::make_flag(flag_desc, option_name, option_value);
+    auto p = x.get();
+    all_options.push_back(std::move(x));
+    return *p;
+  }
 
   template <typename T,
-            typename = std::enable_if_t<is_option_bindable_value_v<T>>>
+            typename = std::enable_if_t<!is_need_split_v<T> && is_option_bindable_value_v<T>>>
   Option& add_option(std::string const& option_desc, T& bind) {
     auto x = Option::make_option(option_desc, bind);
     auto p = x.get();
@@ -897,7 +1004,7 @@ class ArgParser {
   }
 
   template <typename T = std::string,
-            typename = std::enable_if_t<is_option_bindable_value_v<T>>>
+            typename = std::enable_if_t<!is_need_split_v<T> && is_option_bindable_value_v<T>>>
   Option& add_option(std::string const& option_desc) {
     auto x = Option::make_option<T>(option_desc);
     auto p = x.get();
@@ -906,7 +1013,27 @@ class ArgParser {
   }
 
   template <typename T,
-            typename = std::enable_if_t<is_position_bindable_value_v<T>>>
+            typename = std::enable_if_t<is_need_split_v<T> && is_option_bindable_value_v<T>>>
+  Option& add_option(std::string const& option_desc, T& bind, char delimiter = default_delimiter_v<T>) {
+    auto x = Option::make_option(option_desc, bind);
+    auto p = x.get();
+    all_options.push_back(std::move(x));
+    p->delimiter = delimiter;
+    return *p;
+  }
+
+  template <typename T = std::string,
+            typename = std::enable_if_t<is_need_split_v<T> && is_option_bindable_value_v<T>>>
+  Option& add_option(std::string const& option_desc, char delimiter = default_delimiter_v<T>) {
+    auto x = Option::make_option<T>(option_desc);
+    auto p = x.get();
+    all_options.push_back(std::move(x));
+    p->delimiter = delimiter;
+    return *p;
+  }
+
+  template <typename T,
+            typename = std::enable_if_t<!is_need_split_v<T> && is_position_bindable_value_v<T>>>
   Positional& add_positional(std::string const& name, T& bind) {
     auto x = Positional::make_positional(name, bind);
     auto p = x.get();
@@ -914,7 +1041,7 @@ class ArgParser {
     return *p;
   }
   template <typename T = std::vector<std::string>,
-            typename = std::enable_if_t<is_position_bindable_value_v<T>>>
+            typename = std::enable_if_t<!is_need_split_v<T> && is_position_bindable_value_v<T>>>
   Positional& add_positional(std::string const& name) {
     auto x = Positional::make_positional<T>(name);
     auto p = x.get();
@@ -922,6 +1049,25 @@ class ArgParser {
     return *p;
   }
 
+  template <typename T,
+            typename = std::enable_if_t<is_need_split_v<T> && is_position_bindable_value_v<T>>>
+  Positional& add_positional(std::string const& name, T& bind, char delimiter = default_delimiter_v<T>) {
+    auto x = Positional::make_positional(name, bind);
+    auto p = x.get();
+    all_options.push_back(std::move(x));
+    p->delimiter = delimiter;
+    return *p;
+  }
+  template <typename T = std::vector<std::string>,
+            typename = std::enable_if_t<is_need_split_v<T> && is_position_bindable_value_v<T>>>
+  Positional& add_positional(std::string const& name, char delimiter = default_delimiter_v<T>) {
+    auto x = Positional::make_positional<T>(name);
+    auto p = x.get();
+    all_options.push_back(std::move(x));
+    p->delimiter = delimiter;
+    return *p;
+  }
+
   std::string usage() {
     std::stringstream ss;
     ss << (program_name.empty() ? "?" : program_name) << " [OPTION]... ";
@@ -1001,17 +1147,21 @@ class ArgParser {
         while (short_p != curr_arg.end()) {
           if (auto short_flag = get_flag(*short_p); short_flag.has_value()) {
             (*short_flag)->hit(*short_p);
+            if ((*short_flag)->is_alias_flag()) {
+              auto* alis_flag = dynamic_cast<AliasFlag*>(*short_flag);
+              if (auto option = get_option(alis_flag->option_name); option.has_value()) {
+                option.value()->hit(alis_flag->option_name, alis_flag->option_value);
+              } else {
+                assert(false);
+              }
+            }
             short_p++;
           } else if (auto short_option = get_option(*short_p);
                      short_option.has_value()) {
             if (short_p + 1 != curr_arg.end()) {
-              if (auto const [ret, err] =
                       (*short_option)
                           ->hit(*short_p,
                                 std::string(short_p + 1, curr_arg.end()));
-                  ret != 0) {
-                return {ret, err};
-              }
               short_p = curr_arg.end();
             } else {
               if (next == command_line_args.end()) {
@@ -1024,11 +1174,7 @@ class ArgParser {
                   ss << "option requires an argument -- -" << *short_p;
                   return {1, ss.str()};
                 } else {
-                  if (auto const [ret, err] =
                           (*short_option)->hit(*short_p, *next);
-                      ret != 0) {
-                    return {ret, err};
-                  }
                   short_p = curr_arg.end();
                   next = std::next(next);
                 }
@@ -1050,11 +1196,7 @@ class ArgParser {
         if (auto i = curr_arg.find('=', 2); i != std::string::npos) {
           std::string option = curr_arg.substr(2, i - 2);
           if (auto long_opt = get_option(option); long_opt.has_value()) {
-            if (auto const [ret, msg] =
                     (*long_opt)->hit(option, curr_arg.substr(i + 1));
-                ret != 0) {
-              return {ret, msg};
-            }
           } else {
             std::stringstream ss;
             ss << "invalid option -- --" << option;
@@ -1074,10 +1216,7 @@ class ArgParser {
               ss << "option requires an argument -- --" << option;
               return {1, ss.str()};
             } else {
-              if (auto const [ret, err] = (*long_opt)->hit(option, *next);
-                  ret != 0) {
-                return {ret, err};
-              }
+              (*long_opt)->hit(option, *next);
               next = std::next(next);
             }
           } else {
diff --git a/tests/argparse_test.cpp b/tests/argparse_test.cpp
index 77781eb..326adf0 100644
--- a/tests/argparse_test.cpp
+++ b/tests/argparse_test.cpp
@@ -222,7 +222,9 @@ TEST(ArgParser, parser0_3) {
   bool flag_2{false};
   bool flag_3{false};
   int flag_v{false};
+  // TODO:
   std::map<std::string, std::string> option_e;
+  // std::vector<argparse::pair_split_by<std::string, std::string, '='>> option_e;
   std::vector<std::string> option_f;
   std::string option_o;
 
@@ -301,12 +303,9 @@ TEST(ArgParser, parser0_3) {
   EXPECT_EQ(parser["v"].as<int>(), 4);
 
   EXPECT_EQ(3, option_e.size());
-  EXPECT_TRUE(option_e.find("e1") != option_e.end());
-  EXPECT_TRUE(option_e.find("e2") != option_e.end());
-  EXPECT_TRUE(option_e.find("xxx") != option_e.end());
+  EXPECT_EQ(option_e.at("xxx"), "yyy");
   EXPECT_EQ(option_e.at("e1"), "v1");
   EXPECT_EQ(option_e.at("e2"), "v2");
-  EXPECT_EQ(option_e.at("xxx"), "yyy");
 
   EXPECT_EQ("8", option_o);
 
diff --git a/tests/grep_test.cpp b/tests/grep_test.cpp
index 728e527..1a143ab 100644
--- a/tests/grep_test.cpp
+++ b/tests/grep_test.cpp
@@ -1,6 +1,183 @@
 #include "argparse.hpp"
 #include <gtest/gtest.h>
 
+/* ****************************************************************************
+ * Usage: grep [OPTION]... PATTERNS [FILE]...
+ * Search for PATTERNS in each FILE.
+ * Example: grep -i 'hello world' menu.h main.c
+ * PATTERNS can contain multiple patterns separated by newlines.
+ *
+ * Pattern selection and interpretation:
+ *   -E, --extended-regexp     PATTERNS are extended regular expressions
+ *   -F, --fixed-strings       PATTERNS are strings
+ *   -G, --basic-regexp        PATTERNS are basic regular expressions
+ *   -P, --perl-regexp         PATTERNS are Perl regular expressions
+ *   -e, --regexp=PATTERNS     use PATTERNS for matching
+ *   -f, --file=FILE           take PATTERNS from FILE
+ *   -i, --ignore-case         ignore case distinctions in patterns and data
+ *       --no-ignore-case      do not ignore case distinctions (default)
+ *   -w, --word-regexp         match only whole words
+ *   -x, --line-regexp         match only whole lines
+ *   -z, --null-data           a data line ends in 0 byte, not newline
+ *
+ * Miscellaneous:
+ *   -s, --no-messages         suppress error messages
+ *   -v, --invert-match        select non-matching lines
+ *   -V, --version             display version information and exit
+ *       --help                display this help text and exit
+ *
+ * Output control:
+ *   -m, --max-count=NUM       stop after NUM selected lines
+ *   -b, --byte-offset         print the byte offset with output lines
+ *   -n, --line-number         print line number with output lines
+ *       --line-buffered       flush output on every line
+ *   -H, --with-filename       print file name with output lines
+ *   -h, --no-filename         suppress the file name prefix on output
+ *       --label=LABEL         use LABEL as the standard input file name prefix
+ *   -o, --only-matching       show only nonempty parts of lines that match
+ *   -q, --quiet, --silent     suppress all normal output
+ *       --binary-files=TYPE   assume that binary files are TYPE;
+ *                             TYPE is 'binary', 'text', or 'without-match'
+ *   -a, --text                equivalent to --binary-files=text
+ *   -I                        equivalent to --binary-files=without-match
+ *   -d, --directories=ACTION  how to handle directories;
+ *                             ACTION is 'read', 'recurse', or 'skip'
+ *   -D, --devices=ACTION      how to handle devices, FIFOs and sockets;
+ *                             ACTION is 'read' or 'skip'
+ *   -r, --recursive           like --directories=recurse
+ *   -R, --dereference-recursive  likewise, but follow all symlinks
+ *       --include=GLOB        search only files that match GLOB (a file pattern)
+ *       --exclude=GLOB        skip files that match GLOB
+ *       --exclude-from=FILE   skip files that match any file pattern from FILE
+ *       --exclude-dir=GLOB    skip directories that match GLOB
+ *   -L, --files-without-match  print only names of FILEs with no selected lines
+ *   -l, --files-with-matches  print only names of FILEs with selected lines
+ *   -c, --count               print only a count of selected lines per FILE
+ *   -T, --initial-tab         make tabs line up (if needed)
+ *   -Z, --null                print 0 byte after FILE name
+ *
+ * Context control:
+ *   -B, --before-context=NUM  print NUM lines of leading context
+ *   -A, --after-context=NUM   print NUM lines of trailing context
+ *   -C, --context=NUM         print NUM lines of output context
+ *   -NUM                      same as --context=NUM
+ *       --group-separator=SEP  print SEP on line between matches with context
+ *       --no-group-separator  do not print separator for matches with context
+ *       --color[=WHEN],
+ *       --colour[=WHEN]       use markers to highlight the matching strings;
+ *                             WHEN is 'always', 'never', or 'auto'
+ *   -U, --binary              do not strip CR characters at EOL (MSDOS/Windows)
+ *
+ * When FILE is '-', read standard input.  With no FILE, read '.' if
+ * recursive, '-' otherwise.  With fewer than two FILEs, assume -h.
+ * Exit status is 0 if any line is selected, 1 otherwise;
+ * if any error occurs and -q is not given, the exit status is 2.
+* ***************************************************************************/
+
+argparse::ArgParser make_grep_parser() {
+  argparse::ArgParser parser;
+  parser.add_flag("E,extended-regexp")
+    .help("PATTERNS are extended regular expressions");
+  parser.add_flag("F,fixed-strings")
+    .help("PATTERNS are strings");
+  parser.add_flag("G,basic-regexp")
+    .help("PATTERNS are basic regular expressions");
+  parser.add_flag("P,perl-regexp")
+    .help("PATTERNS are Perl regular expressions");
+  parser.add_option("e,regexp")
+    .help("use PATTERNS for matching");
+  parser.add_option("f,file")
+    .help("take PATTERNS from FILE");
+  parser.add_option("i,ignore-case,!no-ignore-case")
+    .help("ignore case distinctions in patterns and data");
+  parser.add_option("w,word-regexp")
+    .help("match only whole words");
+  parser.add_option("x,line-regexp")
+    .help("match only whole lines");
+  parser.add_option("z,null-data")
+    .help("a data line ends in 0 byte, not newline");
+  parser.add_flag("s,no-messages")
+    .help("suppress error messages");
+  parser.add_flag("v,invert-match")
+    .help("select non-matching lines");
+  parser.add_flag("V,version")
+    .help("display version information and exit");
+  parser.add_flag("help")
+    .help("display this help text and exit");
+
+  parser.add_option<int>("m,max-count")
+    .help("stop after NUM selected lines");
+  parser.add_flag("b,byte-offset")
+    .help("print the byte offset with output lines");
+  parser.add_flag("n,line-number")
+    .help("print line number with output lines");
+  parser.add_flag("line-buffered")
+    .help("flush output on every line");
+  parser.add_flag("H,with-filename")
+    .help("print file name with output lines");
+  parser.add_flag("h,no-filename")
+    .help("suppress the file name prefix on output");
+  parser.add_option("label")
+    .help("use LABEL as the standard input file name prefix");
+  parser.add_flag("o,only-matching")
+    .help("show only nonempty parts of lines that match");
+  parser.add_flag("q,quiet,")
+    .help("--silent     suppress all normal output");
+  parser.add_option("binary-files")
+    .help("assume that binary files are TYPE; TYPE is 'binary', 'text', or 'without-match'");
+  parser.add_alias_flag("a,text", "binary-files", "text")
+    .help("equivalent to --binary-files=text");
+  parser.add_alias_flag("-I", "binary-files", "without-match")
+    .help("equivalent to --binary-files=without-match");
+  parser.add_option("d,directories")
+    .help("how to handle directories; ACTION is 'read', 'recurse', or 'skip'");
+  parser.add_option("D,devices")
+    .help("how to handle devices, FIFOs and sockets; ACTION is 'read' or 'skip'");
+  parser.add_flag("r,recursive")
+    .help("like --directories=recurse");
+  parser.add_flag("R,dereference-recursive")
+    .help("likewise, but follow all symlinks");
+  parser.add_option("include")
+    .help("search only files that match GLOB (a file pattern)");
+  parser.add_option("exclude")
+    .help("skip files that match GLOB");
+  parser.add_option("exclude-from")
+    .help("skip files that match any file pattern from FILE");
+  parser.add_option("exclude-dir")
+    .help("skip directories that match GLOB");
+  parser.add_flag("L,files-without-match")
+    .help("print only names of FILEs with no selected lines");
+  parser.add_flag("l,files-with-matches")
+    .help("print only names of FILEs with selected lines");
+  parser.add_flag("c,count")
+    .help("print only a count of selected lines per FILE");
+  parser.add_flag("T,initial-tab")
+    .help("make tabs line up (if needed)");
+  parser.add_flag("Z,null")
+    .help("print 0 byte after FILE name");
+
+  parser.add_option<int>("B,before-context")
+    .help("print NUM lines of leading context");
+  parser.add_option<int>("A,after-context")
+    .help("print NUM lines of trailing context");
+  parser.add_option<int>("C,context")
+    .help("print NUM lines of output context");
+  // TODO:
+  // -NUM                      same as --context=NUM
+  parser.add_option("group-separator")
+    .help("print SEP on line between matches with context");
+  parser.add_option("no-group-separator")
+    .help("do not print separator for matches with context");
+  parser.add_option("color,colour")
+    .help("use markers to highlight the matching strings; WHEN is 'always', 'never', or 'auto'");
+  parser.add_option("U,binary")
+    .help("do not strip CR characters at EOL (MSDOS/Windows)");
+
+  return parser;
+}
+
+
+
 argparse::ArgParser make_zip_parser(){
   argparse::ArgParser parser;
   return parser;
diff --git a/tests/ls_test.cpp b/tests/ls_test.cpp
index 31bd331..fa88ab2 100644
--- a/tests/ls_test.cpp
+++ b/tests/ls_test.cpp
@@ -227,7 +227,6 @@ struct LsOptions {
   bool flag_C;
   std::string option_D;
   bool flag_F;
-  bool flag_G;
   bool flag_H;
   bool flag_I;
   bool flag_L;
@@ -297,7 +296,7 @@ make_ls_parser_bind() {
       .help(
           R"(Display a slash (‘/’) immediately after each pathname that is a directory, an asterisk (‘*’) after each that is executable, an at sign (‘@’) after each symbolic link, an equals sign (‘=’) after each socket, a percent sign (‘%’) after each whiteout, and a vertical bar (‘|’) after each that is a FIFO.)");
 
-  parser.add_flag("G", option->flag_G)
+  parser.add_alias_flag("G", "color", "auto")
       .help(
           R"(Enable colorized output.  This option is equivalent to defining CLICOLOR or COLORTERM in the environment and setting --color=auto.  (See below.)  This functionality can be compiled out by removing the definition of COLORLS.  This option is not defined in IEEE Std 1003.1-2008 (“POSIX.1”).)");
 
@@ -492,7 +491,7 @@ argparse::ArgParser make_ls_parser_unbind() {
   parser.add_flag("F").help(
       R"(Display a slash (‘/’) immediately after each pathname that is a directory, an asterisk (‘*’) after each that is executable, an at sign (‘@’) after each symbolic link, an equals sign (‘=’) after each socket, a percent sign (‘%’) after each whiteout, and a vertical bar (‘|’) after each that is a FIFO.)");
 
-  parser.add_flag("G").help(
+  parser.add_alias_flag("G", "color", "auto").help(
       R"(Enable colorized output.  This option is equivalent to defining CLICOLOR or COLORTERM in the environment and setting --color=auto.  (See below.)  This functionality can be compiled out by removing the definition of COLORLS.  This option is not defined in IEEE Std 1003.1-2008 (“POSIX.1”).)");
 
   parser.add_flag("H").help(
@@ -730,7 +729,6 @@ TEST(ArgParse, lscmd_bind) {
   ASSERT_EQ(parser["B"].as<bool>(), options->flag_B);
   ASSERT_EQ(parser["C"].as<bool>(), options->flag_C);
   ASSERT_EQ(parser["F"].as<bool>(), options->flag_F);
-  ASSERT_EQ(parser["G"].as<bool>(), options->flag_G);
   ASSERT_EQ(parser["H"].as<bool>(), options->flag_H);
   ASSERT_EQ(parser["I"].as<bool>(), options->flag_I);
   ASSERT_EQ(parser["L"].as<bool>(), options->flag_L);
@@ -780,7 +778,6 @@ TEST(ArgParse, lscmd_bind) {
   ASSERT_EQ(&(parser["B"].as<bool>()), &(options->flag_B));
   ASSERT_EQ(&(parser["C"].as<bool>()), &(options->flag_C));
   ASSERT_EQ(&(parser["F"].as<bool>()), &(options->flag_F));
-  ASSERT_EQ(&(parser["G"].as<bool>()), &(options->flag_G));
   ASSERT_EQ(&(parser["H"].as<bool>()), &(options->flag_H));
   ASSERT_EQ(&(parser["I"].as<bool>()), &(options->flag_I));
   ASSERT_EQ(&(parser["L"].as<bool>()), &(options->flag_L));
@@ -1003,7 +1000,7 @@ TEST(lscmd, parser3_bind) {
   ASSERT_EQ(parser["color"].as<std::string>(), "when");
   ASSERT_EQ(options->option_color, "when");
 
-  std::vector<const char*> cmd{"ls",  "-laF",    "--color=always",
+  std::vector<const char*> cmd{"ls",  "-laF",    "--color=always", "-G",
                                "./1", "./1/2/3", ".hided/"};
 
   parser.parse(cmd.size(), cmd.data());
@@ -1015,8 +1012,8 @@ TEST(lscmd, parser3_bind) {
   ASSERT_TRUE(options->flag_a);
   ASSERT_TRUE(options->flag_F);
 
-  ASSERT_EQ(parser["color"].as<std::string>(), "always");
-  ASSERT_EQ(options->option_color, "always");
+  ASSERT_EQ(parser["color"].as<std::string>(), "auto");
+  ASSERT_EQ(options->option_color, "auto");
 
   ASSERT_EQ(
       parser["files_or_directories"].as<std::vector<std::string>>().size(), 3);
@@ -1038,7 +1035,7 @@ TEST(lscmd, parser3) {
 
   ASSERT_EQ(parser["color"].as<std::string>(), "when");
 
-  std::vector<const char*> cmd{"ls",  "-laF",    "--color=always",
+  std::vector<const char*> cmd{"ls",  "-laF",    "--color=always", "-G",
                                "./1", "./1/2/3", ".hided/"};
 
   parser.parse(cmd.size(), cmd.data());
@@ -1047,7 +1044,7 @@ TEST(lscmd, parser3) {
   ASSERT_TRUE(parser["a"].as<bool>());
   ASSERT_TRUE(parser["F"].as<bool>());
 
-  ASSERT_EQ(parser["color"].as<std::string>(), "always");
+  ASSERT_EQ(parser["color"].as<std::string>(), "auto");
 
   ASSERT_EQ(
       parser["files_or_directories"].as<std::vector<std::string>>().size(), 3);