diff --git a/include/ss/common.hpp b/include/ss/common.hpp
new file mode 100644
index 0000000..d2d34bd
--- /dev/null
+++ b/include/ss/common.hpp
@@ -0,0 +1,19 @@
+#pragma once
+#include <vector>
+
+namespace ss {
+
+struct none {};
+
+using string_range = std::pair<const char*, const char*>;
+using split_data = std::vector<string_range>;
+
+constexpr inline auto default_delimiter = ",";
+
+template <bool StringError>
+inline void assert_string_error_defined() {
+    static_assert(StringError,
+                  "'string_error' needs to be enabled to use 'error_msg'");
+}
+
+} /* ss */
diff --git a/include/ss/converter.hpp b/include/ss/converter.hpp
index 0a0b837..74546d8 100644
--- a/include/ss/converter.hpp
+++ b/include/ss/converter.hpp
@@ -40,19 +40,13 @@ template <typename T>
 using no_validator_t = typename no_validator<T>::type;
 
 template <typename... Ts>
-struct no_validator_tup {
-    using type = typename apply_trait<no_validator, std::tuple<Ts...>>::type;
-};
+struct no_validator_tup : apply_trait<no_validator, std::tuple<Ts...>> {};
 
 template <typename... Ts>
-struct no_validator_tup<std::tuple<Ts...>> {
-    using type = typename no_validator_tup<Ts...>::type;
-};
+struct no_validator_tup<std::tuple<Ts...>> : no_validator_tup<Ts...> {};
 
 template <typename T>
-struct no_validator_tup<std::tuple<T>> {
-    using type = no_validator_t<T>;
-};
+struct no_validator_tup<std::tuple<T>> : no_validator<T> {};
 
 template <typename... Ts>
 using no_validator_tup_t = typename no_validator_tup<Ts...>::type;
@@ -62,10 +56,7 @@ using no_validator_tup_t = typename no_validator_tup<Ts...>::type;
 ////////////////
 
 template <typename... Ts>
-struct no_void_tup {
-    using type =
-        typename filter_not<std::is_void, no_validator_tup_t<Ts...>>::type;
-};
+struct no_void_tup : filter_not<std::is_void, no_validator_tup_t<Ts...>> {};
 
 template <typename... Ts>
 using no_void_tup_t = filter_not_t<std::is_void, Ts...>;
@@ -76,14 +67,11 @@ using no_void_tup_t = filter_not_t<std::is_void, Ts...>;
 
 // replace 'validators' and remove void from tuple
 template <typename... Ts>
-struct no_void_validator_tup {
-    using type = no_validator_tup_t<no_void_tup_t<Ts...>>;
-};
+struct no_void_validator_tup : no_validator_tup<no_void_tup_t<Ts...>> {};
 
 template <typename... Ts>
-struct no_void_validator_tup<std::tuple<Ts...>> {
-    using type = no_validator_tup_t<no_void_tup_t<Ts...>>;
-};
+struct no_void_validator_tup<std::tuple<Ts...>>
+    : no_validator_tup<no_void_tup_t<Ts...>> {};
 
 template <typename... Ts>
 using no_void_validator_tup_t = typename no_void_validator_tup<Ts...>::type;
@@ -131,12 +119,12 @@ public:
     no_void_validator_tup_t<Ts...> convert(
         line_ptr_type line, const std::string& delim = default_delimiter) {
         split(line, delim);
-        return convert<Ts...>(splitter_.split_input_);
+        return convert<Ts...>(splitter_.split_data_);
     }
 
     // parses already split line, returns 'T' object with extracted values
     template <typename T, typename... Ts>
-    T convert_object(const split_input& elems) {
+    T convert_object(const split_data& elems) {
         return to_object<T>(convert<Ts...>(elems));
     }
 
@@ -151,17 +139,12 @@ public:
     // one argument is given which is a class which has a tied
     // method which returns a tuple, returns that type
     template <typename T, typename... Ts>
-    no_void_validator_tup_t<T, Ts...> convert(const split_input& elems) {
-        if constexpr (sizeof...(Ts) == 0 &&
-                      is_instance_of<T, std::tuple>::value) {
+    no_void_validator_tup_t<T, Ts...> convert(const split_data& elems) {
+        if constexpr (sizeof...(Ts) == 0 && is_instance_of_v<std::tuple, T>) {
             return convert_impl(elems, static_cast<T*>(nullptr));
-
         } else if constexpr (tied_class_v<T, Ts...>) {
-            using arg_ref_tuple =
-                typename std::result_of_t<decltype (&T::tied)(T)>;
-
-            using arg_tuple =
-                typename apply_trait<std::decay, arg_ref_tuple>::type;
+            using arg_ref_tuple = std::result_of_t<decltype (&T::tied)(T)>;
+            using arg_tuple = apply_trait_t<std::decay, arg_ref_tuple>;
 
             return to_object<T>(
                 convert_impl(elems, static_cast<arg_tuple*>(nullptr)));
@@ -173,7 +156,7 @@ public:
     // same as above, but uses cached split line
     template <typename T, typename... Ts>
     no_void_validator_tup_t<T, Ts...> convert() {
-        return convert<T, Ts...>(splitter_.split_input_);
+        return convert<T, Ts...>(splitter_.split_data_);
     }
 
     bool valid() const {
@@ -185,8 +168,7 @@ public:
     }
 
     const std::string& error_msg() const {
-        static_assert(string_error,
-                      "'string_error' needs to be enabled to use 'error_msg'");
+        assert_string_error_defined<string_error>();
         return error_;
     }
 
@@ -196,11 +178,11 @@ public:
 
     // 'splits' string by given delimiter, returns vector of pairs which
     // contain the beginnings and the ends of each column of the string
-    const split_input& split(line_ptr_type line,
-                             const std::string& delim = default_delimiter) {
-        splitter_.split_input_.clear();
+    const split_data& split(line_ptr_type line,
+                            const std::string& delim = default_delimiter) {
+        splitter_.split_data_.clear();
         if (line[0] == '\0') {
-            return splitter_.split_input_;
+            return splitter_.split_data_;
         }
 
         return splitter_.split(line, delim);
@@ -211,8 +193,8 @@ private:
     // resplit
     ////////////////
 
-    const split_input& resplit(line_ptr_type new_line, ssize_t new_size,
-                               const std::string& delim = default_delimiter) {
+    const split_data& resplit(line_ptr_type new_line, ssize_t new_size,
+                              const std::string& delim = default_delimiter) {
         return splitter_.resplit(new_line, new_size, delim);
     }
 
@@ -285,7 +267,7 @@ private:
     ////////////////
 
     template <typename... Ts>
-    no_void_validator_tup_t<Ts...> convert_impl(const split_input& elems) {
+    no_void_validator_tup_t<Ts...> convert_impl(const split_data& elems) {
         clear_error();
 
         if (!splitter_.valid()) {
@@ -306,7 +288,7 @@ private:
     // do not know how to specialize by return type :(
     template <typename... Ts>
     no_void_validator_tup_t<std::tuple<Ts...>> convert_impl(
-        const split_input& elems, const std::tuple<Ts...>*) {
+        const split_data& elems, const std::tuple<Ts...>*) {
         return convert_impl<Ts...>(elems);
     }
 
@@ -345,11 +327,11 @@ private:
 
     template <size_t ArgN, size_t TupN, typename... Ts>
     void extract_multiple(no_void_validator_tup_t<Ts...>& tup,
-                          const split_input& elems) {
+                          const split_data& elems) {
         using elem_t = std::tuple_element_t<ArgN, std::tuple<Ts...>>;
 
         constexpr bool not_void = !std::is_void_v<elem_t>;
-        constexpr bool one_element = count_not<std::is_void, Ts...>::size == 1;
+        constexpr bool one_element = count_not_v<std::is_void, Ts...> == 1;
 
         if constexpr (not_void) {
             if constexpr (one_element) {
@@ -367,8 +349,8 @@ private:
     }
 
     template <typename... Ts>
-    no_void_validator_tup_t<Ts...> extract_tuple(const split_input& elems) {
-        static_assert(!all_of<std::is_void, Ts...>::value,
+    no_void_validator_tup_t<Ts...> extract_tuple(const split_data& elems) {
+        static_assert(!all_of_v<std::is_void, Ts...>,
                       "at least one parameter must be non void");
         no_void_validator_tup_t<Ts...> ret{};
         extract_multiple<0, 0, Ts...>(ret, elems);
@@ -379,7 +361,7 @@ private:
     // members
     ////////////////
 
-    error_type error_;
+    error_type error_{};
     splitter<Matchers...> splitter_;
 
     template <typename...>
diff --git a/include/ss/extract.hpp b/include/ss/extract.hpp
index 60d3fdb..ebf7ef8 100644
--- a/include/ss/extract.hpp
+++ b/include/ss/extract.hpp
@@ -225,8 +225,8 @@ struct unsupported_type {
 
 template <typename T>
 std::enable_if_t<!std::is_integral_v<T> && !std::is_floating_point_v<T> &&
-                     !is_instance_of<T, std::optional>::value &&
-                     !is_instance_of<T, std::variant>::value,
+                     !is_instance_of_v<std::optional, T> &&
+                     !is_instance_of_v<std::variant, T>,
                  bool>
 extract(const char*, const char*, T&) {
     static_assert(error::unsupported_type<T>::value,
@@ -246,7 +246,7 @@ extract(const char* begin, const char* end, T& value) {
 }
 
 template <typename T>
-std::enable_if_t<is_instance_of<T, std::optional>::value, bool> extract(
+std::enable_if_t<is_instance_of_v<std::optional, T>, bool> extract(
     const char* begin, const char* end, T& value) {
     typename T::value_type raw_value;
     if (extract(begin, end, raw_value)) {
@@ -271,7 +271,7 @@ bool extract_variant(const char* begin, const char* end, T& value) {
 }
 
 template <typename T>
-std::enable_if_t<is_instance_of<T, std::variant>::value, bool> extract(
+std::enable_if_t<is_instance_of_v<std::variant, T>, bool> extract(
     const char* begin, const char* end, T& value) {
     return extract_variant<T, 0>(begin, end, value);
 }
diff --git a/include/ss/parser.hpp b/include/ss/parser.hpp
index af740b1..7054e7c 100644
--- a/include/ss/parser.hpp
+++ b/include/ss/parser.hpp
@@ -13,8 +13,6 @@ namespace ss {
 
 template <typename... Matchers>
 class parser {
-    struct none {};
-
     constexpr static auto string_error = setup<Matchers...>::string_error;
     constexpr static auto multiline = setup<Matchers...>::multiline;
 
@@ -48,8 +46,7 @@ public:
     }
 
     const std::string& error_msg() const {
-        static_assert(string_error,
-                      "'string_error' needs to be enabled to use 'error_msg'");
+        assert_string_error_defined<string_error>();
         return error_;
     }
 
@@ -157,11 +154,13 @@ public:
                 if (!parser_.valid()) {
                     return;
                 }
+
                 if constexpr (!std::is_same_v<U, decltype(tuple_output)>) {
                     value = to_object<U>(std::move(tuple_output));
                 } else {
                     value = std::move(tuple_output);
                 }
+
                 parser_.try_invoke(*value, std::forward<Fun>(fun));
             }
         }
@@ -177,6 +176,10 @@ public:
             return value;
         }
 
+        ////////////////
+        // members
+        ////////////////
+
         std::tuple<Ts...> values_;
         parser& parser_;
     };
@@ -488,7 +491,7 @@ private:
     ////////////////
 
     std::string file_name_;
-    error_type error_;
+    error_type error_{};
     reader reader_;
     size_t line_number_{0};
     bool eof_{false};
diff --git a/include/ss/setup.hpp b/include/ss/setup.hpp
index c773fca..228cb1e 100644
--- a/include/ss/setup.hpp
+++ b/include/ss/setup.hpp
@@ -4,6 +4,10 @@
 
 namespace ss {
 
+////////////////
+// matcher
+////////////////
+
 template <char... Cs>
 struct matcher {
 private:
@@ -36,7 +40,7 @@ public:
 };
 
 template <typename FirstMatcher, typename SecondMatcher>
-constexpr bool matches_intersect() {
+inline constexpr bool matches_intersect() {
     for (const auto& first_match : FirstMatcher::matches) {
         for (const auto& second_match : SecondMatcher::matches) {
             if (first_match != '\0' && first_match == second_match) {
@@ -47,6 +51,13 @@ constexpr bool matches_intersect() {
     return false;
 }
 
+template <typename FirstMatcher, typename SecondMatcher1,
+          typename SecondMatcher2>
+inline constexpr bool matches_intersect_union() {
+    return matches_intersect<FirstMatcher, SecondMatcher1>() ||
+           matches_intersect<FirstMatcher, SecondMatcher2>();
+}
+
 template <>
 class matcher<'\0'> {
 public:
@@ -55,31 +66,57 @@ public:
     static bool match(char c) = delete;
 };
 
+////////////////
+// setup parameters
+////////////////
+
 template <char C>
 struct quote : matcher<C> {};
 
 template <char... Cs>
 struct trim : matcher<Cs...> {};
 
+template <char... Cs>
+struct trim_left : matcher<Cs...> {};
+
+template <char... Cs>
+struct trim_right : matcher<Cs...> {};
+
 template <char... Cs>
 struct escape : matcher<Cs...> {};
 
+// TODO add limit
+class multiline;
+
+class string_error;
+
+////////////////
+// setup implementation
+////////////////
+
 template <typename T, template <char...> class Template>
-struct is_instance_of_matcher {
-    constexpr static bool value = false;
-};
+struct is_instance_of_matcher : std::false_type {};
 
 template <char... Ts, template <char...> class Template>
-struct is_instance_of_matcher<Template<Ts...>, Template> {
-    constexpr static bool value = true;
-};
+struct is_instance_of_matcher<Template<Ts...>, Template> : std::true_type {};
+
+template <typename T, template <char...> class Template>
+using is_instance_of_matcher_t =
+    typename is_instance_of_matcher<T, Template>::type;
 
 template <template <char...> class Matcher, typename... Ts>
 struct get_matcher;
 
 template <template <char...> class Matcher, typename T, typename... Ts>
 struct get_matcher<Matcher, T, Ts...> {
-    using type = ternary_t<is_instance_of_matcher<T, Matcher>::value, T,
+
+    template <typename U>
+    struct is_matcher : is_instance_of_matcher<U, Matcher> {};
+
+    static_assert(count_v<is_matcher, T, Ts...> <= 1,
+                  "the same matcher is cannot"
+                  "be defined multiple times");
+    using type = ternary_t<is_matcher<T>::value, T,
                            typename get_matcher<Matcher, Ts...>::type>;
 };
 
@@ -91,39 +128,72 @@ struct get_matcher<Matcher> {
 template <template <char...> class Matcher, typename... Ts>
 using get_matcher_t = typename get_matcher<Matcher, Ts...>::type;
 
-class multiline;
-class string_error;
-
 template <typename... Ts>
 struct setup {
 private:
     template <typename T>
-    struct is_multiline : std::is_same<T, multiline> {};
+    struct is_matcher
+        : std::disjunction<is_instance_of_matcher_t<T, quote>,
+                           is_instance_of_matcher_t<T, escape>,
+                           is_instance_of_matcher_t<T, trim>,
+                           is_instance_of_matcher_t<T, trim_left>,
+                           is_instance_of_matcher_t<T, trim_right>> {};
 
-    constexpr static auto count_multiline = count<is_multiline, Ts...>::size;
+    template <typename T>
+    struct is_multiline : std::is_same<T, multiline> {};
 
     template <typename T>
     struct is_string_error : std::is_same<T, string_error> {};
 
-    constexpr static auto count_string_error =
-        count<is_string_error, Ts...>::size;
+    constexpr static auto count_matcher = count_v<is_matcher, Ts...>;
+    constexpr static auto count_multiline = count_v<is_multiline, Ts...>;
+    constexpr static auto count_string_error = count_v<is_string_error, Ts...>;
+
+    constexpr static auto number_of_valid_setup_types =
+        count_matcher + count_multiline + count_string_error;
+
+    using trim_left_only = get_matcher_t<trim_left, Ts...>;
+    using trim_right_only = get_matcher_t<trim_right, Ts...>;
+    using trim_all = get_matcher_t<trim, Ts...>;
 
 public:
     using quote = get_matcher_t<quote, Ts...>;
-    using trim = get_matcher_t<trim, Ts...>;
     using escape = get_matcher_t<escape, Ts...>;
+
+    using trim_left = ternary_t<trim_all::enabled, trim_all, trim_left_only>;
+    using trim_right = ternary_t<trim_all::enabled, trim_all, trim_right_only>;
+
     constexpr static bool multiline = (count_multiline == 1);
     constexpr static bool string_error = (count_string_error == 1);
 
+private:
+#define ASSERT_MSG "cannot have the same match character in multiple matchers"
+    static_assert(!matches_intersect<escape, quote>(), ASSERT_MSG);
+
+    constexpr static auto quote_trim_intersect =
+        matches_intersect_union<quote, trim_left, trim_right>();
+    static_assert(!quote_trim_intersect, ASSERT_MSG);
+
+    constexpr static auto escape_trim_intersect =
+        matches_intersect_union<escape, trim_left, trim_right>();
+    static_assert(!escape_trim_intersect, ASSERT_MSG);
+
+#undef ASSERT_MSG
+
     static_assert(
         !multiline || (multiline && (quote::enabled || escape::enabled)),
         "to enable multiline either quote or escape need to be enabled");
 
-#define ASSERT_MSG "cannot have the same match character in multiple matchers"
-    static_assert(!matches_intersect<quote, trim>(), ASSERT_MSG);
-    static_assert(!matches_intersect<trim, escape>(), ASSERT_MSG);
-    static_assert(!matches_intersect<escape, quote>(), ASSERT_MSG);
-#undef ASSERT_MSG
+    static_assert(!(trim_all::enabled && trim_left_only::enabled) &&
+                      !(trim_all::enabled && trim_right_only::enabled),
+                  "ambiguous trim setup");
+
+    static_assert(count_multiline <= 1, "mutliline defined multiple times");
+    static_assert(count_string_error <= 1,
+                  "string_error defined multiple times");
+
+    static_assert(number_of_valid_setup_types == sizeof...(Ts),
+                  "one or multiple invalid setup parameters defined");
 };
 
 template <typename... Ts>
diff --git a/include/ss/splitter.hpp b/include/ss/splitter.hpp
index 483d85d..0024b80 100644
--- a/include/ss/splitter.hpp
+++ b/include/ss/splitter.hpp
@@ -1,4 +1,5 @@
 #pragma once
+#include "common.hpp"
 #include "setup.hpp"
 #include "type_traits.hpp"
 #include <algorithm>
@@ -10,16 +11,12 @@
 
 namespace ss {
 
-// TODO move to common or something
-using string_range = std::pair<const char*, const char*>;
-using split_input = std::vector<string_range>;
-constexpr static auto default_delimiter = ",";
-
 template <typename... Ts>
 class splitter {
 private:
     using quote = typename setup<Ts...>::quote;
-    using trim = typename setup<Ts...>::trim;
+    using trim_left = typename setup<Ts...>::trim_left;
+    using trim_right = typename setup<Ts...>::trim_right;
     using escape = typename setup<Ts...>::escape;
 
     constexpr static auto string_error = setup<Ts...>::string_error;
@@ -39,8 +36,7 @@ public:
     }
 
     const std::string& error_msg() const {
-        static_assert(string_error,
-                      "'string_error' needs to be enabled to use 'error_msg'");
+        assert_string_error_defined<string_error>();
         return error_;
     }
 
@@ -48,9 +44,9 @@ public:
         return unterminated_quote_;
     }
 
-    const split_input& split(line_ptr_type new_line,
-                             const std::string& delimiter = default_delimiter) {
-        split_input_.clear();
+    const split_data& split(line_ptr_type new_line,
+                            const std::string& delimiter = default_delimiter) {
+        split_data_.clear();
         return resplit(new_line, -1, delimiter);
     }
 
@@ -60,32 +56,34 @@ private:
     ////////////////
 
     void adjust_ranges(const char* old_line) {
-        for (auto& [begin, end] : split_input_) {
+        for (auto& [begin, end] : split_data_) {
             begin = begin - old_line + line_;
             end = end - old_line + line_;
         }
     }
 
-    const split_input& resplit(
+    const split_data& resplit(
         line_ptr_type new_line, ssize_t new_size,
         const std::string& delimiter = default_delimiter) {
         line_ = new_line;
 
         // resplitting, continue from last slice
-        if (!split_input_.empty() && unterminated_quote()) {
-            const auto& last = std::prev(split_input_.end());
-            const auto [old_line, old_begin] = *last;
-            size_t begin = old_begin - old_line - 1;
-            split_input_.pop_back();
-            adjust_ranges(old_line);
+        if constexpr (quote::enabled) {
+            if (!split_data_.empty() && unterminated_quote()) {
+                const auto& last = std::prev(split_data_.end());
+                const auto [old_line, old_begin] = *last;
+                size_t begin = old_begin - old_line - 1;
+                split_data_.pop_back();
+                adjust_ranges(old_line);
 
-            // safety measure
-            if (new_size != -1 && static_cast<size_t>(new_size) < begin) {
-                set_error_invalid_resplit();
-                return split_input_;
+                // safety measure
+                if (new_size != -1 && static_cast<size_t>(new_size) < begin) {
+                    set_error_invalid_resplit();
+                    return split_data_;
+                }
+
+                begin_ = line_ + begin;
             }
-
-            begin_ = line_ + begin;
         }
 
         return split_impl_select_delim(delimiter);
@@ -163,9 +161,17 @@ private:
         return delim.size();
     }
 
-    void trim_if_enabled(line_ptr_type& curr) {
-        if constexpr (trim::enabled) {
-            while (trim::match(*curr)) {
+    void trim_left_if_enabled(line_ptr_type& curr) {
+        if constexpr (trim_left::enabled) {
+            while (trim_left::match(*curr)) {
+                ++curr;
+            }
+        }
+    }
+
+    void trim_right_if_enabled(line_ptr_type& curr) {
+        if constexpr (trim_right::enabled) {
+            while (trim_right::match(*curr)) {
                 ++curr;
             }
         }
@@ -176,7 +182,7 @@ private:
                                              const Delim& delim) {
         line_ptr_type end = begin;
 
-        trim_if_enabled(end);
+        trim_right_if_enabled(end);
 
         // just spacing
         if (*end == '\0') {
@@ -190,7 +196,7 @@ private:
         }
 
         end += delimiter_size(delim);
-        trim_if_enabled(end);
+        trim_left_if_enabled(end);
 
         // delimiter
         return {end - begin, true};
@@ -213,7 +219,7 @@ private:
 
     void shift_and_push() {
         shift_and_set_current();
-        split_input_.emplace_back(begin_, curr_);
+        split_data_.emplace_back(begin_, curr_);
     }
 
     void shift_if_escaped(line_ptr_type& curr) {
@@ -241,13 +247,13 @@ private:
     // split impl
     ////////////////
 
-    const split_input& split_impl_select_delim(
+    const split_data& split_impl_select_delim(
         const std::string& delimiter = default_delimiter) {
         clear_error();
         switch (delimiter.size()) {
         case 0:
             set_error_empty_delimiter();
-            return split_input_;
+            return split_data_;
         case 1:
             return split_impl(delimiter[0]);
         default:
@@ -256,18 +262,18 @@ private:
     }
 
     template <typename Delim>
-    const split_input& split_impl(const Delim& delim) {
+    const split_data& split_impl(const Delim& delim) {
 
-        if (split_input_.empty()) {
+        if (split_data_.empty()) {
             begin_ = line_;
         }
 
-        trim_if_enabled(begin_);
+        trim_left_if_enabled(begin_);
 
         for (done_ = false; !done_; read(delim))
             ;
 
-        return split_input_;
+        return split_data_;
     }
 
     ////////////////
@@ -329,7 +335,7 @@ private:
                     // eg: ..."hell\0 -> quote not terminated
                     if (*end_ == '\0') {
                         set_error_unterminated_quote();
-                        split_input_.emplace_back(line_, begin_);
+                        split_data_.emplace_back(line_, begin_);
                         done_ = true;
                         break;
                     }
@@ -363,7 +369,7 @@ private:
                     // mismatched quote
                     // eg: ...,"hel"lo,... -> error
                     set_error_mismatched_quote(end_ - line_);
-                    split_input_.emplace_back(line_, begin_);
+                    split_data_.emplace_back(line_, begin_);
                 }
                 done_ = true;
                 break;
@@ -375,17 +381,16 @@ private:
     // members
     ////////////////
 
-    static_assert(std::is_same_v<error_type, bool> ||
-                  std::is_same_v<error_type, std::string>);
-    error_type error_;
+    error_type error_{};
     bool unterminated_quote_{false};
+    bool done_;
+    size_t escaped_{0};
+    split_data split_data_;
+
     line_ptr_type begin_;
     line_ptr_type curr_;
     line_ptr_type end_;
     line_ptr_type line_;
-    bool done_;
-    size_t escaped_{0};
-    split_input split_input_;
 
     template <typename...>
     friend class converter;
diff --git a/include/ss/type_traits.hpp b/include/ss/type_traits.hpp
index 73913da..2fd75ad 100644
--- a/include/ss/type_traits.hpp
+++ b/include/ss/type_traits.hpp
@@ -103,6 +103,9 @@ struct apply_trait<Trait, std::tuple<T>> {
     using type = std::tuple<typename Trait<T>::type>;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+using apply_trait_t = typename apply_trait<Trait, Ts...>::type;
+
 ////////////////
 // apply optional trait
 ////////////////
@@ -143,6 +146,9 @@ struct apply_optional_trait<Trait, std::tuple<T>> {
         std::tuple<typename optional_trait<typename Trait<T>::type, T>::type>;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+using apply_trait_optional_t = apply_optional_trait<Trait, Ts...>;
+
 ////////////////
 // filter false_type
 ////////////////
@@ -192,6 +198,9 @@ struct negate_impl {
     using type = std::integral_constant<bool, !Trait<Ts...>::value>;
 };
 
+template <template <typename...> class Trait>
+using negate_impl_t = typename negate_impl<Trait>::type;
+
 ////////////////
 // filter by trait
 ////////////////
@@ -235,20 +244,23 @@ struct count;
 
 template <template <typename...> class Trait, typename T, typename... Ts>
 struct count<Trait, T, Ts...> {
-    static constexpr size_t size =
+    static constexpr size_t value =
         std::tuple_size<filter_if_t<Trait, T, Ts...>>::value;
 };
 
 template <template <typename...> class Trait, typename T>
 struct count<Trait, T> {
-    static constexpr size_t size = Trait<T>::value;
+    static constexpr size_t value = Trait<T>::value;
 };
 
 template <template <typename...> class Trait>
 struct count<Trait> {
-    static constexpr size_t size = 0;
+    static constexpr size_t value = 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr size_t count_v = count<Trait, Ts...>::value;
+
 ////////////////
 // count not
 ////////////////
@@ -258,34 +270,40 @@ struct count_not;
 
 template <template <typename...> class Trait, typename T, typename... Ts>
 struct count_not<Trait, T, Ts...> {
-    static constexpr size_t size =
+    static constexpr size_t value =
         std::tuple_size<filter_not_t<Trait, T, Ts...>>::value;
 };
 
 template <template <typename...> class Trait, typename T>
 struct count_not<Trait, T> {
-    static constexpr size_t size = !Trait<T>::value;
+    static constexpr size_t value = !Trait<T>::value;
 };
 
 template <template <typename...> class Trait>
 struct count_not<Trait> {
-    static constexpr size_t size = 0;
+    static constexpr size_t value = 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr size_t count_not_v = count_not<Trait, Ts...>::value;
+
 ////////////////
 // all of
 ////////////////
 
 template <template <typename...> class Trait, typename... Ts>
 struct all_of {
-    static constexpr bool value = count<Trait, Ts...>::size == sizeof...(Ts);
+    static constexpr bool value = count_v<Trait, Ts...> == sizeof...(Ts);
 };
 
 template <template <typename...> class Trait, typename... Ts>
 struct all_of<Trait, std::tuple<Ts...>> {
-    static constexpr bool value = count<Trait, Ts...>::size == sizeof...(Ts);
+    static constexpr bool value = count_v<Trait, Ts...> == sizeof...(Ts);
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr bool all_of_v = all_of<Trait, Ts...>::value;
+
 ////////////////
 // any of
 ////////////////
@@ -293,43 +311,52 @@ struct all_of<Trait, std::tuple<Ts...>> {
 template <template <typename...> class Trait, typename... Ts>
 struct any_of {
     static_assert(sizeof...(Ts) > 0);
-    static constexpr bool value = count<Trait, Ts...>::size > 0;
+    static constexpr bool value = count_v<Trait, Ts...> > 0;
 };
 
 template <template <typename...> class Trait, typename... Ts>
 struct any_of<Trait, std::tuple<Ts...>> {
     static_assert(sizeof...(Ts) > 0);
-    static constexpr bool value = count<Trait, Ts...>::size > 0;
+    static constexpr bool value = count_v<Trait, Ts...> > 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr bool any_of_v = any_of<Trait, Ts...>::value;
+
 ////////////////
 // none  of
 ////////////////
 
 template <template <typename...> class Trait, typename... Ts>
 struct none_of {
-    static constexpr bool value = count<Trait, Ts...>::size == 0;
+    static constexpr bool value = count_v<Trait, Ts...> == 0;
 };
 
 template <template <typename...> class Trait, typename... Ts>
 struct none_of<Trait, std::tuple<Ts...>> {
-    static constexpr bool value = count<Trait, Ts...>::size == 0;
+    static constexpr bool value = count_v<Trait, Ts...> == 0;
 };
 
+template <template <typename...> class Trait, typename... Ts>
+constexpr bool none_of_v = none_of<Trait, Ts...>::value;
+
 ////////////////
 // is instance of
 ////////////////
 
-template <typename T, template <typename...> class Template>
+template <template <typename...> class Template, typename T>
 struct is_instance_of {
     constexpr static bool value = false;
 };
 
-template <typename... Ts, template <typename...> class Template>
-struct is_instance_of<Template<Ts...>, Template> {
+template <template <typename...> class Template, typename... Ts>
+struct is_instance_of<Template, Template<Ts...>> {
     constexpr static bool value = true;
 };
 
+template <template <typename...> class Template, typename... Ts>
+constexpr bool is_instance_of_v = is_instance_of<Template, Ts...>::value;
+
 ////////////////
 // ternary
 ////////////////
@@ -354,17 +381,21 @@ using ternary_t = typename ternary<B, T, U>::type;
 // tuple to struct
 ////////////////
 
-template <class S, std::size_t... Is, class Tup>
-S to_object(std::index_sequence<Is...>, Tup&& tup) {
-    return {std::get<Is>(std::forward<Tup>(tup))...};
+template <class T, std::size_t... Is, class U>
+T to_object_impl(std::index_sequence<Is...>, U&& data) {
+    return {std::get<Is>(std::forward<U>(data))...};
 }
 
-// TODO Tup may not be a tuple ...
-template <class S, class Tup>
-S to_object(Tup&& tup) {
-    using T = std::remove_reference_t<Tup>;
-    return to_object<S>(std::make_index_sequence<std::tuple_size<T>{}>{},
-                        std::forward<Tup>(tup));
+template <class T, class U>
+T to_object(U&& data) {
+    using NoRefU = std::remove_reference_t<U>;
+    if constexpr (is_instance_of_v<std::tuple, NoRefU>) {
+        return to_object_impl<
+            T>(std::make_index_sequence<std::tuple_size<NoRefU>{}>{},
+               std::forward<U>(data));
+    } else {
+        return T{std::forward<U>(data)};
+    }
 }
 
 } /* trait */
diff --git a/test/test_splitter.cpp b/test/test_splitter.cpp
index 1b1a380..6a83e10 100644
--- a/test/test_splitter.cpp
+++ b/test/test_splitter.cpp
@@ -17,7 +17,7 @@ struct set_combinations_size {
     }
 };
 
-std::vector<std::string> words(const ss::split_input& input) {
+std::vector<std::string> words(const ss::split_data& input) {
     std::vector<std::string> ret;
     for (const auto& [begin, end] : input) {
         ret.emplace_back(begin, end);
@@ -88,6 +88,30 @@ auto spaced(const case_type& input, const std::string& s1,
     return ret;
 }
 
+auto spaced_left(const case_type& input, const std::string& s) {
+    case_type ret = input;
+    for (const auto& i : input) {
+        ret.push_back(concat(i));
+        ret.push_back(concat(s, i));
+        ret.push_back(concat(s, s, i));
+        ret.push_back(concat(s, s, s, i));
+    }
+
+    return ret;
+}
+
+auto spaced_right(const case_type& input, const std::string& s) {
+    case_type ret = input;
+    for (const auto& i : input) {
+        ret.push_back(concat(i));
+        ret.push_back(concat(i, s));
+        ret.push_back(concat(i, s, s));
+        ret.push_back(concat(i, s, s, s));
+    }
+
+    return ret;
+}
+
 std::vector<std::string> combinations(const std::vector<std::string>& v,
                                       const std::string& delim, size_t n) {
     if (n <= 1) {
@@ -709,3 +733,104 @@ TEST_CASE("splitter test invalid splits") {
     CHECK(!s.unterminated_quote());
     CHECK(!s.error_msg().empty());
 }
+
+TEST_CASE("splitter test with trim_left") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_left({R"(x )"}, " ");
+    case_type case2 = spaced_left({R"(yy )"}, " ");
+    case_type case3 = spaced_left({R"(y y )"}, " ");
+    case_type case4 = spaced_left({R"()"}, " ");
+
+    std::vector<std::string> delims = {",", "::", "\t", "\n"};
+
+    {
+        matches_type p{{case1, "x "},
+                       {case2, "yy "},
+                       {case3, "y y "},
+                       {case4, ""}};
+        test_combinations<ss::trim_left<' '>>(p, delims);
+    }
+
+    case_type case5 = spaced_left({"z "}, "\t");
+    case_type case6 = spaced_left({"ab\t "}, " \t");
+    case_type case7 = spaced_left({"a\tb "}, " \t");
+    case_type case8 = spaced_left({"a \t b "}, " \t");
+
+    {
+        matches_type p{{case1, "x "},    {case2, "yy "},    {case3, "y y "},
+                       {case4, ""},      {case5, "z "},     {case6, "ab\t "},
+                       {case7, "a\tb "}, {case8, "a \t b "}};
+        test_combinations<ss::trim_left<' ', '\t'>>(p, {",", "::", "\n"});
+    }
+}
+
+TEST_CASE("splitter test with trim_right") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_right({R"( x)"}, " ");
+    case_type case2 = spaced_right({R"( yy)"}, " ");
+    case_type case3 = spaced_right({R"( y y)"}, " ");
+    case_type case4 = spaced_right({R"()"}, " ");
+
+    std::vector<std::string> delims = {",", "::", "\t", "\n"};
+
+    {
+        matches_type p{{case1, " x"},
+                       {case2, " yy"},
+                       {case3, " y y"},
+                       {case4, ""}};
+        test_combinations<ss::trim_right<' '>>(p, delims);
+    }
+
+    case_type case5 = spaced_right({" z"}, "\t");
+    case_type case6 = spaced_right({"\t ab"}, " \t");
+    case_type case7 = spaced_right({"\ta\tb"}, " \t");
+    case_type case8 = spaced_right({" \t a \t b"}, " \t");
+
+    {
+        matches_type p{{case1, " x"},     {case2, " yy"},
+                       {case3, " y y"},   {case4, ""},
+                       {case5, " z"},     {case6, "\t ab"},
+                       {case7, "\ta\tb"}, {case8, " \t a \t b"}};
+        test_combinations<ss::trim_right<' ', '\t'>>(p, {",", "::", "\n"});
+    }
+}
+
+TEST_CASE("splitter test with trim_right and trim_left") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_right({R"(-x)"}, "-");
+    case_type case2 = spaced_left({R"(yy_)"}, "_");
+    case_type case3 = spaced_right({R"(-y y)"}, "-");
+    case_type case4 = spaced_left({R"()"}, "-");
+    case_type case5 = spaced_left({R"()"}, "_");
+    case_type case6 = {"___---", "_-", "______-"};
+
+    std::vector<std::string> delims = {",", "::", "\t", "\n"};
+
+    {
+        matches_type p{{case1, "-x"}, {case2, "yy_"}, {case3, "-y y"},
+                       {case4, ""},   {case5, ""},    {case6, ""}};
+        test_combinations<ss::trim_left<'_'>, ss::trim_right<'-'>>(p, delims);
+    }
+}
+
+TEST_CASE("splitter test with quote and escape, trim_left and trim_right") {
+    auto guard = set_combinations_size(3);
+    case_type case1 = spaced_left({R"("\"")", R"(\")", R"("""")"}, "_");
+    case_type case2 =
+        spaced_left({R"("x\"x")", R"(x\"x)", R"(x"x)", R"("x""x")"}, "_");
+    case_type case3 = spaced_left({R"("")", R"()"}, "_");
+    case_type case4 = spaced_left({R"("x")", R"(x)"}, "_");
+    case_type case5 =
+        spaced_right({R"("\"\"")", R"("""""")", R"("\"""")", R"("""\"")"}, "-");
+    case_type case6 = spaced_right({R"("\\")", R"(\\)"}, "-");
+    case_type case7 = spaced_right({R"("xxxxxxxxxx")", R"(xxxxxxxxxx)"}, "-");
+
+    std::vector<std::string> delims = {"::", "\n"};
+
+    {
+        matches_type p{{case1, "\""},   {case2, "x\"x"}, {case3, ""},
+                       {case5, "\"\""}, {case6, "\\"},   {case7, "xxxxxxxxxx"}};
+        test_combinations<ss::quote<'"'>, ss::escape<'\\'>, ss::trim_left<'_'>,
+                          ss::trim_right<'-'>>(p, delims);
+    }
+}