diff --git a/README.md b/README.md
index a311918..5bf9958 100755
--- a/README.md
+++ b/README.md
@@ -15,9 +15,9 @@
 + security - что-то типа защиты от чего-то
 + utils - вспомогательные решения для библиотеки
 
+- logger - реализация логирования
 - exception - универсальный класс обработки ошибок
 - iterators - набор разнообразных реализаций итераторов
-- logger - реализация логирования
 
 + - задукоментированно с коментариями и примерами
 - - доки в раборте, нужно делать и разбирать
diff --git a/bin/examples/concepts/main.cpp b/bin/examples/concepts/main.cpp
index 53a5f16..0d8d2b3 100644
--- a/bin/examples/concepts/main.cpp
+++ b/bin/examples/concepts/main.cpp
@@ -1,7 +1,7 @@
 #include "hack/concepts/concepts.hpp"
 #include "hack/logger/logger.hpp"
 
-template<hack::concepts::modern::has_value_type T>
+template<hack::concepts::has_value_type T>
 void example_has_value_type(const T& container) 
 {
   /*
@@ -16,37 +16,37 @@ void example_has_value_type(const T& container)
   hack::log()("Value type: ", typeid(typename T::value_type).name());
 }
 
-template<hack::concepts::modern::has_key_type T>
+template<hack::concepts::has_key_type T>
 void example_has_key_type(const T& container) 
 {
   hack::log()("Key type: ", typeid(typename T::key_type).name());
 }
 
-template<hack::concepts::modern::has_mapped_type T>
+template<hack::concepts::has_mapped_type T>
 void example_has_mapped_type(const T& container) 
 {
   hack::log()("Mapped type: ", typeid(typename T::mapped_type).name());
 }
 
-template<hack::concepts::modern::has_iterator T>
+template<hack::concepts::has_iterator T>
 void example_has_iterator(const T& container) 
 {
   hack::log()("Container is iterable, size: ", std::distance(container.begin(), container.end()));
 }
 
-template<hack::concepts::modern::has_size T>
+template<hack::concepts::has_size T>
 void example_has_size(const T& container) 
 {
   hack::log()("Container size:",  container.size());
 }
 
-template<hack::concepts::modern::has_key_compare T>
+template<hack::concepts::has_key_compare T>
 void example_has_key_compare(const T& container) 
 {
   hack::log()("Key compare type: ", typeid(typename T::key_compare).name());
 }
 
-template<hack::concepts::modern::has_allocator_type T>
+template<hack::concepts::has_allocator_type T>
 void example_has_allocator_type(const T& container) 
 {
   // Можно получить аллокатор из контейнера
@@ -54,77 +54,77 @@ void example_has_allocator_type(const T& container)
   hack::log()("Allocator obtained successfully");
 }
 
-template<hack::concepts::modern::is_string T>
+template<hack::concepts::is_string T>
 void example_is_string(const T& str) 
 {
   hack::log()("String content: ", str, " (length: ", str.length(), ")");
 }
 
-template<hack::concepts::modern::is_sequence_container T>
+template<hack::concepts::is_sequence_container T>
 void example_is_sequence_container(const T& container) 
 {
   hack::log()("Sequence container with ", container.size(), " elements");
 }
 
-template<hack::concepts::modern::is_random_access_container T>
+template<hack::concepts::is_random_access_container T>
 void example_is_random_access_container(T& container) 
 {
   if (!container.empty()) 
     hack::log()("First element: ", container[0]);
 }
 
-template<hack::concepts::modern::is_container_adapter T>
+template<hack::concepts::is_container_adapter T>
 void example_is_container_adapter(T& adapter) 
 {
   hack::log()("Container adapter with ", adapter.size(), " elements");
 }
 
-template<hack::concepts::modern::is_associative_container T>
+template<hack::concepts::is_associative_container T>
 void example_is_associative_container(const T& container) 
 {
   hack::log()("Associative container with ", container.size(), " elements");
 }
 
-template<hack::concepts::modern::is_unordered_associative_container T>
+template<hack::concepts::is_unordered_associative_container T>
 void example_is_unordered_associative_container(const T& container) 
 {
   hack::log()("Unordered associative container with ", container.size(), " elements");
 }
 
-template<hack::concepts::modern::is_tuple_like T>
+template<hack::concepts::is_tuple_like T>
 void example_is_tuple_like(const T& tuple) 
 {
   hack::log()("Tuple-like with ", std::tuple_size_v<T>, " elements");
 }
 
-template<hack::concepts::modern::is_fixed_array T>
+template<hack::concepts::is_fixed_array T>
 void example_is_fixed_array(const T& array) 
 {
   hack::log()("Fixed array with ", std::extent_v<T>, " elements");
 }
 
-template<hack::concepts::modern::is_std_array T>
+template<hack::concepts::is_std_array T>
 void example_is_std_array(const T& array) 
 {
   hack::log()("std::array with ", array.size(), " elements");
 }
 
-template<hack::concepts::modern::is_any_container T>
+template<hack::concepts::is_any_container T>
 void example_is_any_container(const T& container) 
 {
   hack::log()("Any container with ", container.size(), " elements");
 }
 
-template<hack::concepts::modern::is_iterable T>
+template<hack::concepts::is_iterable T>
 void example_is_iterable(const T& iterable) 
 {
   hack::log()("Iterable object");
 }
 
-template<hack::concepts::modern::is_sized T>
+template<hack::concepts::is_sized T>
 void example_is_sized(const T& sized) 
 {
-  if constexpr (hack::concepts::modern::has_size<T>) 
+  if constexpr (hack::concepts::has_size<T>) 
     hack::log()("Sized object: ", sized.size(), " elements");
   else 
     hack::log()("Sized object (compile-time size)"); 
@@ -133,29 +133,29 @@ void example_is_sized(const T& sized)
 template<typename T>
 void check_support(const T& value) 
 {
-  if constexpr (hack::concepts::modern::not_supported<T>) 
+  if constexpr (hack::concepts::not_supported<T>) 
     hack::log()("Type is NOT supported by this library");
   else
     hack::log()("Type is supported");
 }
 
-template<hack::concepts::modern::has_key_value_semantics T>
+template<hack::concepts::has_key_value_semantics T>
 void example_has_key_value_semantics(T& container) 
 {
-  if constexpr (hack::concepts::modern::has_mapped_type<T>) 
+  if constexpr (hack::concepts::has_mapped_type<T>) 
     hack::log()("Key-value container, sample access demonstrated");
   else 
     hack::log()("Set-like container");
 }
 
-template<hack::concepts::modern::is_contiguous_container T>
+template<hack::concepts::is_contiguous_container T>
 void example_is_contiguous_container(const T& container) 
 {
   hack::log()("Contiguous memory container");
 }
 
 template<typename Container, typename Value>
-requires hack::concepts::modern::can_push_front<Container, Value>
+requires hack::concepts::can_push_front<Container, Value>
 void example_can_push_front(Container& container, Value&& value)
 {
   container.push_front(std::forward<Value>(value));
@@ -163,7 +163,7 @@ void example_can_push_front(Container& container, Value&& value)
 }
 
 template<typename Container, typename Value>
-requires hack::concepts::modern::can_push_back<Container, Value>
+requires hack::concepts::can_push_back<Container, Value>
 void example_can_push_back(Container& container, Value&& value)
 {
   container.push_back(std::forward<Value>(value));
@@ -171,7 +171,7 @@ void example_can_push_back(Container& container, Value&& value)
 }
 
 template<typename Container, typename Key>
-requires hack::concepts::modern::can_find<Container, Key>
+requires hack::concepts::can_find<Container, Key>
 void example_can_find(Container& container, Key&& key)
 {
   auto it = container.find(std::forward<Key>(key));
diff --git a/bin/examples/logger/main.cpp b/bin/examples/logger/main.cpp
new file mode 100644
index 0000000..fec8100
--- /dev/null
+++ b/bin/examples/logger/main.cpp
@@ -0,0 +1,24 @@
+#include <vector>
+#include <map>
+#include "hack/logger/logger.hpp"
+
+auto main(int argc, char *argv[]) -> int
+{
+  std::string str = "hi";
+  int i = 1;
+  double d = 2.0;
+  float f = 3.f;
+  std::vector<std::string> vs = { "a", "b", "c" };
+  std::map<int, int> mi = { { 1, 1 }, { 2, 2 }, { 3, 3 } };
+
+  hack::log().set_devider(", ");
+  hack::log().no_func();
+  hack::log()(1, 2, 3.1f, 4.3, "asdf", "qwer", "xzcv");
+  hack::log().set_devider(" = ");
+  hack::log()(1, 2, 3.1f, 4.3, "asdf", "qwer", "xzcv");
+  hack::log().reset();
+  hack::log()(1, 2, 3.1f, 4.3, "asdf", "qwer", "xzcv");
+
+  return 0;
+}
+
diff --git a/bin/meson.build b/bin/meson.build
index 83df1e9..cf101b7 100755
--- a/bin/meson.build
+++ b/bin/meson.build
@@ -4,7 +4,8 @@ executable(
   # 'examples/concepts/main.cpp', 
   # 'examples/math/main.cpp', 
   # 'examples/range/main.cpp', 
-  'examples/patterns/main.cpp', 
+  # 'examples/patterns/main.cpp', 
+   'examples/logger/main.cpp', 
   dependencies : deps,
   cpp_args: args,
   include_directories : inc
diff --git a/src/hack/concepts/concepts.hpp b/src/hack/concepts/concepts.hpp
index 09701ab..f68d484 100755
--- a/src/hack/concepts/concepts.hpp
+++ b/src/hack/concepts/concepts.hpp
@@ -18,42 +18,7 @@
 #include <utility>
 #include <concepts>
 
-// HERE
-// Это старая версия. Перед удалением нужнопроверить ее работу по сравнению с работой новой версии
 namespace hack::concepts
-{
-  template<typename T>
-  concept is_map = std::same_as<T, std::map<typename T::key_type, typename T::mapped_type, typename T::key_compare, typename T::allocator_type>> ||
-                   std::same_as<T, std::unordered_map<typename T::key_type, typename T::mapped_type, typename T::hasher, typename T::key_equal, typename T::allocator_type>>;
-
-  template<typename T>
-  concept is_tuple = requires (T t) { std::tuple_cat(t, std::make_tuple(1, "tuple")); };
-
-  template<typename T>
-  concept is_set = std::same_as<T, std::set<typename T::key_type, typename T::key_compare, typename T::allocator_type>>;
-
-  template<typename T>
-  concept is_unordered_set = std::same_as<T, std::unordered_set<typename T::key_type>>;
-
-  template<typename T>
-  concept is_forward_list = std::same_as<T, std::forward_list<typename T::value_type>>;
-
-  template<typename T>
-  concept is_string = std::is_convertible_v<T, std::string_view>;
-
-  template<typename T, std::size_t N = 0>
-  concept is_sequence_container = std::same_as<T, std::vector<typename T::value_type>> || std::same_as<T, std::list<typename T::value_type>> || (std::is_array_v<T> && N > 0);
-
-  template<typename T>
-  concept is_associative_container = is_map<T> || is_tuple<T> || is_set<T> || is_unordered_set<T>;
-
-
-  template<typename T>
-  concept not_defined = !std::enable_if_t<!(std::integral<T> || is_sequence_container<T> || is_map<T> || is_tuple<T> || is_set<T> || is_unordered_set<T> || 
-                        is_forward_list<T> || std::is_array<T>() || is_string<T>), bool>() ==  true;
-}
-
-namespace hack::concepts::modern
 {
   // Базовые концепты для обнаружения характеристик типов.
   // Эти концепты являются строительными блоками для более сложных проверок.
@@ -302,4 +267,16 @@ namespace hack::concepts::modern
   // Ключевой концепт для алгоритмов поиска и проверки существования элементов
   template<typename Container, typename Key>
   concept can_find = requires(Container c, Key&& key) { c.find(std::forward<Key>(key)); };
+
+
+  // @brief Проверяет, является ли данное числом
+  // @details Проверяет на основные операции
+  template<typename T>
+  concept is_number = requires(T value) {
+    requires std::is_arithmetic_v<T>; // Включает все арифметические типы
+    value + value; // Проверяет арифметические операции
+    value - value;
+    value * value;
+    value / value;
+  };
 }
diff --git a/src/hack/logger/logger.OLD.hpp b/src/hack/logger/logger.OLD.hpp
new file mode 100755
index 0000000..5e95695
--- /dev/null
+++ b/src/hack/logger/logger.OLD.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <experimental/source_location>
+#include <string>
+
+#include "hack/utils/color.hpp"
+#include "hack/concepts/concepts.hpp"
+#include "hack/iterators/sequence_ostream_iterator.hpp"
+#include "hack/iterators/associative_ostream_iterator.hpp"
+
+#include "hack/patterns/ring_buffer.hpp"
+
+// HERE
+// и нужно сделать реализацию где выводлится все в одной линии но при помощи цикла
+// типа такого:
+// for (auto i : range) hack::log(hack::log::line)(i);
+namespace hack
+{
+  class log
+  {
+    public:
+      log(std::string devider_ = " ", std::experimental::source_location location_ = std::experimental::source_location::current()) : location { location_ }
+      {
+        this->devider = devider_;
+      }
+
+      log(log&) = delete;
+      log(log&&) = delete;
+
+    public:
+      template<typename... Args>
+      void operator() (const Args&... args)
+      {
+        count = sizeof...(Args);
+        prepare(make_type_view, location);
+        print(args...);
+      }
+
+    private:
+      std::experimental::source_location location;
+      inline static int count = 0;
+      inline static std::string devider = " ";
+
+    private:
+      template<typename T, typename U>
+      void prepare(T t, U u)
+      {
+        std::cout << t
+                  << u.file_name() << ":" << utils::color::reset 
+                  << utils::color::italic << utils::color::yellow << u.function_name() << "()" << utils::color::reset
+                  << utils::color::bold << utils::color::blue << "[" << u.line() << "]" << utils::color::reset << ": ";
+      }
+
+      static void print() { std::cout << std::endl; }
+
+      static std::ostream& make_type_view(std::ostream &os)
+      {
+        os << utils::color::bold << utils::color::green << "[ok]" << utils::color::reset << utils::color::green;
+        return os;
+      }
+
+      template<typename T, typename... Args>
+      static void print(const T& data, const Args&... args)
+      {
+        --count;
+        print_t(data);
+        print(args...);
+      }
+
+      template<concepts::is_string T>
+      static void print_t(const T& data)
+      {
+        std::cout << data << (count != 0 ? devider : "");
+      }
+
+      template<std::integral T>
+      static void print_t(const T& data)
+      {
+        std::cout << data << (count != 0 ? devider : "");
+      }
+
+      template<concepts::is_sequence_container T>
+      static void print_t(const T& data)
+      {
+        std::cout << "{ ";
+        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
+        std::cout << " }" << (count != 0 ? devider : "");
+      }
+
+      // HERE
+      // реализовать это с учетом новых концептов
+      template<concepts::is_set T>
+      static void print_t(const T& data)
+      {
+        std::cout << "{ ";
+        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
+        std::cout << " }" << (count != 0 ? devider : "");
+      }
+
+      template<concepts::is_unordered_set T>
+      static void print_t(const T& data)
+      {
+        std::cout << "{ ";
+        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
+        std::cout << " }" << (count != 0 ? devider : "");
+      }
+
+      template<concepts::is_forward_list T>
+      static void print_t(const T& data)
+      {
+        std::cout << "{ ";
+        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(std::distance(data.cbegin(), data.cend()), std::cout));
+        std::cout << " }" << (count != 0 ? devider : "");
+      }
+
+      template<concepts::is_map T>
+      static void print_t(const T& data)
+      {
+        std::cout << "{";
+        std::copy(data.begin(), data.cend(), iterators::associative_ostream_iterator<typename T::value_type>(data.size(), std::cout));
+        std::cout << "}" << (count != 0 ? devider : "");
+      }
+
+      template<concepts::is_tuple T, typename std::size_t... idx>
+      static void print_t(const T& data)
+      {
+        print_t(data, std::make_index_sequence<std::tuple_size<T>::value>{});
+      }
+
+      template<concepts::not_defined T>
+      static void print_t(const T& data)
+      {
+        std::cout << data << (count != 0 ? devider : "");
+      }
+
+      template<typename T, typename std::size_t... idx>
+      static void print_t(const T& data, std::index_sequence<idx...>)
+      {
+        std::cout << "{ ";
+        ((std::cout << std::get<idx>(data) << (idx != std::tuple_size<T>::value - 1 ? devider : "")), ...);
+        std::cout << " }" << (count != 0 ? devider : "");
+      }
+
+      template<typename T>
+      static void print_t(const hack::patterns::ring_buffer<T>& rb)
+      {
+        print_t(rb.get_src());
+      }
+
+      friend class warn;
+      friend class error;
+  };
+
+  class warn : public log
+  {
+    public:
+      warn(std::string devider_ = " ", std::experimental::source_location location_ = std::experimental::source_location::current()) : location { location_ }
+      {
+        this->devider = devider_;
+      }
+
+      warn(warn&) = delete;
+      warn(warn&&) = delete;
+
+    public:
+      template<typename... Args>
+      void operator() (const Args&... args)
+      {
+        prepare(make_type_view, location);
+        count = sizeof...(Args);
+        print(args...);
+      }
+
+    private:
+      std::experimental::source_location location;
+
+    private:
+      static std::ostream& make_type_view(std::ostream &os)
+      {
+        os << utils::color::bold << utils::color::yellow << "[WARN]" << utils::color::reset << utils::color::yellow;
+        return os;
+      }
+  };
+
+  class error : public log
+  {
+    public:
+      error(std::string devider_ = " ", std::experimental::source_location location_ = std::experimental::source_location::current()) : location { location_ }
+      {
+        this->devider = devider_;
+      }
+      error(error&) = delete;
+      error(error&&) = delete;
+
+    public:
+      template<typename... Args>
+      void operator() (const Args&... args)
+      {
+        prepare(make_type_view, location);
+        count = sizeof...(Args);
+        print(args...);
+      }
+
+    private:
+      std::experimental::source_location location;
+
+    private:
+      static std::ostream& make_type_view(std::ostream &os)
+      {
+        os << utils::color::bold <<  utils::color::red << "[ERROR]" << utils::color::reset << utils::color::red;
+        return os;
+      }
+  };
+}
diff --git a/src/hack/logger/logger.hpp b/src/hack/logger/logger.hpp
index 2792d32..c4b30a0 100755
--- a/src/hack/logger/logger.hpp
+++ b/src/hack/logger/logger.hpp
@@ -1,14 +1,15 @@
 #pragma once
 
-#include <experimental/source_location>
+#include <source_location> // C++20
 #include <string>
-
+#include <sstream>
 #include "hack/utils/color.hpp"
+#include "hack/patterns/singleton.hpp"
 #include "hack/concepts/concepts.hpp"
-#include "hack/iterators/sequence_ostream_iterator.hpp"
-#include "hack/iterators/associative_ostream_iterator.hpp"
 
-#include "hack/patterns/ring_buffer.hpp"
+#include <execinfo.h>
+#include <iostream>
+#include <cxxabi.h>
 
 // HERE
 // и нужно сделать реализацию где выводлится все в одной линии но при помощи цикла
@@ -16,197 +17,81 @@
 // for (auto i : range) hack::log(hack::log::line)(i);
 namespace hack
 {
-  class log
+  class logger : public hack::patterns::singleton<logger>
   {
     public:
-      log(std::string devider_ = " ", std::experimental::source_location location_ = std::experimental::source_location::current()) : location { location_ }
-      {
-        this->devider = devider_;
+      void set_location(std::source_location location) { m_location = location; }
+      void set_devider(std::string devider) { m_devider = devider; }
+      void no_func() { m_no_func = true; };
+      void reset() 
+      { 
+        m_no_func = m_base_config.m_no_func; 
+        m_devider = m_base_config.m_devider;
       }
 
-      log(log&) = delete;
-      log(log&&) = delete;
-
-    public:
       template<typename... Args>
       void operator() (const Args&... args)
       {
-        count = sizeof...(Args);
-        prepare(make_type_view, location);
-        print(args...);
+        m_count = sizeof...(Args);
+        prepare();
+        print_impl(args...);
       }
 
     private:
-      std::experimental::source_location location;
-      inline static int count = 0;
-      inline static std::string devider = " ";
+      struct config
+      {
+        bool m_no_func = false;
+        std::string m_devider = " ";
+      } m_base_config;
 
     private:
-      template<typename T, typename U>
-      void prepare(T t, U u)
+      void prepare()
       {
-        std::cout << t
-                  << u.file_name() << ":" << utils::color::reset 
-                  << utils::color::italic << utils::color::yellow << u.function_name() << "()" << utils::color::reset
-                  << utils::color::bold << utils::color::blue << "[" << u.line() << "]" << utils::color::reset << ": ";
-      }
+        std::stringstream ss;
+        ss << utils::color::bold << utils::color::green << "[ok]" << utils::color::reset << utils::color::green
+           << m_location.file_name() << ":" << utils::color::reset;
 
-      static void print() { std::cout << std::endl; }
+        if (!m_no_func)
+          ss << utils::color::italic << utils::color::yellow << m_location.function_name() << utils::color::reset;
 
-      static std::ostream& make_type_view(std::ostream &os)
-      {
-        os << utils::color::bold << utils::color::green << "[ok]" << utils::color::reset << utils::color::green;
-        return os;
+        ss << utils::color::bold << utils::color::blue << "[" << m_location.line() << "]" << utils::color::reset << ": ";
+        std::cout << ss.str();
       }
 
       template<typename T, typename... Args>
-      static void print(const T& data, const Args&... args)
+      void print_impl(const T& data, const Args&... args)
       {
-        --count;
-        print_t(data);
-        print(args...);
+        --m_count;
+        pring_first(data);
+        print_impl(args...);
       }
 
-      template<concepts::is_string T>
-      static void print_t(const T& data)
-      {
-        std::cout << data << (count != 0 ? devider : "");
-      }
+      void print_impl() { std::cout << std::endl; }
 
-      template<std::integral T>
-      static void print_t(const T& data)
+      template<typename T>
+      requires concepts::is_string<T>
+      void pring_first(const T& data)
       {
-        std::cout << data << (count != 0 ? devider : "");
-      }
-
-      template<concepts::is_sequence_container T>
-      static void print_t(const T& data)
-      {
-        std::cout << "{ ";
-        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
-        std::cout << " }" << (count != 0 ? devider : "");
-      }
-
-      template<concepts::is_set T>
-      static void print_t(const T& data)
-      {
-        std::cout << "{ ";
-        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
-        std::cout << " }" << (count != 0 ? devider : "");
-      }
-
-      template<concepts::is_unordered_set T>
-      static void print_t(const T& data)
-      {
-        std::cout << "{ ";
-        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(data.size(), std::cout));
-        std::cout << " }" << (count != 0 ? devider : "");
-      }
-
-      template<concepts::is_forward_list T>
-      static void print_t(const T& data)
-      {
-        std::cout << "{ ";
-        std::copy(data.cbegin(), data.cend(), iterators::sequence_ostream_iterator<typename T::value_type>(std::distance(data.cbegin(), data.cend()), std::cout));
-        std::cout << " }" << (count != 0 ? devider : "");
-      }
-      
-      template<concepts::is_map T>
-      static void print_t(const T& data)
-      {
-        std::cout << "{";
-        std::copy(data.begin(), data.cend(), iterators::associative_ostream_iterator<typename T::value_type>(data.size(), std::cout));
-        std::cout << "}" << (count != 0 ? devider : "");
-      }
-
-      template<concepts::is_tuple T, typename std::size_t... idx>
-      static void print_t(const T& data)
-      {
-        print_t(data, std::make_index_sequence<std::tuple_size<T>::value>{});
-      }
-
-      template<typename T, typename std::size_t... idx>
-      static void print_t(const T& data, std::index_sequence<idx...>)
-      {
-        std::cout << "{ ";
-        ((std::cout << std::get<idx>(data) << (idx != std::tuple_size<T>::value - 1 ? devider : "")), ...);
-        std::cout << " }" << (count != 0 ? devider : "");
-      }
-
-      template<concepts::not_defined T>
-      static void print_t(const T& data)
-      {
-        std::cout << data << (count != 0 ? devider : "");
+        std::cout << data << (m_count != 0 ? m_devider : "");
       }
 
       template<typename T>
-      static void print_t(const hack::patterns::ring_buffer<T>& rb)
+      requires concepts::is_number<T>
+      void pring_first(const T& data)
       {
-        print_t(rb.get_src());
+        std::cout << data << (m_count != 0 ? m_devider : "");
       }
 
-      friend class warn;
-      friend class error;
+    private:
+      std::source_location m_location;
+      std::size_t m_count = 0;
+      std::string m_devider = m_base_config.m_devider;
+      bool m_no_func = m_base_config.m_no_func;
   };
 
-  class warn : public log
+  inline logger& log(std::source_location location = std::source_location::current())
   {
-    public:
-      warn(std::string devider_ = " ", std::experimental::source_location location_ = std::experimental::source_location::current()) : location { location_ }
-      {
-        this->devider = devider_;
-      }
-
-      warn(warn&) = delete;
-      warn(warn&&) = delete;
-
-    public:
-      template<typename... Args>
-      void operator() (const Args&... args)
-      {
-        prepare(make_type_view, location);
-        count = sizeof...(Args);
-        print(args...);
-      }
-
-    private:
-      std::experimental::source_location location;
-
-    private:
-      static std::ostream& make_type_view(std::ostream &os)
-      {
-        os << utils::color::bold << utils::color::yellow << "[WARN]" << utils::color::reset << utils::color::yellow;
-        return os;
-      }
-  };
-
-  class error : public log
-  {
-    public:
-      error(std::string devider_ = " ", std::experimental::source_location location_ = std::experimental::source_location::current()) : location { location_ }
-      {
-        this->devider = devider_;
-      }
-      error(error&) = delete;
-      error(error&&) = delete;
-
-    public:
-      template<typename... Args>
-      void operator() (const Args&... args)
-      {
-        prepare(make_type_view, location);
-        count = sizeof...(Args);
-        print(args...);
-      }
-
-    private:
-      std::experimental::source_location location;
-
-    private:
-      static std::ostream& make_type_view(std::ostream &os)
-      {
-        os << utils::color::bold <<  utils::color::red << "[ERROR]" << utils::color::reset << utils::color::red;
-        return os;
-      }
-  };
+    logger::instance().set_location(location);
+    return logger::instance();
+  }
 }