diff --git a/common/adc_value_holder.h b/common/adc_value_holder.h
index 8c0c9c0..b30a026 100644
--- a/common/adc_value_holder.h
+++ b/common/adc_value_holder.h
@@ -96,8 +96,8 @@ inline std::error_code make_error_code(AdcValueHolderErrorCode ec)
 class AdcValueHolder
 {
 protected:
-    template <typename T>
-    using arg_t = typename traits::adc_func_traits<std::remove_reference_t<T>>::ret_t;
+    // template <typename T>
+    // using arg_t = typename traits::adc_func_traits<std::remove_reference_t<T>>::ret_t;
 
     std::function<void(std::any&)> _getterWrapper;
     std::function<void(const std::any&)> _setterWrapper;
@@ -108,12 +108,12 @@ protected:
     std::type_index _internalTypeIndex;
 
     void init(std::invocable<> auto&& getter,
-              std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
-              std::predicate<const arg_t<decltype(getter)>&> auto&& validator)
+              std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+              std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator)
     {
-        using value_t = arg_t<decltype(getter)>;
+        using value_t = traits::adc_retval_t<decltype(getter)>;
 
-        // static_assert(std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
+        static_assert(!std::is_same_v<value_t, void>, "THE getter MUST NOT RETURN void TYPE!!!");
 
         using g_t = decltype(getter);
         _getterWrapper = [wrapper = traits::adc_pf_wrapper(std::forward<g_t>(getter))](std::any& val) {
@@ -183,42 +183,37 @@ public:
 
     /*  CONSTRUCTORS AND DESTRUCTOR  */
 
-    AdcValueHolder(std::invocable<> auto&& getter,
-                   std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
-                   std::predicate<const arg_t<decltype(getter)>&> auto&& validator)
-        : _internalTypeIndex(std::type_index(typeid(arg_t<decltype(getter)>)))
+    template <typename GT,
+              typename VALT = traits::adc_retval_t<GT>,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
+    AdcValueHolder(GT&& getter,
+                   std::invocable<const VALT&> auto&& setter,
+                   VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+        requires std::invocable<GT> && std::predicate<VT, const VALT&>
+        : _internalTypeIndex(std::type_index(typeid(VALT)))
     {
-        init(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+        init(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
              std::forward<decltype(validator)>(validator));
     }
 
 
-    // NOTE: due to using of concepts one cannot use of default value for validator callable!!!
-    AdcValueHolder(std::invocable<> auto&& getter, std::invocable<const arg_t<decltype(getter)>&> auto&& setter)
-        : AdcValueHolder(std::forward<decltype(getter)>(getter),
-                         std::forward<decltype(setter)>(setter),
-                         AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>)
-    {
-    }
-
-
     template <typename... Ts>
     AdcValueHolder(std::invocable<> auto&& getter,
-                   std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
-                   std::predicate<const arg_t<decltype(getter)>&> auto&& validator,
+                   std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+                   std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator,
                    const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
         : AdcValueHolder(std::forward<decltype(getter)>(getter),
                          std::forward<decltype(setter)>(setter),
                          std::forward<decltype(validator)>(validator))
     {
         // setup trivially-defined conversion function
-        AdcValueHolder::setupTrivialConvertFunc<arg_t<decltype(getter)>, std::tuple<Ts...>>(this);
+        AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>(this);
     }
 
 
     template <typename... Ts>
     AdcValueHolder(std::invocable<> auto&& getter,
-                   std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
+                   std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
                    const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
         : AdcValueHolder(std::forward<decltype(getter)>(getter),
                          std::forward<decltype(setter)>(setter),
@@ -247,10 +242,13 @@ public:
     }
 
 
-    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
-                                     std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
-                                     std::predicate<const arg_t<decltype(getter)>&> auto&& validator =
-                                         AdcValueHolder::AdcValueHolderDummyValidator<arg_t<decltype(getter)>>)
+    template <typename GT,
+              typename VALT = traits::adc_retval_t<GT>,
+              typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
+    AdcValueHolder& resetValueHolder(GT&& getter,
+                                     std::invocable<const VALT&> auto&& setter,
+                                     VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+        requires std::invocable<GT> && std::predicate<VT, const VALT&>
     {
         _convertFromInternal.clear();
         _convertToInternal.clear();
@@ -262,25 +260,17 @@ public:
     }
 
 
-    AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
-                                     std::invocable<const arg_t<decltype(getter)>&> auto&& setter)
-    {
-        return resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
-                                AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>);
-    }
-
-
     template <typename... Ts>
     AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
-                                     std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
-                                     std::predicate<const arg_t<decltype(getter)>&> auto&& validator,
+                                     std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
+                                     std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator,
                                      const std::tuple<Ts...>& /* tuple-of-trivially-converting-types */)
     {
         resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
                          std::forward<decltype(validator)>(validator));
 
         // setup trivially-defined conversion function
-        AdcValueHolder::setupTrivialConvertFunc<arg_t<decltype(getter)>, std::tuple<Ts...>>(this);
+        AdcValueHolder::setupTrivialConvertFunc<traits::adc_retval_t<decltype(getter)>, std::tuple<Ts...>>(this);
 
         return *this;
     }
@@ -288,7 +278,7 @@ public:
 
     template <typename... Ts>
     AdcValueHolder& resetValueHolder(std::invocable<> auto&& getter,
-                                     std::invocable<const arg_t<decltype(getter)>&> auto&& setter,
+                                     std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
                                      const std::tuple<Ts...>& t /* tuple-of-trivially-converting-types */)
     {
         return resetValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
@@ -423,28 +413,32 @@ protected:
 
  */
 
-AdcValueHolder make_arith_valueholder(std::invocable<> auto&& getter,
-                                      std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter,
-                                      std::predicate<const traits::adc_retval_t<decltype(getter)>&> auto&& validator)
+template <typename GT,
+          typename VALT = traits::adc_retval_t<GT>,
+          typename VT = decltype(AdcValueHolder::AdcValueHolderDummyValidator<VALT>)>
+AdcValueHolder make_arith_valueholder(GT&& getter,
+                                      std::invocable<const VALT&> auto&& setter,
+                                      VT&& validator = AdcValueHolder::AdcValueHolderDummyValidator<VALT>)
+    requires std::invocable<GT> && std::predicate<VT, const VALT&>
 {
-    using val_t = traits::adc_retval_t<decltype(getter)>;
+    using val_t = traits::adc_retval_t<GT>;
 
-    static_assert(std::predicate<decltype(validator), const traits::adc_retval_t<decltype(getter)>&>,
-                  "INVALID VALIDATOR TYPE!!!");
+    // static_assert(std::predicate<decltype(validator), const traits::adc_retval_t<decltype(getter)>&>,
+    //               "INVALID VALIDATOR TYPE!!!");
 
     static_assert(std::is_arithmetic_v<val_t>, "GETTER MUST RETURN AN ARITHMETIC TYPE VALUE!!!");
 
-    return AdcValueHolder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+    return AdcValueHolder(std::forward<GT>(getter), std::forward<decltype(setter)>(setter),
                           std::forward<decltype(validator)>(validator), AdcValueHolder::_defaultTrivialConvTypes);
 }
 
 
-AdcValueHolder make_arith_valueholder(std::invocable<> auto&& getter,
-                                      std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter)
-{
-    return make_arith_valueholder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
-                                  AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>);
-}
+// AdcValueHolder make_arith_valueholder(std::invocable<> auto&& getter,
+//                                       std::invocable<const traits::adc_retval_t<decltype(getter)>&> auto&& setter)
+// {
+//     return make_arith_valueholder(std::forward<decltype(getter)>(getter), std::forward<decltype(setter)>(setter),
+//                                   AdcValueHolder::AdcValueHolderDummyValidator<traits::adc_retval_t<decltype(getter)>>);
+// }
 
 
 }  // namespace adc
diff --git a/tests/adc_valueholder_test.cpp b/tests/adc_valueholder_test.cpp
index f65034d..24f6f50 100644
--- a/tests/adc_valueholder_test.cpp
+++ b/tests/adc_valueholder_test.cpp
@@ -18,7 +18,7 @@ TEST_CASE("[ADC VALUEHOLDER]")
             return true;
     };
 
-    // adc::AdcValueHolder vh(getter, setter, validator);
+    adc::AdcValueHolder vht(getter, setter, adc::AdcValueHolder::_defaultTrivialConvTypes);
     adc::AdcValueHolder vh(getter, setter, validator);
     auto vah = adc::make_arith_valueholder(getter, setter);