diff --git a/include/iris/x4/auxiliary/attr.hpp b/include/iris/x4/auxiliary/attr.hpp
index 03dbb06b5..5e1b31fea 100644
--- a/include/iris/x4/auxiliary/attr.hpp
+++ b/include/iris/x4/auxiliary/attr.hpp
@@ -14,9 +14,9 @@
 
 #include <iris/x4/core/parser.hpp>
 #include <iris/x4/core/move_to.hpp>
+#include <iris/x4/core/char_traits.hpp>
 
 #include <iris/x4/traits/container_traits.hpp>
-#include <iris/x4/traits/string_traits.hpp>
 
 #include <string>
 #include <string_view>
@@ -104,7 +104,7 @@ struct attr_parser<T, void> : parser<attr_parser<T, void>>
 
 namespace detail {
 
-template<traits::CharArray R>
+template<CharArray R>
 using string_array_attr_parser_t = attr_parser<
     std::basic_string<std::remove_extent_t<std::remove_cvref_t<R>>>,
     std::basic_string_view<std::remove_extent_t<std::remove_cvref_t<R>>>
@@ -112,7 +112,7 @@ using string_array_attr_parser_t = attr_parser<
 
 } // detail
 
-template<traits::CharArray R>
+template<CharArray R>
 attr_parser(R const&) -> attr_parser<
     std::basic_string<std::remove_extent_t<std::remove_cvref_t<R>>>,
     std::basic_string_view<std::remove_extent_t<std::remove_cvref_t<R>>>
@@ -141,7 +141,7 @@ struct attr_gen
         return attr_parser<std::remove_cvref_t<T>>{std::forward<T>(value)};
     }
 
-    template<traits::CharArray R>
+    template<CharArray R>
     [[nodiscard]] static constexpr string_array_attr_parser_t<R>
     operator()(R&& value)
         noexcept(std::is_nothrow_constructible_v<string_array_attr_parser_t<R>, R>)
diff --git a/include/iris/x4/char/any_char.hpp b/include/iris/x4/char/any_char.hpp
index 6719ea0a9..72af3998a 100644
--- a/include/iris/x4/char/any_char.hpp
+++ b/include/iris/x4/char/any_char.hpp
@@ -10,9 +10,9 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
+#include <iris/x4/core/char_traits.hpp>
 #include <iris/x4/char/literal_char.hpp>
 #include <iris/x4/char/char_set.hpp>
-#include <iris/x4/traits/string_traits.hpp>
 
 namespace iris::x4 {
 
@@ -43,7 +43,7 @@ struct any_char : char_parser<Encoding, any_char<Encoding>>
         return {ch};
     }
 
-    template<traits::CharIncompatibleWith<char_type> CharT>
+    template<CharIncompatibleWith<char_type> CharT>
     static constexpr void operator()(CharT) = delete; // Mixing incompatible char types is not allowed
 
     [[nodiscard]] static constexpr literal_char<Encoding>
@@ -59,7 +59,7 @@ struct any_char : char_parser<Encoding, any_char<Encoding>>
         return char_set<Encoding>{ch};
     }
 
-    template<traits::CharIncompatibleWith<char_type> CharT, std::size_t N>
+    template<CharIncompatibleWith<char_type> CharT, std::size_t N>
     static constexpr void
     operator()(CharT const (&)[N]) = delete; // Mixing incompatible char types is not allowed
 
@@ -71,7 +71,7 @@ struct any_char : char_parser<Encoding, any_char<Encoding>>
     }
 
     template<class From, class To>
-        requires traits::CharIncompatibleWith<From, char_type> || traits::CharIncompatibleWith<To, char_type>
+        requires CharIncompatibleWith<From, char_type> || CharIncompatibleWith<To, char_type>
     static constexpr void operator()(From, To) = delete; // Mixing incompatible char types is not allowed
 
     template<class From, std::size_t FromN, class To, std::size_t ToN>
diff --git a/include/iris/x4/char/char.hpp b/include/iris/x4/char/char.hpp
index 7674ed135..867959364 100644
--- a/include/iris/x4/char/char.hpp
+++ b/include/iris/x4/char/char.hpp
@@ -10,9 +10,9 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
+#include <iris/x4/core/char_traits.hpp>
 #include <iris/x4/char/any_char.hpp>
 #include <iris/x4/char/literal_char.hpp>
-#include <iris/x4/traits/string_traits.hpp>
 
 #include <iris/x4/char_encoding/standard.hpp>
 
@@ -39,7 +39,7 @@ lit(char ch) noexcept
 }
 
 [[nodiscard]] constexpr literal_char<char_encoding::standard, unused_type>
-lit(traits::X4VagueArrayOf2Chars<char> auto const& ch) noexcept
+lit(X4VagueArrayOf2Chars<char> auto const& ch) noexcept
 {
     return {ch[0]};
 }
@@ -51,8 +51,8 @@ lit(traits::X4VagueArrayOf2Chars<char> auto const& ch) noexcept
 // If you still see errors after the inclusion, that might be due to
 // mixing incompatible string literals. Don't do that.
 
-constexpr void lit(traits::CharIncompatibleWith<char> auto const*) = delete; // Mixing incompatible character types is not allowed
-constexpr void lit(traits::CharIncompatibleWith<char> auto) = delete; // Mixing incompatible character types is not allowed
+constexpr void lit(CharIncompatibleWith<char> auto const*) = delete; // Mixing incompatible character types is not allowed
+constexpr void lit(CharIncompatibleWith<char> auto) = delete; // Mixing incompatible character types is not allowed
 
 } // standard
 
@@ -76,15 +76,15 @@ lit(wchar_t ch) noexcept
 }
 
 [[nodiscard]] constexpr literal_char<char_encoding::standard_wide, unused_type>
-lit(traits::X4VagueArrayOf2Chars<wchar_t> auto const& ch) noexcept
+lit(X4VagueArrayOf2Chars<wchar_t> auto const& ch) noexcept
 {
     return {ch[0]};
 }
 
 } // helpers
 
-constexpr void lit(traits::CharIncompatibleWith<wchar_t> auto const*) = delete; // Mixing incompatible character types is not allowed
-constexpr void lit(traits::CharIncompatibleWith<wchar_t> auto) = delete; // Mixing incompatible character types is not allowed
+constexpr void lit(CharIncompatibleWith<wchar_t> auto const*) = delete; // Mixing incompatible character types is not allowed
+constexpr void lit(CharIncompatibleWith<wchar_t> auto) = delete; // Mixing incompatible character types is not allowed
 
 } // standard_wide
 
@@ -108,15 +108,15 @@ lit(char32_t ch) noexcept
 }
 
 [[nodiscard]] constexpr literal_char<char_encoding::unicode, unused_type>
-lit(traits::X4VagueArrayOf2Chars<char32_t> auto const& ch) noexcept
+lit(X4VagueArrayOf2Chars<char32_t> auto const& ch) noexcept
 {
     return {ch[0]};
 }
 
 } // helpers
 
-constexpr void lit(traits::CharIncompatibleWith<char32_t> auto const*) = delete; // Mixing incompatible character types is not allowed
-constexpr void lit(traits::CharIncompatibleWith<char32_t> auto) = delete; // Mixing incompatible character types is not allowed
+constexpr void lit(CharIncompatibleWith<char32_t> auto const*) = delete; // Mixing incompatible character types is not allowed
+constexpr void lit(CharIncompatibleWith<char32_t> auto) = delete; // Mixing incompatible character types is not allowed
 
 } // unicode
 
@@ -143,7 +143,7 @@ using x4::standard_wide::lit;
 namespace unicode {
 using x4::unicode::char_;
 using x4::unicode::lit;
-} // standard_wide
+} // unicode
 #endif
 
 using x4::char_; // TODO: make `any_parser` encoding-agnostic
@@ -178,10 +178,24 @@ struct as_parser<wchar_t>
         return {ch};
     }
 };
-#endif
+#endif // IRIS_X4_NO_STANDARD_WIDE
+
+#ifdef IRIS_X4_UNICODE
+template<>
+struct as_parser<char32_t>
+{
+    using type = literal_char<char_encoding::unicode, unused_type>;
+    using value_type = type;
+
+    [[nodiscard]] static constexpr type call(char32_t ch) noexcept
+    {
+        return {ch};
+    }
+};
+#endif // IRIS_X4_UNICODE
 
 template<>
-struct as_parser<char [2]>
+struct as_parser<char[2]>
 {
     using type = literal_char<char_encoding::standard, unused_type>;
     using value_type = type;
@@ -194,7 +208,7 @@ struct as_parser<char [2]>
 
 #ifndef IRIS_X4_NO_STANDARD_WIDE
 template<>
-struct as_parser<wchar_t [2]>
+struct as_parser<wchar_t[2]>
 {
     using type = literal_char<char_encoding::standard_wide, unused_type>;
     using value_type = type;
@@ -206,6 +220,20 @@ struct as_parser<wchar_t [2]>
 };
 #endif // IRIS_X4_NO_STANDARD_WIDE
 
+#ifdef IRIS_X4_UNICODE
+template<>
+struct as_parser<char32_t[2]>
+{
+    using type = literal_char<char_encoding::unicode, unused_type>;
+    using value_type = type;
+
+    [[nodiscard]] static constexpr type call(char32_t const ch[]) noexcept
+    {
+        return {ch[0]};
+    }
+};
+#endif // IRIS_X4_UNICODE
+
 } // extension
 
 } // iris::x4
diff --git a/include/iris/x4/char/char_class.hpp b/include/iris/x4/char/char_class.hpp
index 925522667..4df79cc2e 100644
--- a/include/iris/x4/char/char_class.hpp
+++ b/include/iris/x4/char/char_class.hpp
@@ -11,6 +11,7 @@
 ==============================================================================*/
 
 #include <iris/x4/core/skip_over.hpp>
+#include <iris/x4/core/char_traits.hpp>
 
 #include <iris/x4/char/char_parser.hpp>
 #include <iris/x4/char/char_class_tags.hpp>
@@ -18,7 +19,7 @@
 
 #include <iris/x4/string/case_compare.hpp>
 
-#include <iris/x4/traits/string_traits.hpp>
+#include <iris/x4/traits/char_encoding_traits.hpp>
 
 #include <iris/x4/char_encoding/standard.hpp>
 
@@ -183,7 +184,7 @@ template<class CharClassTag, std::forward_iterator It, std::sentinel_for<It> Se>
 constexpr void builtin_skip_over(It& first, Se const& last) noexcept
 {
     using CharT = std::remove_cvref_t<std::iter_value_t<It>>;
-    static_assert(traits::CharLike<CharT>);
+    static_assert(CharLike<CharT>);
 
     using Encoding = traits::char_encoding_for<CharT>;
     using Parser = char_class_parser<Encoding, CharClassTag>;
diff --git a/include/iris/x4/char/char_parser.hpp b/include/iris/x4/char/char_parser.hpp
index 53b196006..393242cd0 100644
--- a/include/iris/x4/char/char_parser.hpp
+++ b/include/iris/x4/char/char_parser.hpp
@@ -13,8 +13,7 @@
 #include <iris/x4/core/parser.hpp>
 #include <iris/x4/core/skip_over.hpp>
 #include <iris/x4/core/move_to.hpp>
-
-#include <iris/x4/traits/string_traits.hpp>
+#include <iris/x4/core/char_traits.hpp>
 
 #include <concepts>
 #include <iterator>
@@ -47,8 +46,8 @@ struct char_parser : parser<Derived>
             noexcept(++first)
         )
     {
-        static_assert(std::same_as<std::iter_value_t<It>, char_type>, "Mixing incompatible char types is not allowed");
-        static_assert(!traits::CharLike<Attr> || std::same_as<Attr, char_type>, "Mixing incompatible char types is not allowed");
+        static_assert(!CharIncompatibleWith<std::iter_value_t<It>, char_type>, "Mixing incompatible char types is not allowed");
+        static_assert(!CharLike<Attr> || !CharIncompatibleWith<Attr, char_type>, "Mixing incompatible char types is not allowed");
 
         x4::skip_over(first, last, ctx);
 
@@ -72,8 +71,8 @@ struct char_parser : parser<Derived>
             noexcept(++first)
         )
     {
-        static_assert(std::same_as<std::iter_value_t<It>, char_type>, "Mixing incompatible char types is not allowed");
-        static_assert(!traits::CharLike<Attr> || std::same_as<Attr, char_type>, "Mixing incompatible char types is not allowed");
+        static_assert(!CharIncompatibleWith<std::iter_value_t<It>, char_type>, "Mixing incompatible char types is not allowed");
+        static_assert(!CharLike<Attr> || !CharIncompatibleWith<Attr, char_type>, "Mixing incompatible char types is not allowed");
 
         x4::skip_over(first, last, ctx);
 
diff --git a/include/iris/x4/core/char_traits.hpp b/include/iris/x4/core/char_traits.hpp
new file mode 100644
index 000000000..19ad29650
--- /dev/null
+++ b/include/iris/x4/core/char_traits.hpp
@@ -0,0 +1,60 @@
+#ifndef IRIS_ZZ_X4_CORE_CHAR_TRAITS_HPP
+#define IRIS_ZZ_X4_CORE_CHAR_TRAITS_HPP
+
+/*=============================================================================
+    Copyright (c) 2026 The Iris Project Contributors
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+================================================_==============================*/
+
+#include <iris/config.hpp>
+
+#include <concepts>
+#include <type_traits>
+
+namespace iris::x4 {
+
+template<class T>
+concept CharLike =
+    std::same_as<std::remove_cvref_t<T>, char> ||
+    std::same_as<std::remove_cvref_t<T>, wchar_t> ||
+    std::same_as<std::remove_cvref_t<T>, char8_t> ||
+    std::same_as<std::remove_cvref_t<T>, char16_t> ||
+    std::same_as<std::remove_cvref_t<T>, char32_t>;
+
+template<class T>
+concept CharArray =
+    std::is_array_v<std::remove_cvref_t<T>> &&
+    CharLike<std::remove_extent_t<std::remove_cvref_t<T>>>;
+
+// Spirit has historically converted "c" to 'c'.
+//
+// While we think it's still useful to retain the conversion,
+// we need to avoid further conversion to `std::basic_string_view`,
+// which leads to performance overhead. This trait enables
+// detection of such arrays.
+//
+// Note that the status quo introduces ambiguity in determining
+// {'c', '\0'} and {'c', 'd'}, but we're not aware of any practical
+// usage of non-null-terminated character array in the context of
+// DSL on parser combinator.
+//
+// However, if compelling use cases emerge, we may revise these
+// semantics. Versioned as `X4` for forward compatibility.
+template<class T, class CharT>
+concept X4VagueArrayOf2Chars =
+    std::same_as<std::remove_extent_t<std::remove_cvref_t<T>>, CharT> &&
+    std::is_bounded_array_v<std::remove_cvref_t<T>> &&
+    std::extent_v<std::remove_cvref_t<T>> == 2;
+
+// Mixing incompatible character types is semantically wrong.
+// Don't do that. It may even lead to security vulnerabilities.
+template<class T, class ExpectedCharT>
+concept CharIncompatibleWith =
+    CharLike<T> &&
+    !std::same_as<T, ExpectedCharT>;
+
+} // iris::x4
+
+#endif
diff --git a/include/iris/x4/core/move_to.hpp b/include/iris/x4/core/move_to.hpp
index 24612e6c1..bb1c7589a 100644
--- a/include/iris/x4/core/move_to.hpp
+++ b/include/iris/x4/core/move_to.hpp
@@ -12,7 +12,8 @@
 =============================================================================*/
 
 #include <iris/config.hpp>
-#include <iris/type_traits.hpp>
+
+#include <iris/x4/core/char_traits.hpp>
 
 #include <iris/x4/traits/attribute_category.hpp>
 #include <iris/x4/traits/tuple_traits.hpp>
@@ -74,7 +75,7 @@ constexpr void move_to(T&, T&) noexcept
     );
 
     static_assert(
-        false,
+        !std::is_lvalue_reference_v<T&>,
         "lvalue reference detected on the `src` argument of `x4::move_to`. "
         "The caller is definitely lacking `std::move` or `std::forward`. If you "
         "intend to *copy* the mutable value, apply `x4::move_to(std::as_const(attr_), attr)`."
@@ -134,6 +135,8 @@ move_to(Source&& src, Dest& dest)
 {
     static_assert(!std::same_as<std::remove_cvref_t<Source>, Dest>, "[BUG] This call should instead resolve to the overload handling identical types");
     static_assert(std::is_assignable_v<Dest&, Source>);
+    static_assert((!CharLike<Dest> && !CharLike<std::remove_cvref_t<Source>>) || !CharIncompatibleWith<Dest, std::remove_cvref_t<Source>>, "Mixing incompatible char types is not allowed");
+
     dest = std::forward<Source>(src);
 }
 
@@ -206,6 +209,13 @@ move_to(It first, Se last, Dest& dest)
 {
     static_assert(!std::same_as<std::remove_const_t<Dest>, unused_type>);
     static_assert(!std::same_as<std::remove_const_t<Dest>, unused_container_type>);
+    static_assert(
+        // If either `It` or `Dest` is relevant to any character type,
+        (!CharLike<std::remove_cvref_t<std::iter_value_t<It>>> && !CharLike<std::remove_cvref_t<typename traits::container_value<Dest>::type>>) ||
+        // ... then do the check below:
+        !CharIncompatibleWith<std::remove_cvref_t<std::iter_value_t<It>>, std::remove_cvref_t<typename traits::container_value<Dest>::type>>,
+        "Mixing incompatible char types is not allowed"
+    );
 
     if constexpr (!is_ttp_specialization_of_v<Dest, container_appender>) {
         if (!traits::is_empty(dest)) {
diff --git a/include/iris/x4/core/string_traits.hpp b/include/iris/x4/core/string_traits.hpp
new file mode 100644
index 000000000..5952626d8
--- /dev/null
+++ b/include/iris/x4/core/string_traits.hpp
@@ -0,0 +1,50 @@
+#ifndef IRIS_ZZ_X4_CORE_STRING_TRAITS_HPP
+#define IRIS_ZZ_X4_CORE_STRING_TRAITS_HPP
+
+/*=============================================================================
+    Copyright (c) 2026 The Iris Project Contributors
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+================================================_==============================*/
+
+#include <iris/config.hpp>
+
+#include <iris/x4/core/char_traits.hpp>
+
+#include <string>
+#include <string_view>
+#include <type_traits>
+#include <concepts>
+
+namespace iris::x4 {
+
+// Mixing incompatible character types is semantically wrong.
+// Don't do that. It may even lead to security vulnerabilities.
+template<class T, class ExpectedCharT>
+concept StringLikeIncompatibleWith =
+    CharLike<std::remove_const_t<std::remove_pointer_t<std::decay_t<T>>>> &&
+    !std::convertible_to<T, std::basic_string_view<ExpectedCharT>>;
+
+// Main utility to guide `char_`, `lit` and `string` to be
+// resolved into either `x4::literal_char` or `x4::literal_string`.
+//
+// This may also be used in other codes which require the same
+// semantics.
+template<class T, class CharT>
+concept CppStringLike =
+    // This avoids converting `CharT[2]` to `std::basic_string_view`.
+    (!X4VagueArrayOf2Chars<T, CharT>) &&
+    // All other types that are *naturally* convertible to `std::basic_string_view`.
+    std::convertible_to<std::decay_t<T>, std::basic_string_view<CharT>>;
+
+template<class T>
+using maybe_owning_string = std::conditional_t<
+    std::is_pointer_v<std::decay_t<T>>,
+    std::basic_string_view<std::remove_const_t<std::remove_pointer_t<std::decay_t<T>>>>,
+    std::remove_cvref_t<T>
+>;
+
+} // iris::x4
+
+#endif
diff --git a/include/iris/x4/debug/print_attribute.hpp b/include/iris/x4/debug/print_attribute.hpp
index cd5507cdc..ee71588ce 100644
--- a/include/iris/x4/debug/print_attribute.hpp
+++ b/include/iris/x4/debug/print_attribute.hpp
@@ -25,6 +25,7 @@
 
 #include <print>
 #include <iterator>
+#include <concepts>
 
 #include <cstdint>
 
@@ -144,7 +145,7 @@ inline void print_chars(std::ostream& os, char32_t const ch)
 }
 
 template<std::forward_iterator It, std::sentinel_for<It> Se>
-void print_chars(std::ostream& os, It const it, Se const se, std::size_t const max_code_points)
+void print_chars(std::ostream& os, It it, Se const se, std::size_t const max_code_points)
 {
     iris::unicode::code_point_iterator<It> code_point_it{it, it, se};
     iris::unicode::code_point_iterator<It> const code_point_se{se, it, se};
@@ -241,7 +242,7 @@ struct print_attribute_debug
     static void call(std::ostream& out, T_ const& val)
     {
         if constexpr (iris::StringLike<T_>) {
-            out << std::basic_string_view{val};
+            out << iris::unicode::transcode_ref<char>(std::basic_string_view{val});
 
         } else {
             out << '[';
diff --git a/include/iris/x4/numeric/bool.hpp b/include/iris/x4/numeric/bool.hpp
index c170d8acf..07261a751 100644
--- a/include/iris/x4/numeric/bool.hpp
+++ b/include/iris/x4/numeric/bool.hpp
@@ -17,6 +17,8 @@
 
 #include <iris/x4/string/detail/string_parse.hpp>
 
+#include <iris/x4/traits/char_encoding_traits.hpp>
+
 #include <concepts>
 #include <string_view>
 #include <iterator>
@@ -25,6 +27,23 @@
 
 namespace iris::x4 {
 
+template<class CharT>
+struct bool_token;
+
+template<>
+struct bool_token<char>
+{
+    static constexpr auto true_ = "true";
+    static constexpr auto false_ = "false";
+};
+
+template<>
+struct bool_token<char32_t>
+{
+    static constexpr auto true_ = U"true";
+    static constexpr auto false_ = U"false";
+};
+
 //  Default boolean policies
 template<class T = bool>
 struct bool_policies
@@ -34,8 +53,8 @@ struct bool_policies
     parse_true(It& first, Se const& last, Attr& attr_, CaseCompare const& compare)
         noexcept(noexcept(x4::move_to(T(true), attr_)))
     {
-        using namespace std::string_view_literals;
-        if (detail::string_parse("true"sv, first, last, unused_container, compare)) {
+        using CharT = std::remove_const_t<std::iter_value_t<It>>;
+        if (detail::string_parse(std::basic_string_view{bool_token<CharT>::true_}, first, last, unused_container, compare)) {
             x4::move_to(T(true), attr_);
             return true;
         }
@@ -47,8 +66,8 @@ struct bool_policies
     parse_false(It& first, Se const& last, Attr& attr_, CaseCompare const& compare)
         noexcept(noexcept(x4::move_to(T(false), attr_)))
     {
-        using namespace std::string_view_literals;
-        if (detail::string_parse("false"sv, first, last, unused_container, compare)) {
+        using CharT = std::remove_const_t<std::iter_value_t<It>>;
+        if (detail::string_parse(std::basic_string_view{bool_token<CharT>::false_}, first, last, unused_container, compare)) {
             x4::move_to(T(false), attr_);
             return true;
         }
@@ -56,28 +75,13 @@ struct bool_policies
     }
 };
 
-namespace detail {
-
-template<class Policy, class Encoding>
-concept BoolPolicy = requires(
-    typename Encoding::char_type const*& first, typename Encoding::char_type const* const& last,
-    unused_type const& ctx, case_compare<Encoding> const& compare
-) {
-    { Policy::parse_true(first, last, ctx, compare) } -> std::same_as<bool>;
-    { Policy::parse_false(first, last, ctx, compare) } -> std::same_as<bool>;
-};
-
-} // detail
-
-template<class T, class Encoding, class Policy = bool_policies<T>>
-struct bool_parser : parser<bool_parser<T, Encoding, Policy>>
+template<class T, class Policy = bool_policies<T>>
+struct bool_parser : parser<bool_parser<T, Policy>>
 {
     static_assert(X4Attribute<T>);
     static_assert(std::default_initializable<T>);
-    static_assert(detail::BoolPolicy<Policy, Encoding>);
 
     using attribute_type = T;
-    using encoding = Encoding;
     using policy_type = Policy;
 
     static constexpr bool has_attribute = true;
@@ -94,13 +98,15 @@ struct bool_parser : parser<bool_parser<T, Encoding, Policy>>
     parse(It& first, Se const& last, Context const& ctx, U& attr)
         noexcept(
             noexcept(x4::skip_over(first, last, ctx)) &&
-            noexcept(Policy::parse_true(first, last, attr, get_case_compare<encoding>(ctx))) &&
-            noexcept(Policy::parse_false(first, last, attr, get_case_compare<encoding>(ctx)))
+            noexcept(Policy::parse_true(first, last, attr, x4::get_case_compare<traits::char_encoding_for<std::remove_const_t<std::iter_value_t<It>>>>(ctx))) &&
+            noexcept(Policy::parse_false(first, last, attr, x4::get_case_compare<traits::char_encoding_for<std::remove_const_t<std::iter_value_t<It>>>>(ctx)))
         )
     {
         x4::skip_over(first, last, ctx);
-        return Policy::parse_true(first, last, attr, get_case_compare<encoding>(ctx))
-            || Policy::parse_false(first, last, attr, get_case_compare<encoding>(ctx));
+
+        auto const& compare = x4::get_case_compare<traits::char_encoding_for<std::remove_const_t<std::iter_value_t<It>>>>(ctx);
+        return Policy::parse_true(first, last, attr, compare)
+            || Policy::parse_false(first, last, attr, compare);
     }
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, class Attr>
@@ -115,7 +121,7 @@ struct bool_parser : parser<bool_parser<T, Encoding, Policy>>
         static_assert(X4NonUnusedAttribute<Attr>);
 
         // this case is called when Attribute is not T
-        T attr_;
+        T attr_{};
         if (bool_parser::parse(first, last, ctx, attr_)) {
             x4::move_to(std::move(attr_), attr);
             return true;
@@ -129,15 +135,13 @@ struct bool_parser : parser<bool_parser<T, Encoding, Policy>>
     }
 };
 
-template<class T, class Encoding, class Policy = bool_policies<T>>
-struct literal_bool_parser : parser<literal_bool_parser<T, Encoding, Policy>>
+template<class T, class Policy = bool_policies<T>>
+struct literal_bool_parser : parser<literal_bool_parser<T, Policy>>
 {
     static_assert(X4Attribute<T>);
     static_assert(std::default_initializable<T>);
-    static_assert(detail::BoolPolicy<Policy, Encoding>);
 
     using attribute_type = T;
-    using encoding = Encoding;
 
     static constexpr bool has_attribute = true;
 
@@ -161,13 +165,15 @@ struct literal_bool_parser : parser<literal_bool_parser<T, Encoding, Policy>>
     parse(It& first, Se const& last, Context const& ctx, U& attr) const
         noexcept(
             noexcept(x4::skip_over(first, last, ctx)) &&
-            noexcept(Policy::parse_true(first, last, attr, x4::get_case_compare<encoding>(ctx))) &&
-            noexcept(Policy::parse_false(first, last, attr, x4::get_case_compare<encoding>(ctx)))
+            noexcept(Policy::parse_true(first, last, attr, x4::get_case_compare<traits::char_encoding_for<std::remove_const_t<std::iter_value_t<It>>>>(ctx))) &&
+            noexcept(Policy::parse_false(first, last, attr, x4::get_case_compare<traits::char_encoding_for<std::remove_const_t<std::iter_value_t<It>>>>(ctx)))
         )
     {
         x4::skip_over(first, last, ctx);
-        return (expected_bool_ && Policy::parse_true(first, last, attr, x4::get_case_compare<encoding>(ctx)))
-            || (!expected_bool_ && Policy::parse_false(first, last, attr, x4::get_case_compare<encoding>(ctx)));
+
+        auto const& compare = x4::get_case_compare<traits::char_encoding_for<std::remove_const_t<std::iter_value_t<It>>>>(ctx);
+        return (expected_bool_ && Policy::parse_true(first, last, attr, compare))
+            || (!expected_bool_ && Policy::parse_false(first, last, attr, compare));
     }
 
     template<std::forward_iterator It, std::sentinel_for<It> Se, class Context, class Attr>
@@ -182,7 +188,7 @@ struct literal_bool_parser : parser<literal_bool_parser<T, Encoding, Policy>>
         static_assert(X4NonUnusedAttribute<Attr>);
 
         // this case is called when Attribute is not T
-        T attr_;
+        T attr_{};
         if (literal_bool_parser::parse(first, last, ctx, attr_)) {
             x4::move_to(std::move(attr_), attr);
             return true;
@@ -199,54 +205,18 @@ struct literal_bool_parser : parser<literal_bool_parser<T, Encoding, Policy>>
     T expected_bool_; // TODO: remove this runtime param; make this CTP
 };
 
-namespace standard {
-
-[[maybe_unused]] inline constexpr bool_parser<bool, char_encoding::standard> bool_{};
-[[maybe_unused]] inline constexpr literal_bool_parser<bool, char_encoding::standard> true_{true};
-[[maybe_unused]] inline constexpr literal_bool_parser<bool, char_encoding::standard> false_{false};
-
-} // standard
-
-namespace parsers::standard {
-
-using x4::standard::bool_;
-using x4::standard::true_;
-using x4::standard::false_;
-
-} // parsers::standard
-
-#ifndef IRIS_X4_NO_STANDARD_WIDE
-namespace standard_wide {
-
-[[maybe_unused]] inline constexpr bool_parser<bool, char_encoding::standard_wide> bool_{};
-[[maybe_unused]] inline constexpr literal_bool_parser<bool, char_encoding::standard_wide> true_{true};
-[[maybe_unused]] inline constexpr literal_bool_parser<bool, char_encoding::standard_wide> false_{false};
-
-} // standard_wide
-
-namespace parsers::standard_wide {
-
-using x4::standard_wide::bool_;
-using x4::standard_wide::true_;
-using x4::standard_wide::false_;
-
-} // parsers::standard_wide
-#endif
-
-// TODO: unicode bool parser
-
-using standard::bool_;
-using standard::true_;
-using standard::false_;
-
 namespace parsers {
 
-using x4::standard::bool_;
-using x4::standard::true_;
-using x4::standard::false_;
+[[maybe_unused]] inline constexpr bool_parser<bool> bool_{};
+[[maybe_unused]] inline constexpr literal_bool_parser<bool> true_{true};
+[[maybe_unused]] inline constexpr literal_bool_parser<bool> false_{false};
 
 } // parsers
 
+using parsers::bool_;
+using parsers::true_;
+using parsers::false_;
+
 } // iris::x4
 
 #endif
diff --git a/include/iris/x4/parse.hpp b/include/iris/x4/parse.hpp
index 2d9180170..abdbf885c 100644
--- a/include/iris/x4/parse.hpp
+++ b/include/iris/x4/parse.hpp
@@ -16,11 +16,10 @@
 #include <iris/x4/core/skip_over.hpp>
 #include <iris/x4/core/context.hpp>
 #include <iris/x4/core/expectation.hpp>
+#include <iris/x4/core/char_traits.hpp>
 
 #include <iris/x4/char/char_class.hpp> // for builtin skipper
 
-#include <iris/x4/traits/string_traits.hpp>
-
 #include <iris/x4/parse_result.hpp>
 
 #include <iterator>
@@ -159,14 +158,14 @@ concept X4RangeParseSkipper =
     >;
 
 template<std::ranges::forward_range R>
-    requires (!traits::CharArray<R>)
+    requires (!CharArray<R>)
 [[nodiscard]] static constexpr decltype(auto) as_parse_range(R const& range) noexcept
 {
     return range;
 }
 
 template<std::ranges::forward_range R>
-    requires traits::CharArray<R>
+    requires CharArray<R>
 [[nodiscard]] static constexpr auto as_parse_range(R const& str)
     noexcept(noexcept(std::basic_string_view{str}))
 {
diff --git a/include/iris/x4/parse_result.hpp b/include/iris/x4/parse_result.hpp
index 480988e4a..8feb694cc 100644
--- a/include/iris/x4/parse_result.hpp
+++ b/include/iris/x4/parse_result.hpp
@@ -11,7 +11,7 @@
 
 #include <iris/config.hpp>
 #include <iris/x4/core/expectation.hpp>
-#include <iris/x4/traits/string_traits.hpp>
+#include <iris/x4/core/char_traits.hpp>
 
 #include <iterator>
 #include <ranges>
@@ -95,7 +95,7 @@ struct parse_result_for_impl
 };
 
 template<std::ranges::forward_range R>
-    requires traits::CharArray<R>
+    requires CharArray<R>
 struct parse_result_for_impl<R>
 {
     using string_view_type = std::basic_string_view<
@@ -116,7 +116,7 @@ struct range_parse_parser_impl
 };
 
 template<std::ranges::forward_range R>
-    requires traits::CharArray<R>
+    requires CharArray<R>
 struct range_parse_parser_impl<R>
 {
     using string_view_type = std::basic_string_view<
diff --git a/include/iris/x4/string/detail/string_parse.hpp b/include/iris/x4/string/detail/string_parse.hpp
index 945a6a732..e985172c8 100644
--- a/include/iris/x4/string/detail/string_parse.hpp
+++ b/include/iris/x4/string/detail/string_parse.hpp
@@ -11,7 +11,7 @@
 ==============================================================================*/
 
 #include <iris/x4/core/move_to.hpp>
-#include <iris/x4/traits/string_traits.hpp>
+#include <iris/x4/core/char_traits.hpp>
 #include <iris/x4/traits/tuple_traits.hpp>
 #include <iris/x4/traits/container_traits.hpp>
 
@@ -33,7 +33,7 @@ string_parse(
     using synthesized_value_type = traits::synthesized_value_t<Attr>;
     static_assert(std::same_as<traits::attribute_category_t<synthesized_value_type>, traits::container_attr>);
     using value_type = traits::container_value<synthesized_value_type>::type;
-    static_assert(!traits::CharLike<value_type> || std::same_as<value_type, CharT>, "Mixing incompatible char types is not allowed");
+    static_assert(!CharLike<value_type> || !CharIncompatibleWith<value_type, CharT>, "Mixing incompatible char types is not allowed");
 
     It it = first;
     auto stri = str.begin();
@@ -80,7 +80,7 @@ string_parse(
     using synthesized_value_type = traits::synthesized_value_t<Attr>;
     static_assert(std::same_as<traits::attribute_category_t<synthesized_value_type>, traits::container_attr>);
     using value_type = traits::container_value<synthesized_value_type>::type;
-    static_assert(!traits::CharLike<value_type> || std::same_as<value_type, CharT>, "Mixing incompatible char types is not allowed");
+    static_assert(!CharLike<value_type> || !CharIncompatibleWith<value_type, CharT>, "Mixing incompatible char types is not allowed");
 
     auto uc_it = ucstr.begin();
     auto uc_last = ucstr.end();
diff --git a/include/iris/x4/string/string.hpp b/include/iris/x4/string/string.hpp
index 4ea10a291..73d0934e3 100644
--- a/include/iris/x4/string/string.hpp
+++ b/include/iris/x4/string/string.hpp
@@ -10,9 +10,11 @@
     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 ==============================================================================*/
 
-#include <iris/x4/string/literal_string.hpp>
+#include <iris/x4/core/char_traits.hpp>
+#include <iris/x4/core/string_traits.hpp>
+
 #include <iris/x4/char/literal_char.hpp> // required for "c" -> 'c' optimization
-#include <iris/x4/traits/string_traits.hpp>
+#include <iris/x4/string/literal_string.hpp>
 
 #include <iris/x4/char_encoding/standard.hpp>
 
@@ -35,10 +37,10 @@ namespace standard {
 
 inline namespace helpers {
 
-template<traits::CppStringLike<char> T>
-[[nodiscard]] constexpr literal_string<traits::maybe_owning_string<T>, char_encoding::standard>
+template<CppStringLike<char> T>
+[[nodiscard]] constexpr literal_string<maybe_owning_string<T>, char_encoding::standard>
 string(T&& string_like)
-    noexcept(std::is_nothrow_constructible_v<literal_string<traits::maybe_owning_string<T>, char_encoding::standard>, T>)
+    noexcept(std::is_nothrow_constructible_v<literal_string<maybe_owning_string<T>, char_encoding::standard>, T>)
 {
     return {std::forward<T>(string_like)};
 }
@@ -52,15 +54,15 @@ string(char ch) noexcept
 
 // Optimize `literal_string{"c"}` into `literal_char{'c'}`
 [[nodiscard]] constexpr literal_char<char_encoding::standard, std::basic_string<char>>
-string(traits::X4VagueArrayOf2Chars<char> auto const& ch) noexcept
+string(X4VagueArrayOf2Chars<char> auto const& ch) noexcept
 {
     return {ch[0]};
 }
 
-template<traits::CppStringLike<char> T>
-[[nodiscard]] constexpr literal_string<traits::maybe_owning_string<T>, char_encoding::standard, unused_type>
+template<CppStringLike<char> T>
+[[nodiscard]] constexpr literal_string<maybe_owning_string<T>, char_encoding::standard, unused_type>
 lit(T&& string_like)
-    noexcept(std::is_nothrow_constructible_v<literal_string<traits::maybe_owning_string<T>, char_encoding::standard, unused_type>, T>)
+    noexcept(std::is_nothrow_constructible_v<literal_string<maybe_owning_string<T>, char_encoding::standard, unused_type>, T>)
 {
     return {std::forward<T>(string_like)};
 }
@@ -68,7 +70,7 @@ lit(T&& string_like)
 } // helpers
 
 template<class T>
-    requires traits::CharIncompatibleWith<T, char> || traits::StringLikeIncompatibleWith<T, char>
+    requires CharIncompatibleWith<T, char> || StringLikeIncompatibleWith<T, char>
 constexpr void string(T&&) = delete; // Mixing incompatible character types is not allowed
 
 } // standard
@@ -81,10 +83,10 @@ namespace standard_wide {
 
 inline namespace helpers {
 
-template<traits::CppStringLike<wchar_t> T>
-[[nodiscard]] constexpr literal_string<traits::maybe_owning_string<T>, char_encoding::standard_wide>
+template<CppStringLike<wchar_t> T>
+[[nodiscard]] constexpr literal_string<maybe_owning_string<T>, char_encoding::standard_wide>
 string(T&& string_like)
-    noexcept(std::is_nothrow_constructible_v<literal_string<traits::maybe_owning_string<T>, char_encoding::standard_wide>, T>)
+    noexcept(std::is_nothrow_constructible_v<literal_string<maybe_owning_string<T>, char_encoding::standard_wide>, T>)
 {
     return {std::forward<T>(string_like)};
 }
@@ -98,15 +100,15 @@ string(wchar_t ch) noexcept
 
 // Optimize `literal_string{L"c"}` into `literal_char{L'c'}`
 [[nodiscard]] constexpr literal_char<char_encoding::standard_wide, std::basic_string<wchar_t>>
-string(traits::X4VagueArrayOf2Chars<wchar_t> auto const& ch) noexcept
+string(X4VagueArrayOf2Chars<wchar_t> auto const& ch) noexcept
 {
     return {ch[0]};
 }
 
-template<traits::CppStringLike<wchar_t> T>
-[[nodiscard]] constexpr literal_string<traits::maybe_owning_string<T>, char_encoding::standard_wide, unused_type>
+template<CppStringLike<wchar_t> T>
+[[nodiscard]] constexpr literal_string<maybe_owning_string<T>, char_encoding::standard_wide, unused_type>
 lit(T&& string_like)
-    noexcept(std::is_nothrow_constructible_v<literal_string<traits::maybe_owning_string<T>, char_encoding::standard_wide, unused_type>, T>)
+    noexcept(std::is_nothrow_constructible_v<literal_string<maybe_owning_string<T>, char_encoding::standard_wide, unused_type>, T>)
 {
     return {std::forward<T>(string_like)};
 }
@@ -114,7 +116,7 @@ lit(T&& string_like)
 } // helpers
 
 template<class T>
-    requires traits::CharIncompatibleWith<T, wchar_t> || traits::StringLikeIncompatibleWith<T, wchar_t>
+    requires CharIncompatibleWith<T, wchar_t> || StringLikeIncompatibleWith<T, wchar_t>
 constexpr void string(T&&) = delete; // Mixing incompatible character types is not allowed
 
 } // standard_wide
@@ -129,10 +131,10 @@ namespace unicode {
 inline namespace helpers {
 
 // TODO: add `char8_t` and `char16_t` overloads
-template<traits::CppStringLike<char32_t> T>
-[[nodiscard]] constexpr literal_string<traits::maybe_owning_string<T>, char_encoding::unicode>
+template<CppStringLike<char32_t> T>
+[[nodiscard]] constexpr literal_string<maybe_owning_string<T>, char_encoding::unicode>
 string(T&& string_like)
-    noexcept(std::is_nothrow_constructible_v<literal_string<traits::maybe_owning_string<T>, char_encoding::unicode>, T>)
+    noexcept(std::is_nothrow_constructible_v<literal_string<maybe_owning_string<T>, char_encoding::unicode>, T>)
 {
     return {std::forward<T>(string_like)};
 }
@@ -146,15 +148,15 @@ string(char32_t ch) noexcept
 
 // Optimize `literal_string{U"c"}` into `literal_char{U'c'}`
 [[nodiscard]] constexpr literal_char<char_encoding::unicode, std::basic_string<char32_t>>
-string(traits::X4VagueArrayOf2Chars<char32_t> auto const& ch) noexcept
+string(X4VagueArrayOf2Chars<char32_t> auto const& ch) noexcept
 {
     return {ch[0]};
 }
 
-template<traits::CppStringLike<char32_t> T>
-[[nodiscard]] constexpr literal_string<traits::maybe_owning_string<T>, char_encoding::unicode, unused_type>
+template<CppStringLike<char32_t> T>
+[[nodiscard]] constexpr literal_string<maybe_owning_string<T>, char_encoding::unicode, unused_type>
 lit(T&& string_like)
-    noexcept(std::is_nothrow_constructible_v<literal_string<traits::maybe_owning_string<T>, char_encoding::unicode, unused_type>, T>)
+    noexcept(std::is_nothrow_constructible_v<literal_string<maybe_owning_string<T>, char_encoding::unicode, unused_type>, T>)
 {
     return {std::forward<T>(string_like)};
 }
@@ -162,7 +164,7 @@ lit(T&& string_like)
 } // helpers
 
 template<class T>
-    requires traits::CharIncompatibleWith<T, char32_t> || traits::StringLikeIncompatibleWith<T, char32_t>
+    requires CharIncompatibleWith<T, char32_t> || StringLikeIncompatibleWith<T, char32_t>
 constexpr void string(T&&) = delete; // Mixing incompatible character types is not allowed
 
 } // unicode
@@ -201,7 +203,7 @@ using x4::lit;
 
 namespace extension {
 
-template<traits::CharLike CharT, std::size_t N>
+template<CharLike CharT, std::size_t N>
 struct as_parser<CharT[N]>
 {
     using type = literal_string<std::basic_string_view<CharT>, traits::char_encoding_for<CharT>, unused_type>;
@@ -213,10 +215,10 @@ struct as_parser<CharT[N]>
     }
 };
 
-template<traits::CharLike CharT, std::size_t N>
+template<CharLike CharT, std::size_t N>
 struct as_parser<CharT const[N]> : as_parser<CharT[N]> {};
 
-template<traits::CharLike CharT>
+template<CharLike CharT>
 struct as_parser<CharT const*>
 {
     using type = literal_string<std::basic_string_view<CharT>, traits::char_encoding_for<CharT>, unused_type>;
@@ -228,7 +230,7 @@ struct as_parser<CharT const*>
     }
 };
 
-template<traits::CharLike CharT>
+template<CharLike CharT>
 struct as_parser<std::basic_string<CharT>>
 {
     using type = literal_string<std::basic_string<CharT>, traits::char_encoding_for<CharT>, unused_type>;
@@ -242,7 +244,7 @@ struct as_parser<std::basic_string<CharT>>
     }
 };
 
-template<traits::CharLike CharT>
+template<CharLike CharT>
 struct as_parser<std::basic_string_view<CharT>>
 {
     using type = literal_string<std::basic_string_view<CharT>, traits::char_encoding_for<CharT>, unused_type>;
diff --git a/include/iris/x4/symbols.hpp b/include/iris/x4/symbols.hpp
index ab325d5af..73a1ef2f8 100644
--- a/include/iris/x4/symbols.hpp
+++ b/include/iris/x4/symbols.hpp
@@ -17,8 +17,6 @@
 #include <iris/x4/core/unused.hpp>
 #include <iris/x4/core/move_to.hpp>
 
-#include <iris/x4/traits/string_traits.hpp>
-
 #include <iris/x4/string/tst.hpp>
 #include <iris/x4/string/case_compare.hpp>
 
@@ -312,14 +310,14 @@ struct symbols_parser_impl : parser<Derived>
     [[nodiscard]] constexpr value_type* find_impl(Iterator begin, Iterator end) noexcept
     {
         value_type* r = lookup->find(begin, end, case_compare<Encoding>());
-        return begin == end ? r : 0;
+        return begin == end ? r : nullptr;
     }
 
     template<std::forward_iterator Iterator>
     [[nodiscard]] constexpr value_type const* find_impl(Iterator begin, Iterator end) const noexcept
     {
         value_type const* r = lookup->find(begin, end, case_compare<Encoding>());
-        return begin == end ? r : 0;
+        return begin == end ? r : nullptr;
     }
 
     std::conditional_t<IsShared, std::shared_ptr<Lookup>, std::unique_ptr<Lookup>> lookup;
diff --git a/include/iris/x4/traits/char_encoding_traits.hpp b/include/iris/x4/traits/char_encoding_traits.hpp
index ff14fe981..cc8ac0adc 100644
--- a/include/iris/x4/traits/char_encoding_traits.hpp
+++ b/include/iris/x4/traits/char_encoding_traits.hpp
@@ -23,6 +23,20 @@ namespace iris::x4::traits {
 
 namespace detail {
 
+template<CharLike CharT> struct char_encoding_for_impl;
+template<> struct char_encoding_for_impl<char> { using type = char_encoding::standard; };
+
+#ifndef IRIS_X4_NO_STANDARD_WIDE
+template<> struct char_encoding_for_impl<wchar_t> { using type = char_encoding::standard_wide; };
+#endif
+
+#ifdef IRIS_X4_UNICODE
+template<> struct char_encoding_for_impl<char8_t> { using type = char_encoding::unicode; };
+template<> struct char_encoding_for_impl<char16_t> { using type = char_encoding::unicode; };
+template<> struct char_encoding_for_impl<char32_t> { using type = char_encoding::unicode; };
+#endif
+
+
 template<class Encoding>
 struct char_encoding_traits_impl
 {
@@ -45,6 +59,11 @@ struct char_encoding_traits_impl
 
 } // detail
 
+
+template<CharLike CharT>
+using char_encoding_for = typename detail::char_encoding_for_impl<CharT>::type;
+
+
 template<CharLike CharT>
 struct char_encoding_traits;
 
diff --git a/include/iris/x4/traits/string_traits.hpp b/include/iris/x4/traits/string_traits.hpp
deleted file mode 100644
index 639741877..000000000
--- a/include/iris/x4/traits/string_traits.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-#ifndef IRIS_ZZ_X4_TRAITS_STRING_TRAITS_HPP
-#define IRIS_ZZ_X4_TRAITS_STRING_TRAITS_HPP
-
-/*=============================================================================
-    Copyright (c) 2001-2014 Joel de Guzman
-    Copyright (c) 2001-2011 Hartmut Kaiser
-    Copyright (c) 2010 Bryce Lelbach
-    Copyright (c) 2025 Nana Sakisaka
-    Copyright (c) 2026 The Iris Project Contributors
-
-    Distributed under the Boost Software License, Version 1.0. (See accompanying
-    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-================================================_==============================*/
-
-#if defined(IRIS_UNICODE) && !defined(IRIS_X4_UNICODE)
-# error "`IRIS_UNICODE` has no effect on X4. #define `IRIS_X4_UNICODE`"
-#endif
-
-#if defined(IRIS_X3_UNICODE) && !defined(IRIS_X4_UNICODE)
-# error "`IRIS_X3_UNICODE` has no effect on X4. #define `IRIS_X4_UNICODE`"
-#endif
-
-#if defined(IRIS_NO_STANDARD_WIDE) && !defined(IRIS_X4_NO_STANDARD_WIDE)
-# error "`IRIS_NO_STANDARD_WIDE` has no effect on X4. #define `IRIS_X4_NO_STANDARD_WIDE`"
-#endif
-
-#if defined(IRIS_X3_NO_STANDARD_WIDE) && !defined(IRIS_X4_NO_STANDARD_WIDE)
-# error "`IRIS_X3_NO_STANDARD_WIDE` has no effect on X4. #define `IRIS_X4_NO_STANDARD_WIDE`"
-#endif
-
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <concepts>
-
-namespace iris::x4::char_encoding {
-
-struct standard;
-
-#ifndef IRIS_X4_NO_STANDARD_WIDE
-struct standard_wide;
-#endif
-
-#ifdef IRIS_X4_UNICODE
-struct unicode;
-#endif
-
-} // iris::x4::char_encoding
-
-namespace iris::x4::traits {
-
-template<class T>
-concept CharLike =
-    std::same_as<std::remove_cvref_t<T>, char> ||
-    std::same_as<std::remove_cvref_t<T>, wchar_t> ||
-    std::same_as<std::remove_cvref_t<T>, char8_t> ||
-    std::same_as<std::remove_cvref_t<T>, char16_t> ||
-    std::same_as<std::remove_cvref_t<T>, char32_t>;
-
-template<class T>
-concept CharArray =
-    std::is_array_v<std::remove_cvref_t<T>> &&
-    CharLike<std::remove_extent_t<std::remove_cvref_t<T>>>;
-
-// Spirit has historically converted "c" to 'c'.
-//
-// While we think it's still useful to retain the conversion,
-// we need to avoid further conversion to `std::basic_string_view`,
-// which leads to performance overhead. This trait enables
-// detection of such arrays.
-//
-// Note that the status quo introduces ambiguity in determining
-// {'c', '\0'} and {'c', 'd'}, but we're not aware of any practical
-// usage of non-null-terminated character array in the context of
-// DSL on parser combinator.
-//
-// However, if compelling use cases emerge, we may revise these
-// semantics. Versioned as `X4` for forward compatibility.
-template<class T, class CharT>
-concept X4VagueArrayOf2Chars =
-    std::same_as<std::remove_extent_t<std::remove_cvref_t<T>>, CharT> &&
-    std::is_bounded_array_v<std::remove_cvref_t<T>> &&
-    std::extent_v<std::remove_cvref_t<T>> == 2;
-
-// Main utility to guide `char_`, `lit` and `string` to be
-// resolved into either `x4::literal_char` or `x4::literal_string`.
-//
-// This may also be used in other codes which require the same
-// semantics.
-template<class T, class CharT>
-concept CppStringLike =
-    // This avoids converting `CharT[2]` to `std::basic_string_view`.
-    (!X4VagueArrayOf2Chars<T, CharT>) &&
-    // All other types that are *naturally* convertible to `std::basic_string_view`.
-    std::convertible_to<std::decay_t<T>, std::basic_string_view<CharT>>;
-
-// Mixing incompatible character types is semantically wrong.
-// Don't do that. It may even lead to security vulnerabilities.
-template<class T, class ExpectedCharT>
-concept CharIncompatibleWith =
-    CharLike<T> &&
-    !std::same_as<T, ExpectedCharT>;
-
-// Mixing incompatible character types is semantically wrong.
-// Don't do that. It may even lead to security vulnerabilities.
-template<class T, class ExpectedCharT>
-concept StringLikeIncompatibleWith =
-    CharLike<std::remove_const_t<std::remove_pointer_t<std::decay_t<T>>>> &&
-    !std::convertible_to<T, std::basic_string_view<ExpectedCharT>>;
-
-namespace detail {
-    template<CharLike CharT> struct char_encoding_for_impl;
-    template<> struct char_encoding_for_impl<char> { using type = char_encoding::standard; };
-
-#ifndef IRIS_X4_NO_STANDARD_WIDE
-    template<> struct char_encoding_for_impl<wchar_t> { using type = char_encoding::standard_wide; };
-#endif
-
-#ifdef IRIS_X4_UNICODE
-    template<> struct char_encoding_for_impl<char8_t> { using type = char_encoding::unicode; };
-    template<> struct char_encoding_for_impl<char16_t> { using type = char_encoding::unicode; };
-    template<> struct char_encoding_for_impl<char32_t> { using type = char_encoding::unicode; };
-#endif
-} // detail
-
-template<class T>
-using maybe_owning_string = std::conditional_t<
-    std::is_pointer_v<std::decay_t<T>>,
-    std::basic_string_view<std::remove_const_t<std::remove_pointer_t<std::decay_t<T>>>>,
-    std::remove_cvref_t<T>
->;
-
-template<CharLike CharT>
-using char_encoding_for = typename detail::char_encoding_for_impl<CharT>::type;
-
-} // iris::x4::traits
-
-#endif
diff --git a/modules/iris b/modules/iris
index 8104bf726..8dfa73a34 160000
--- a/modules/iris
+++ b/modules/iris
@@ -1 +1 @@
-Subproject commit 8104bf726122384bea8e18feac2d956ffa26bf7f
+Subproject commit 8dfa73a34bbb707b7f7ef4ddef77f810a6d15a23
diff --git a/test/x4/bool.cpp b/test/x4/bool.cpp
index f46949379..12b2fb927 100644
--- a/test/x4/bool.cpp
+++ b/test/x4/bool.cpp
@@ -46,12 +46,6 @@ TEST_CASE("bool")
     using x4::false_;
     using x4::no_case;
 
-    static_assert(x4::detail::BoolPolicy<x4::bool_policies<>, x4::char_encoding::standard>);
-    static_assert(x4::detail::BoolPolicy<x4::bool_policies<>, x4::char_encoding::standard_wide>);
-    static_assert(x4::detail::BoolPolicy<x4::bool_policies<>, x4::char_encoding::unicode>);
-
-    static_assert(x4::detail::BoolPolicy<backwards_bool_policies, x4::char_encoding::standard>);
-
     {
         IRIS_X4_ASSERT_CONSTEXPR_CTORS(bool_);
 
@@ -91,7 +85,7 @@ TEST_CASE("bool")
     }
 
     {
-        using backwards_bool_type = x4::bool_parser<bool, x4::char_encoding::standard, backwards_bool_policies>;
+        using backwards_bool_type = x4::bool_parser<bool, backwards_bool_policies>;
         constexpr backwards_bool_type backwards_bool{};
 
         IRIS_X4_ASSERT_CONSTEXPR_CTORS(backwards_bool);
@@ -124,7 +118,7 @@ TEST_CASE("bool")
             bool b;
         };
 
-        using bool_test_type = x4::bool_parser<test_bool_type, x4::char_encoding::standard>;
+        using bool_test_type = x4::bool_parser<test_bool_type>;
         constexpr bool_test_type test_bool{};
 
         IRIS_X4_ASSERT_CONSTEXPR_CTORS(test_bool);