diff --git a/CMakeLists.txt b/CMakeLists.txt
index 49cbdb2..c25a988 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -39,7 +39,7 @@ if(BUILD_TESTS)
 	add_subdirectory(tests)
 endif()
 
-set(LIBREXY_PUBLIC_HEADERS "include/rexy/rexy.hpp" "include/rexy/algorithm.hpp" "include/rexy/utility.hpp" "include/rexy/basic_string_hash.hpp" "include/rexy/hash.hpp" "include/rexy/static_string_hash.hpp" "include/rexy/string_hash.hpp" "include/rexy/mpmc_queue.hpp" "include/rexy/mpmc_queue.tpp" "include/rexy/traits.hpp" "include/rexy/steal.hpp" "include/rexy/binary.hpp" "include/rexy/expression.hpp" "include/rexy/binary_base.hpp" "include/rexy/binary_base.tpp" "include/rexy/string_base.hpp" "include/rexy/string.hpp" "include/rexy/filerd.hpp" "include/rexy/string_base.tpp" "include/rexy/allocator.hpp" "include/rexy/meta.hpp" "include/rexy/buffer.hpp" "include/rexy/buffer.tpp" "include/rexy/debug_print.hpp" "include/rexy/deferred.hpp" "include/rexy/demangle.hpp" "include/rexy/enum_traits.hpp" "include/rexy/source_location.hpp" "include/rexy/storage_for.hpp" "include/rexy/storage_for.tpp")
+set(LIBREXY_PUBLIC_HEADERS "include/rexy/rexy.hpp" "include/rexy/algorithm.hpp" "include/rexy/utility.hpp" "include/rexy/basic_string_hash.hpp" "include/rexy/hash.hpp" "include/rexy/static_string_hash.hpp" "include/rexy/string_hash.hpp" "include/rexy/mpmc_queue.hpp" "include/rexy/mpmc_queue.tpp" "include/rexy/traits.hpp" "include/rexy/steal.hpp" "include/rexy/binary.hpp" "include/rexy/expression.hpp" "include/rexy/binary_base.hpp" "include/rexy/binary_base.tpp" "include/rexy/string_base.hpp" "include/rexy/string.hpp" "include/rexy/filerd.hpp" "include/rexy/string_base.tpp" "include/rexy/allocator.hpp" "include/rexy/meta.hpp" "include/rexy/buffer.hpp" "include/rexy/buffer.tpp" "include/rexy/debug_print.hpp" "include/rexy/deferred.hpp" "include/rexy/demangle.hpp" "include/rexy/enum_traits.hpp" "include/rexy/storage_for.hpp" "include/rexy/storage_for.tpp" "include/rexy/visitor.hpp")
 target_compile_options(rexy PRIVATE -Wall -Wextra -pedantic -std=c++20)
 
 install(TARGETS rexy
@@ -52,6 +52,7 @@ install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/pc/librexy.pc"
 install(FILES ${LIBREXY_PUBLIC_HEADERS} DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/rexy/")
 install(DIRECTORY "include/rexy/detail" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/rexy" FILES_MATCHING PATTERN "*.hpp" PATTERN "*.tpp")
 install(DIRECTORY "include/rexy/cx" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/rexy" FILES_MATCHING PATTERN "*.hpp" PATTERN "*.tpp")
+install(DIRECTORY "include/rexy/compat" DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}/rexy" FILES_MATCHING PATTERN "*.hpp" PATTERN "*.tpp")
 
 configure_file(
 	"${CMAKE_CURRENT_SOURCE_DIR}/pc/librexy.pc.cmake.in"
diff --git a/include/rexy/source_location.hpp b/include/rexy/compat/source_location.hpp
similarity index 98%
rename from include/rexy/source_location.hpp
rename to include/rexy/compat/source_location.hpp
index ca992fa..ec48ac5 100644
--- a/include/rexy/source_location.hpp
+++ b/include/rexy/compat/source_location.hpp
@@ -32,7 +32,7 @@
 	#define CONSTEVAL constexpr
 #endif
 
-namespace rexy{
+namespace rexy::compat{
 
 	class source_location
 	{
@@ -111,7 +111,7 @@ namespace rexy{
 
 #include <source_location>
 
-namespace rexy{
+namespace rexy::compat{
 
 	using source_location = std::source_location;
 
diff --git a/include/rexy/compat/to_address.hpp b/include/rexy/compat/to_address.hpp
new file mode 100644
index 0000000..19d3428
--- /dev/null
+++ b/include/rexy/compat/to_address.hpp
@@ -0,0 +1,50 @@
+/**
+	This file is a part of rexy's general purpose library
+	Copyright (C) 2022 rexy712
+
+	This program is free software: you can redistribute it and/or modify
+	it under the terms of the GNU General Public License as published by
+	the Free Software Foundation, either version 3 of the License, or
+	(at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+	GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef REXY_COMPAT_TO_ADDRESS_HPP
+#define REXY_COMPAT_TO_ADDRESS_HPP
+
+#if __cplusplus >= 202002L
+	#include <memory> //to_address
+#endif
+
+
+namespace rexy::compat{
+#if __cplusplus >= 202002L
+	template<class T>
+	constexpr T* to_address(T* p)noexcept{
+		return std::to_address(p);
+	}
+	template<class Ptr>
+	constexpr auto to_address(const Ptr& p)noexcept{
+		return std::to_address(p);
+	}
+#else
+	template<class T>
+	constexpr T* to_address(T* p)noexcept{
+		return p;
+	}
+	template<class Ptr>
+	constexpr auto to_address(const Ptr& p)noexcept{
+		return to_address(p.operator->());
+	}
+#endif
+
+}
+
+#endif
diff --git a/include/rexy/cx/string.hpp b/include/rexy/cx/string.hpp
index 2aeccd7..f0156d1 100644
--- a/include/rexy/cx/string.hpp
+++ b/include/rexy/cx/string.hpp
@@ -83,7 +83,7 @@ namespace rexy::cx{
 			}
 		}
 
-		constexpr string(const rexy::string_view<value_type>& str)noexcept:
+		constexpr string(const rexy::basic_string_view<value_type>& str)noexcept:
 			m_length(str.length())
 		{
 			for(size_type i = 0;i < m_length;++i){
@@ -167,7 +167,7 @@ namespace rexy::cx{
 		constexpr void append(const string& s)noexcept{
 			append(s.get(), s.length());
 		}
-		constexpr void append(const rexy::string_view<value_type>& s)noexcept{
+		constexpr void append(const rexy::basic_string_view<value_type>& s)noexcept{
 			append(s.get(), s.length());
 		}
 	};
@@ -193,11 +193,11 @@ namespace rexy::cx{
 	}
 	template<class Str1, std::enable_if_t<detail::is_cx_string<Str1>::value,int> = 0>
 	constexpr auto operator+(Str1&& l, const char* r)noexcept{
-		return string_cat_expr(std::forward<Str1>(l), rexy::string_view<char>(r));
+		return string_cat_expr(std::forward<Str1>(l), rexy::basic_string_view<char>(r));
 	}
 	template<class Str1, std::enable_if_t<detail::is_cx_string<Str1>::value,int> = 0>
 	constexpr auto operator+(const char* l, Str1&& r)noexcept{
-		return string_cat_expr(rexy::string_view<char>(l), std::forward<Str1>(r));
+		return string_cat_expr(rexy::basic_string_view<char>(l), std::forward<Str1>(r));
 	}
 }
 
diff --git a/include/rexy/debug_print.hpp b/include/rexy/debug_print.hpp
index c526224..a4028ab 100644
--- a/include/rexy/debug_print.hpp
+++ b/include/rexy/debug_print.hpp
@@ -40,7 +40,7 @@
 	#include <cstdio> //fprintf, vfprintf
 	#include <utility> //forward
 
-	#include "source_location.hpp"
+	#include "compat/source_location.hpp"
 
 
 	namespace rexy::debug{
@@ -53,7 +53,7 @@
 		}
 		template<class... Args>
 		struct print{
-			explicit print(Args&&... args, const rexy::source_location& loc = rexy::source_location::current()){
+			explicit print(Args&&... args, const rexy::compat::source_location& loc = rexy::compat::source_location::current()){
 				std::fprintf(stderr, "%s:%s:%d: ", loc.file_name(), loc.function_name(), loc.line());
 				std::fprintf(stderr, std::forward<Args>(args)...);
 			}
@@ -67,7 +67,7 @@
 		#ifdef REXY_ENABLE_COLOR_DEBUG
 			template<class... Args>
 			struct print_succ{
-				explicit print_succ(Args&&... args, const rexy::source_location& loc = rexy::source_location::current()){
+				explicit print_succ(Args&&... args, const rexy::compat::source_location& loc = rexy::compat::source_location::current()){
 					std::fprintf(stderr, "%s", detail::color_green);
 					std::fprintf(stderr, "%s:%s:%d: ", loc.file_name(), loc.function_name(), loc.line());
 					std::fprintf(stderr, std::forward<Args>(args)...);
@@ -80,7 +80,7 @@
 			};
 			template<class... Args>
 			struct print_info{
-				explicit print_info(Args&&... args, const rexy::source_location& loc = rexy::source_location::current()){
+				explicit print_info(Args&&... args, const rexy::compat::source_location& loc = rexy::compat::source_location::current()){
 					std::fprintf(stderr, "%s", detail::color_blue);
 					std::fprintf(stderr, "%s:%s:%d: ", loc.file_name(), loc.function_name(), loc.line());
 					std::fprintf(stderr, std::forward<Args>(args)...);
@@ -93,7 +93,7 @@
 			};
 			template<class... Args>
 			struct print_warn{
-				explicit print_warn(Args&&... args, const rexy::source_location& loc = rexy::source_location::current()){
+				explicit print_warn(Args&&... args, const rexy::compat::source_location& loc = rexy::compat::source_location::current()){
 					std::fprintf(stderr, "%s", detail::color_yellow);
 					std::fprintf(stderr, "%s:%s:%d: ", loc.file_name(), loc.function_name(), loc.line());
 					std::fprintf(stderr, std::forward<Args>(args)...);
@@ -106,7 +106,7 @@
 			};
 			template<class... Args>
 			struct print_error{
-				explicit print_error(Args&&... args, const rexy::source_location& loc = rexy::source_location::current()){
+				explicit print_error(Args&&... args, const rexy::compat::source_location& loc = rexy::compat::source_location::current()){
 					std::fprintf(stderr, "%s", detail::color_red);
 					std::fprintf(stderr, "%s:%s:%d: ", loc.file_name(), loc.function_name(), loc.line());
 					std::fprintf(stderr, std::forward<Args>(args)...);
diff --git a/include/rexy/detail/binary_string_conv.hpp b/include/rexy/detail/binary_string_conv.hpp
index ed09f47..3d966f1 100644
--- a/include/rexy/detail/binary_string_conv.hpp
+++ b/include/rexy/detail/binary_string_conv.hpp
@@ -24,7 +24,7 @@
 #include <cstring> //memcpy
 
 namespace rexy{
-	template<class Str, detail::enable_if_concrete_string<Str> = 0>
+	template<class Str, std::enable_if_t<is_string_v<Str>,int> = 0>
 	auto binary_to_string(const binary_base& b)
 		noexcept(std::is_nothrow_constructible<Str, decltype(b.size())>::value)
 	{
@@ -32,7 +32,7 @@ namespace rexy{
 		s.append(b.get(), b.size());
 		return s;
 	}
-	template<class Al, class Str, detail::enable_if_concrete_string<Str> = 0, std::enable_if_t<std::is_same<std::decay_t<Al>,typename Str::allocator_type>::value,int> = 0>
+	template<class Al, class Str, std::enable_if_t<is_string_v<Str>,int> = 0, std::enable_if_t<std::is_same<std::decay_t<Al>,typename Str::allocator_type>::value,int> = 0>
 	auto binary_to_string(basic_binary<Al>&& b)noexcept{
 		return Str(rexy::steal(b.release()), b.size());
 	}
diff --git a/include/rexy/static_string_hash.hpp b/include/rexy/static_string_hash.hpp
index 2e1a19c..79b3404 100644
--- a/include/rexy/static_string_hash.hpp
+++ b/include/rexy/static_string_hash.hpp
@@ -26,7 +26,7 @@
 namespace rexy{
 
 	template<class Char>
-	struct hash<rexy::string_view<Char>> : public string_hash<rexy::string_view<Char>>{};
+	struct hash<rexy::basic_string_view<Char>> : public string_hash<rexy::basic_string_view<Char>>{};
 
 }
 
diff --git a/include/rexy/steal.hpp b/include/rexy/steal.hpp
index f5abdbc..3dba273 100644
--- a/include/rexy/steal.hpp
+++ b/include/rexy/steal.hpp
@@ -34,7 +34,7 @@ namespace rexy{
 
 	public:
 		template<class U>
-		constexpr steal(U&& u)
+		constexpr explicit steal(U&& u)
 			noexcept(std::is_nothrow_constructible<T,U&&>::value):
 			m_val(std::forward<U>(u)){}
 
diff --git a/include/rexy/string.hpp b/include/rexy/string.hpp
index b2cd045..2bf3a10 100644
--- a/include/rexy/string.hpp
+++ b/include/rexy/string.hpp
@@ -33,6 +33,14 @@ namespace rexy{
 	extern template class basic_string<char16_t,allocator<char16_t>>;
 	extern template class basic_string<char32_t,allocator<char32_t>>;
 
+
+	using string_view = basic_string_view<char>;
+
+	extern template class basic_string_view<char>;
+	extern template class basic_string_view<wchar_t>;
+	extern template class basic_string_view<char16_t>;
+	extern template class basic_string_view<char32_t>;
+
 }
 
 #ifdef REXY_CX_HASH_HPP
diff --git a/include/rexy/string_base.hpp b/include/rexy/string_base.hpp
index b2bfbe3..54feaf7 100644
--- a/include/rexy/string_base.hpp
+++ b/include/rexy/string_base.hpp
@@ -37,8 +37,90 @@
 
 #include "detail/cpp20.hpp"
 
+#if __cplusplus >= 202002L
+	#include <concepts>
+#endif
+
 namespace rexy{
 
+	template<class Char>
+	class string_base;
+
+	template<class Char>
+	class basic_string_view
+	{
+	public:
+		using value_type = Char;
+		using size_type = size_t;
+		using difference_type = ptrdiff_t;
+		using pointer = value_type*;
+		using const_pointer = const value_type*;
+		using reference = value_type&;
+		using const_reference = const value_type&;
+		using iterator = pointer;
+		using const_iterator = const_pointer;
+		using reverse_iterator = std::reverse_iterator<iterator>;
+		using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+	private:
+		const_pointer m_data = nullptr;
+		size_type m_length = 0;
+
+	public:
+		constexpr basic_string_view(void)noexcept;
+		constexpr basic_string_view(const_pointer str, size_type len)noexcept;
+		constexpr basic_string_view(const_pointer c)noexcept;
+		constexpr basic_string_view(const basic_string_view& s)noexcept;
+		constexpr basic_string_view(const string_base<Char>& s)noexcept;
+		constexpr basic_string_view(basic_string_view&& s)noexcept;
+		template<class InIter>
+		constexpr basic_string_view(InIter start, InIter fin)noexcept;
+		REXY_CPP20_CONSTEXPR ~basic_string_view(void)noexcept = default;
+
+		constexpr basic_string_view& operator=(const_pointer c)noexcept;
+		constexpr basic_string_view& operator=(const basic_string_view& s)noexcept;
+		constexpr basic_string_view& operator=(basic_string_view&&)noexcept;
+
+
+		//Length of string not including null terminator
+		constexpr size_type length(void)const noexcept{return m_length;}
+		//direct access to managed pointer
+		constexpr const_pointer c_str(void)const noexcept{return m_data;}
+		constexpr const_pointer get(void)const noexcept{return m_data;}
+		constexpr operator const_pointer(void)const noexcept{return m_data;}
+		//true if m_data is not empty
+		constexpr bool valid(void)const noexcept{return m_length > 0;}
+
+		constexpr const_reference operator[](size_type i)const noexcept{return m_data[i];}
+
+		constexpr const_iterator search(const basic_string_view& s)const;
+		constexpr const_iterator search(const_pointer c)const;
+		template<class Searcher>
+		constexpr const_iterator search(const basic_string_view& s, const Searcher& searcher)const;
+		template<class Searcher>
+		constexpr const_iterator search(const_pointer c, const Searcher& searcher)const;
+		constexpr bool compare(const basic_string_view& s)const{return *this == s;}
+		constexpr bool compare(const_pointer c)const{return *this == c;}
+
+		constexpr const_iterator begin(void)const{return m_data;}
+		constexpr const_iterator end(void)const{return m_data+m_length;}
+		constexpr const_iterator cbegin(void)const{return begin();}
+		constexpr const_iterator cend(void)const{return end();}
+
+		constexpr const_reverse_iterator rbegin(void)const{return const_reverse_iterator(m_data+m_length);}
+		constexpr const_reverse_iterator rend(void)const{return const_reverse_iterator(m_data-1);}
+		constexpr const_reverse_iterator crbegin(void)const{return rbegin();}
+		constexpr const_reverse_iterator crend(void)const{return rend();}
+	};
+
+	template<class T>
+	basic_string_view(const T*) -> basic_string_view<T>;
+	template<class T>
+	basic_string_view(const T*, size_t) -> basic_string_view<T>;
+
+	template<class T>
+	using static_string [[deprecated]] = basic_string_view<T>;
+
 	//Base of all RAII strings. Its use is allowing passing of rexy strings to functions without knowing the exact type
 	template<class Char>
 	class string_base
@@ -274,6 +356,7 @@ namespace rexy{
 		REXY_CPP20_CONSTEXPR basic_string(size_type len, size_type cap)noexcept(noexcept(this->allocate(0)));
 		template<class InputIt>
 		REXY_CPP20_CONSTEXPR basic_string(InputIt start, InputIt fin)noexcept(noexcept(this->allocate(0)));
+		REXY_CPP20_CONSTEXPR basic_string(const basic_string_view<Char>& sv)noexcept(noexcept(this->allocate(0)));
 		//normal copy and move ctors
 		REXY_CPP20_CONSTEXPR basic_string(const basic_string& b)noexcept(noexcept(this->allocate(0)));
 		constexpr basic_string(basic_string&& s)noexcept;
@@ -291,6 +374,9 @@ namespace rexy{
 		REXY_CPP20_CONSTEXPR basic_string& operator=(const string_base<Char>& s)
 			noexcept(noexcept(this->allocate(0)) &&
 			         noexcept(this->deallocate(nullptr,0)));
+		REXY_CPP20_CONSTEXPR basic_string& operator=(const basic_string_view<Char>& sv)
+			noexcept(noexcept(this->allocate(0)) &&
+			         noexcept(this->deallocate(nullptr,0)));
 		//Copy from c string
 		REXY_CPP20_CONSTEXPR basic_string& operator=(const_pointer c)
 			noexcept(noexcept(this->allocate(0)) &&
@@ -355,146 +441,249 @@ namespace rexy{
 	template<class Left, class Right>
 	string_cat_expr(Left&&,Right&&) -> string_cat_expr<Left&&,Right&&>;
 
-	template<class Char>
-	class string_view : public string_base<Char>
-	{
-	public:
-		using value_type = typename string_base<Char>::value_type;
-		using size_type = typename string_base<Char>::size_type;
-		using difference_type = typename string_base<Char>::difference_type;
-		using pointer = typename string_base<Char>::pointer;
-		using const_pointer = typename string_base<Char>::const_pointer;
-		using reference = typename string_base<Char>::reference;
-		using const_reference = typename string_base<Char>::const_reference;
-		using iterator = typename string_base<Char>::iterator;
-		using const_iterator = typename string_base<Char>::const_iterator;
+#if __cplusplus >= 202002L
 
-	public:
-		constexpr string_view(void)noexcept;
-		constexpr string_view(const_pointer str, size_type len)noexcept;
-		constexpr string_view(const_pointer c)noexcept;
-		constexpr string_view(const string_view& s)noexcept;
-		constexpr string_view(const string_base<Char>& s)noexcept;
-		constexpr string_view(string_view&& s)noexcept;
-		template<class InIter>
-		constexpr string_view(InIter start, InIter fin)noexcept;
-		REXY_CPP20_CONSTEXPR ~string_view(void)noexcept = default;
-
-		constexpr string_view& operator=(const_pointer c)noexcept;
-		constexpr string_view& operator=(const string_view& s)noexcept;
-		constexpr string_view& operator=(string_view&&)noexcept;
+	template<class T>
+	concept BasicString = requires(T a){
+		{a.length()} -> std::same_as<typename std::decay_t<T>::size_type>;
+		{a.c_str()} -> std::same_as<typename std::decay_t<T>::const_pointer>;
+		{a[0]} -> std::same_as<typename std::decay_t<T>::const_reference>;
+		{a.begin()} -> std::same_as<typename std::decay_t<T>::const_iterator>;
+		{a.end()} -> std::same_as<typename std::decay_t<T>::const_iterator>;
 	};
-
 	template<class T>
-	string_view(const T*) -> string_view<T>;
+	concept StringExpr = rexy::is_template_type<T,string_cat_expr>::value;
 	template<class T>
-	string_view(const T*, size_t) -> string_view<T>;
-
-	template<class T>
-	using static_string [[deprecated]] = string_view<T>;
+	concept String = BasicString<T> || StringExpr<T>;
 
 	template<class T>
 	struct is_string{
-		static constexpr bool value = rexy::is_template_derived_type<T,string_base>::value || rexy::is_template_type<T,string_cat_expr>::value;
+		static constexpr bool value = BasicString<T>;
 	};
 	template<class T>
-	struct is_concrete_string{
-		static constexpr bool value = rexy::is_template_derived_type<T,string_base>::value;
+	static constexpr bool is_string_v = is_string<T>::value;
+	template<class... Ts>
+	struct are_strings{
+		static constexpr bool value = (BasicString<Ts> && ...);
 	};
-	namespace detail{
+	template<class... Ts>
+	static constexpr bool are_strings_v = are_strings<Ts...>::value;
+	template<class T>
+	struct is_string_expr{
+		static constexpr bool value = StringExpr<T>;
+	};
+	template<class T>
+	static constexpr bool is_string_expr_v = is_string_expr<T>::value;
+	template<class... Ts>
+	struct are_string_expr{
+		static constexpr bool value = (StringExpr<Ts> && ...);
+	};
+	template<class... Ts>
+	static constexpr bool are_string_expr_v = are_string_expr<Ts...>::value;
 
-		template<class... Ts>
-		using enable_if_string = std::enable_if_t<(is_string<Ts>::value && ...),int>;
-		template<class... Ts>
-		using enable_if_concrete_string = std::enable_if_t<(is_concrete_string<Ts>::value && ...),int>;
-		template<class... Ts>
-		using enable_if_expr_string = std::enable_if_t<(rexy::is_template_type<Ts,string_cat_expr>::value && ...),int>;
-
-	} //namespace detail
-
-	template<class Str1, class Str2, detail::enable_if_concrete_string<Str1,Str2> = 0>
-	constexpr bool operator==(Str1&& left, Str2&& right)noexcept{
-		return left.valid() && right.valid() && left.length() == right.length() && !strcmp(left.get(), right.get());
+	//Compare
+	template<BasicString Str1, BasicString Str2>
+	constexpr bool operator==(Str1&& left, Str2&& right){
+		return left.length() == right.length() && !strcmp(left.c_str(), right.c_str());
 	}
-	template<class Str, detail::enable_if_concrete_string<Str> = 0>
-	constexpr bool operator==(Str&& left, typename std::decay_t<Str>::const_pointer right)noexcept{
-		return left.valid() && right && !strcmp(left.get(), right);
-	}
-	template<class Str1, class Str2, detail::enable_if_concrete_string<Str1,Str2> = 0>
-	constexpr bool operator!=(Str1&& left, Str2&& right)noexcept{
-		return !(left == right);
-	}
-	template<class Str, detail::enable_if_concrete_string<Str> = 0>
-	constexpr bool operator!=(Str&& left, typename std::decay_t<Str>::const_pointer right)noexcept{
-		return !(left == right);
+	template<BasicString Str1, BasicString Str2>
+	constexpr bool operator!=(Str1&& left, Str2&& right){
+		return !(std::forward<Str1>(left) == std::forward<Str2>(right));
 	}
 
-	template<class Left, class Right, detail::enable_if_string<Left,Right> = 0>
+	//String + string concat
+	template<String Left, String Right>
 	constexpr auto operator+(Left&& l, Right&& r)
 		//uses deduction guide whereas std::is_nothrow_constructible couldn't
 		noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(l), std::forward<Right>(r))))
 	{
 		return string_cat_expr(std::forward<Left>(l), std::forward<Right>(r));
 	}
-	template<class Right, detail::enable_if_string<Right> = 0>
+	template<String Right>
 	constexpr auto operator+(typename std::decay_t<Right>::const_pointer left, Right&& right)
-		noexcept(noexcept(::new (nullptr) string_cat_expr(rexy::string_view(left), std::forward<Right>(right))))
+		noexcept(noexcept(::new (nullptr) string_cat_expr(rexy::basic_string_view(left), std::forward<Right>(right))))
 	{
-		return string_cat_expr(rexy::string_view(left), std::forward<Right>(right));
+		return string_cat_expr(rexy::basic_string_view(left), std::forward<Right>(right));
 	}
-
-	template<class Left, detail::enable_if_string<Left> = 0>
+	template<String Left>
 	constexpr auto operator+(Left&& left, typename std::decay_t<Left>::const_pointer right)
-		noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(left), rexy::string_view(right))))
+		noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(left), rexy::basic_string_view(right))))
 	{
-		return rexy::string_cat_expr(std::forward<Left>(left), rexy::string_view(right));
+		return rexy::string_cat_expr(std::forward<Left>(left), rexy::basic_string_view(right));
 	}
 
-	template<class Left, class Right, detail::enable_if_concrete_string<Left> = 0, detail::enable_if_string<Right> = 0>
+	//String concat assign
+	template<BasicString Left, String Right>
 	REXY_CPP20_CONSTEXPR decltype(auto) operator+=(Left& l, Right&& r)
 		noexcept(noexcept(l + std::forward<Right>(r)) && std::is_nothrow_assignable<Left, decltype(l + std::forward<Right>(r))>::value)
 	{
 		return l = (l + std::forward<Right>(r));
 	}
-	template<class Left, detail::enable_if_concrete_string<Left> = 0>
+	template<BasicString Left>
 	REXY_CPP20_CONSTEXPR decltype(auto) operator+=(Left& l, typename std::decay_t<Left>::const_pointer r)
 		noexcept(noexcept(l + r) && std::is_nothrow_assignable<Left, decltype(l + r)>::value)
 	{
 		return l = (l + r);
 	}
+
+#else //__cplusplus == 202002L
+
+	#define HAS_MEMFUN_WITH_RET(type, ret, fun, ...) \
+		template<class T> \
+		struct has_##fun##_f{ \
+			std::false_type check(...); \
+			template<class type> \
+			auto check(type* u) -> std::enable_if<std::is_same_v<std::declval<type>().fun(__VA_ARGS__),ret>,std::true_type>; \
+	 \
+			static constexpr bool value = decltype(check(std::declval<T*>()))::value; \
+		}; \
+		template<class T> \
+		static constexpr bool has_##fun##_f_v = has_##fun##_f<T>::value
+
+	#define HAS_MEMOP_WITH_RET(type, ret, opname, op, ...) \
+		template<class T> \
+		struct has_##opname##_f{ \
+			std::false_type check(...); \
+			template<class type> \
+			auto check(type* u) -> std::enable_if<std::is_same_v<std::declval<type>().operator op(__VA_ARGS__),ret>,std::true_type>; \
+	 \
+			static constexpr bool value = decltype(check(std::declval<T*>()))::value; \
+		}; \
+		template<class T> \
+		static constexpr bool has_##opname##_f_v = has_##opname##_f<T>::value
+
+
+	HAS_MEMFUN_WITH_RET(U, typename U::size_type, length);
+	HAS_MEMFUN_WITH_RET(U, typename U::const_pointer, c_str);
+	HAS_MEMOP_WITH_RET(U, typename U::const_reference, indexop, [], 0);
+	HAS_MEMFUN_WITH_RET(U, typename U::const_iterator, begin);
+	HAS_MEMFUN_WITH_RET(U, typename U::const_iterator, end);
+
+	#undef HAS_MEMFUN_WITH_RET
+	#undef HAS_MEMOP_WITH_RET
+
+	template<class T>
+	struct is_string{
+		static constexpr bool value = has_length_f_v<T> && has_c_str_f_v<T> && has_indexop_f_v<T> && has_begin_f_v<T> && has_end_f_v<T>;
+	};
+	template<class T>
+	static constexpr bool is_string_v = is_string<T>::value;
+	template<class... Ts>
+	struct are_strings{
+		static constexpr bool value = (is_string<Ts>::value && ...);
+	};
+	template<class... Ts>
+	static constexpr bool are_strings_v = are_strings<Ts...>::value;
+	template<class T>
+	struct is_string_expr{
+		static constexpr bool value = rexy::is_template_type<T,string_cat_expr>::value;
+	};
+	template<class T>
+	static constexpr bool is_string_expr_v = is_string_expr<T>::value;
+	template<class... Ts>
+	struct are_string_expr{
+		static constexpr bool value = (is_string_expr<Ts>::value && ...);
+	};
+	template<class... Ts>
+	static constexpr bool are_string_expr_v = are_string_expr<Ts...>::value;
+
+	//Compare
+	template<class Str1, class Str2, std::enable_if_t<are_strings<Str1, Str2>::value,int> = 0>
+	constexpr bool operator==(Str1&& left, Str2&& right){
+		return left.length() == right.length() && !strcmp(left.c_str(), right.c_str());
+	}
+	template<class Str1, class Str2, std::enable_if_t<are_strings<Str1, Str2>::value,int> = 0>
+	constexpr bool operator!=(Str1&& left, Str2&& right)noexcept{
+		return !(std::forward<Str1>(left) == std::forward<Str2>(right));
+	}
+
+	//String + string concat
+	template<class Left, class Right, std::enable_if_t<are_strings<Left, Right>::value,int> = 0>
+	constexpr auto operator+(Left&& l, Right&& r)
+		//uses deduction guide whereas std::is_nothrow_constructible couldn't
+		noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(l), std::forward<Right>(r))))
+	{
+		return string_cat_expr(std::forward<Left>(l), std::forward<Right>(r));
+	}
+	template<class Right, std::enable_if_t<is_string<Right>::value,int> = 0>
+	constexpr auto operator+(typename std::decay_t<Right>::const_pointer left, Right&& right)
+		noexcept(noexcept(::new (nullptr) string_cat_expr(rexy::basic_string_view(left), std::forward<Right>(right))))
+	{
+		return string_cat_expr(rexy::basic_string_view(left), std::forward<Right>(right));
+	}
+	template<class Left, std::enable_if_t<is_string<Left>::value,int> = 0>
+	constexpr auto operator+(Left&& left, typename std::decay_t<Left>::const_pointer right)
+		noexcept(noexcept(::new (nullptr) string_cat_expr(std::forward<Left>(left), rexy::basic_string_view(right))))
+	{
+		return rexy::string_cat_expr(std::forward<Left>(left), rexy::basic_string_view(right));
+	}
+
+
+	//String + expr concat
+	template<class Left, class Right, std::enable_if_t<is_string<Left>::value && is_string_expr<Right>::value,int> = 0>
+	constexpr auto operator+(Left&& left, Right&& right){
+		return string_cat_expr(std::forward<Left>(left), std::forward<Right>(right));
+	}
+	template<class Left, class Right, std::enable_if_t<is_string_expr<Left>::value && is_string<Right>::value,int> = 0>
+	constexpr auto operator+(Left&& left, Right&& right){
+		return string_cat_expr(std::forward<Left>(left), std::forward<Right>(right));
+	}
+
+	//String concat assignment
+	template<class Left, class Right, std::enable_if_t<are_strings<Left,Right>::value,int> = 0>
+	REXY_CPP20_CONSTEXPR decltype(auto) operator+=(Left& l, Right&& r)
+		noexcept(noexcept(l + std::forward<Right>(r)) && std::is_nothrow_assignable<Left, decltype(l + std::forward<Right>(r))>::value)
+	{
+		return l = (l + std::forward<Right>(r));
+	}
+	template<class Left, class Right, std::enable_if_t<is_string<Left>::value && is_string_expr<Right>::value,int> = 0>
+	REXY_CPP20_CONSTEXPR decltype(auto) operator+=(Left& l, Right&& r)
+		noexcept(noexcept(l + std::forward<Right>(r)) && std::is_nothrow_assignable<Left, decltype(l + std::forward<Right>(r))>::value)
+	{
+		return l = (l + std::forward<Right>(r));
+	}
+	template<class Left, std::enable_if_t<is_string<Left>::value, int> = 0>
+	REXY_CPP20_CONSTEXPR decltype(auto) operator+=(Left& l, typename std::decay_t<Left>::const_pointer r)
+		noexcept(noexcept(l + r) && std::is_nothrow_assignable<Left, decltype(l + r)>::value)
+	{
+		return l = (l + r);
+	}
+
+#endif //__cplusplus == 202002L
+
 }
 
 #include "string_base.tpp"
 
 namespace{
 	[[deprecated]]
-	constexpr inline rexy::string_view<char> operator"" _ss(const char* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<char> operator"" _ss(const char* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
 	[[deprecated]]
-	constexpr inline rexy::string_view<wchar_t> operator"" _ss(const wchar_t* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<wchar_t> operator"" _ss(const wchar_t* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
 	[[deprecated]]
-	constexpr inline rexy::string_view<char16_t> operator"" _ss(const char16_t* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<char16_t> operator"" _ss(const char16_t* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
 	[[deprecated]]
-	constexpr inline rexy::string_view<char32_t> operator"" _ss(const char32_t* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<char32_t> operator"" _ss(const char32_t* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
 
-	constexpr inline rexy::string_view<char> operator"" _sv(const char* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<char> operator"" _sv(const char* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
-	constexpr inline rexy::string_view<wchar_t> operator"" _sv(const wchar_t* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<wchar_t> operator"" _sv(const wchar_t* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
-	constexpr inline rexy::string_view<char16_t> operator"" _sv(const char16_t* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<char16_t> operator"" _sv(const char16_t* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
-	constexpr inline rexy::string_view<char32_t> operator"" _sv(const char32_t* str, size_t len)noexcept{
-		return rexy::string_view(str, len);
+	constexpr inline rexy::basic_string_view<char32_t> operator"" _sv(const char32_t* str, size_t len)noexcept{
+		return rexy::basic_string_view(str, len);
 	}
 
 	template<class Char, class Alloc>
@@ -502,7 +691,7 @@ namespace{
 		return os << str.c_str();
 	}
 	template<class Char>
-	std::ostream& operator<<(std::ostream& os, const rexy::string_view<Char>& str){
+	std::ostream& operator<<(std::ostream& os, const rexy::basic_string_view<Char>& str){
 		return os << str.c_str();
 	}
 
diff --git a/include/rexy/string_base.tpp b/include/rexy/string_base.tpp
index 8b60247..54cbe09 100644
--- a/include/rexy/string_base.tpp
+++ b/include/rexy/string_base.tpp
@@ -1,6 +1,6 @@
 /**
 	This file is a part of rexy's general purpose library
-	Copyright (C) 2020 rexy712
+	Copyright (C) 2020-2022 rexy712
 
 	This program is free software: you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
@@ -22,11 +22,11 @@
 #include <utility> //forward, move, swap, etc
 #include <cstdlib> //memcpy
 #include <cstring> //strlen, strcpy
-#include <memory> //to_address
 
 #include "utility.hpp" //max
 #include "detail/string_appender.hpp"
 #include "algorithm.hpp"
+#include "compat/to_address.hpp"
 
 #define STOP_STRICT_ALIAS_WARNING(x) (x)
 
@@ -133,6 +133,13 @@ namespace rexy{
 	{
 		_copy_construct_string(nullptr, len, cap);
 	}
+	template<class Char, class Allocator>
+	REXY_CPP20_CONSTEXPR basic_string<Char,Allocator>::basic_string(const basic_string_view<Char>& sv)
+		noexcept(noexcept(this->allocate(0)))
+	{
+		_copy_construct_string(sv.c_str(), sv.length(), sv.length());
+	}
+
 	template<class Char, class Allocator>
 	template<class InputIt>
 	REXY_CPP20_CONSTEXPR basic_string<Char,Allocator>::basic_string(InputIt start, InputIt fin)
@@ -200,6 +207,14 @@ namespace rexy{
 		return (*this = basic_string(s));
 	}
 	//Copy from c string
+	template<class Char, class Allocator>
+	REXY_CPP20_CONSTEXPR basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const basic_string_view<Char>& sv)
+		noexcept(noexcept(this->allocate(0)) &&
+		         noexcept(this->deallocate(nullptr,0)))
+	{
+		return _copy_string(sv.c_str(), sv.length());
+	}
+
 	template<class Char, class Allocator>
 	REXY_CPP20_CONSTEXPR basic_string<Char,Allocator>& basic_string<Char,Allocator>::operator=(const_pointer c)
 		noexcept(noexcept(this->allocate(0)) &&
@@ -327,7 +342,7 @@ namespace rexy{
 		noexcept(noexcept(this->allocate(0)) &&
 		         noexcept(this->deallocate(nullptr,0)))
 		{
-		if(!len)
+		if(!s || !len)
 			return (*this = basic_string(rexy::steal<pointer>(nullptr), 0, 0));
 		if(len <= this->length()){
 			this->set_length(len);
@@ -359,63 +374,48 @@ namespace rexy{
 
 
 	template<class Char>
-	constexpr string_view<Char>::string_view(void)noexcept:
-		string_view(nullptr, 0){}
+	constexpr basic_string_view<Char>::basic_string_view(void)noexcept:
+		basic_string_view(nullptr, 0){}
 
 	template<class Char>
-	constexpr string_view<Char>::string_view(const_pointer str, size_type len)noexcept{
-		if(!str)
-			this->set_long_ptr(nullptr);
-		else
-			this->set_long_ptr(const_cast<pointer>(str));
-		this->set_long_length(len);
-		this->set_long_capacity(len);
-	}
+	constexpr basic_string_view<Char>::basic_string_view(const_pointer str, size_type len)noexcept:
+		m_data(str), m_length(len){}
 	template<class Char>
-	constexpr string_view<Char>::string_view(const string_view& s)noexcept:
-		string_view(s.get_long_ptr(), s.get_long_length()){}
+	constexpr basic_string_view<Char>::basic_string_view(const basic_string_view& s)noexcept:
+		m_data(s.m_data), m_length(s.m_length){}
 	template<class Char>
-	constexpr string_view<Char>::string_view(const string_base<Char>& s)noexcept:
-		string_view(s.c_str(), s.length()){}
+	constexpr basic_string_view<Char>::basic_string_view(const string_base<Char>& s)noexcept:
+		m_data(s.c_str()), m_length(s.length()){}
 	template<class Char>
-	constexpr string_view<Char>::string_view(string_view&& s)noexcept:
-		string_view(s.get_long_ptr(), s.get_long_length()){}
+	constexpr basic_string_view<Char>::basic_string_view(basic_string_view&& s)noexcept:
+		m_data(s.m_data), m_length(s.m_length){}
 	template<class Char>
 	template<class InIter>
-	constexpr string_view<Char>::string_view(InIter start, InIter fin)noexcept:
-		string_view(std::to_address(start), fin - start){}
+	constexpr basic_string_view<Char>::basic_string_view(InIter start, InIter fin)noexcept:
+		basic_string_view(compat::to_address(start), fin - start){}
 
 	template<class Char>
-	constexpr string_view<Char>& string_view<Char>::operator=(const string_view& s)noexcept{
-		this->set_long_ptr(const_cast<pointer>(s.get_long_ptr()));
-		this->set_long_length(s.get_long_length());
-		this->set_long_capacity(s.get_long_capacity());
+	constexpr basic_string_view<Char>& basic_string_view<Char>::operator=(const basic_string_view& s)noexcept{
+		m_data = s.m_data;
+		m_length = s.m_length;
 		return *this;
 	}
 	template<class Char>
-	constexpr string_view<Char>::string_view(const_pointer c)noexcept:
-		string_view(c, strlen(c)){}
+	constexpr basic_string_view<Char>::basic_string_view(const_pointer c)noexcept:
+		basic_string_view(c, strlen(c)){}
 	template<class Char>
-	constexpr string_view<Char>& string_view<Char>::operator=(const_pointer c)noexcept{
-		size_type len = strlen(c);
-		this->set_long_ptr(const_cast<pointer>(c));
-		this->set_long_length(len);
-		this->set_long_capacity(len);
+	constexpr basic_string_view<Char>& basic_string_view<Char>::operator=(const_pointer c)noexcept{
+		m_data = c;
+		m_length = strlen(c);
 		return *this;
 	}
 	template<class Char>
-	constexpr string_view<Char>& string_view<Char>::operator=(string_view&& s)noexcept{
-		this->set_long_ptr(s.get_long_ptr());
-		this->set_long_length(s.get_long_length());
-		this->set_long_capacity(s.get_long_capacity());
+	constexpr basic_string_view<Char>& basic_string_view<Char>::operator=(basic_string_view&& s)noexcept{
+		m_data = s.m_data;
+		m_length = s.m_length;
 		return *this;
 	}
 
-	extern template class string_view<char>;
-	extern template class string_view<wchar_t>;
-	extern template class string_view<char16_t>;
-	extern template class string_view<char32_t>;
-
 } //namespace rexy
 
 #undef STOP_STRICT_ALIAS_WARNING
diff --git a/src/ensure.cpp b/src/ensure.cpp
index b53ebcf..0d8b1fe 100644
--- a/src/ensure.cpp
+++ b/src/ensure.cpp
@@ -21,10 +21,10 @@
 #include "rexy/meta.hpp"
 #include "rexy/enum_traits.hpp"
 #include "rexy/deferred.hpp"
-#include "rexy/source_location.hpp"
 #include "rexy/demangle.hpp"
 #include "rexy/debug_print.hpp"
 #include "rexy/storage_for.hpp"
+#include "rexy/visitor.hpp"
 
 #include "rexy/detail/binary_string_conv.hpp"
 #include "rexy/detail/string_appender.hpp"
@@ -35,3 +35,6 @@
 #include "rexy/cx/vector.hpp"
 
 #include "rexy/cx/detail/bool_specialize_base.hpp"
+
+#include "rexy/compat/to_address.hpp"
+#include "rexy/compat/source_location.hpp"
diff --git a/src/static_string.cpp b/src/static_string.cpp
index 6634190..47d4363 100644
--- a/src/static_string.cpp
+++ b/src/static_string.cpp
@@ -20,9 +20,9 @@
 
 namespace rexy{
 
-	template class string_view<char>;
-	template class string_view<wchar_t>;
-	template class string_view<char16_t>;
-	template class string_view<char32_t>;
+	template class basic_string_view<char>;
+	template class basic_string_view<wchar_t>;
+	template class basic_string_view<char16_t>;
+	template class basic_string_view<char32_t>;
 
 }