named_type.hpp

// Copyright (c) 2023 Martin Stump
// SPDX-License-Identifier: BSL-1.0
 
#pragma once
 
#include <algorithm>
#include <compare>
#include <concepts>
#include <cstddef>
#include <format>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <ranges>
#include <string_view>
#include <type_traits>
#include <utility>
 
#include "gw/concepts.hpp"
#include "gw/inplace_string.hpp"
 
namespace gw {
 
namespace detail {
 
struct named_type_empty_base {
  constexpr auto operator<=>(const named_type_empty_base&) const noexcept -> std::strong_ordering = default;
};
 
}  // namespace detail
 
//
//
//
template <typename T, basic_inplace_string Name>
class named_type final
    : public std::conditional_t<std::ranges::range<T>, std::ranges::view_interface<named_type<T, Name>>,
                                detail::named_type_empty_base> {
 public:
  //
  // Public types
  //
 
  using value_type = T;                       
  using reference = value_type&;              
  using const_reference = const value_type&;  
  using pointer = value_type*;                
  using const_pointer = const value_type*;    
 
  //
  // Constructors
  //
 
  template <typename... Args>
  constexpr explicit named_type(Args&&... args) noexcept(std::is_nothrow_constructible_v<value_type, Args...>)
    requires std::constructible_from<value_type, Args...>
      : m_value(value_type{std::forward<Args>(args)...}) {}
 
  template <typename U, typename... Args>
  constexpr named_type(std::initializer_list<U> ilist, Args&&... args) noexcept(
      std::is_nothrow_constructible_v<value_type, std::initializer_list<U>&, Args...>)
    requires std::constructible_from<value_type, std::initializer_list<U>&, Args...>
      : m_value(value_type{ilist, std::forward<Args>(args)...}) {}
 
  //
  // Destructor
  //
 
  ~named_type() noexcept(std::is_nothrow_destructible_v<value_type>) = default;
 
  //
  // Static functions
  //
 
  static constexpr auto name() noexcept { return Name.view(); }
 
  //
  // Observers
  //
 
  constexpr auto operator->() const noexcept -> const_pointer { return &m_value; }
 
  constexpr auto operator->() noexcept -> pointer { return &m_value; }
 
  constexpr auto operator*() const& noexcept -> const_reference { return m_value; }
 
  constexpr auto operator*() & noexcept -> reference { return m_value; }
 
  constexpr auto operator*() const&& noexcept -> const value_type&& { return std::move(m_value); }
 
  constexpr auto operator*() && noexcept -> value_type&& { return std::move(m_value); }
 
  constexpr auto value() const& noexcept -> const_reference { return m_value; }
 
  constexpr auto value() & noexcept -> reference { return m_value; }
 
  constexpr auto value() const&& noexcept -> const value_type&& { return std::move(m_value); }
 
  constexpr auto value() && noexcept -> value_type&& { return std::move(m_value); }
 
  //
  // Monadic operations
  //
 
  template <typename F>
  constexpr auto transform(F&& func) const& noexcept(noexcept(func(m_value))) -> named_type
    requires std::invocable<F, const_reference>
  {
    return named_type<std::remove_cv_t<std::invoke_result_t<F, const_reference>>, Name>{func(m_value)};
  }
 
  template <typename F>
  constexpr auto transform(F&& func) & noexcept(noexcept(func(m_value))) -> named_type
    requires std::invocable<F, reference>
  {
    return named_type<std::remove_cv_t<std::invoke_result_t<F, reference>>, Name>{func(m_value)};
  }
 
  template <typename F>
  constexpr auto transform(F&& func) const&& noexcept(noexcept(func(m_value))) -> named_type
    requires std::invocable<F, const value_type&&>
  {
    return named_type<std::remove_cv_t<std::invoke_result_t<F, const value_type&&>>, Name>{func(std::move(m_value))};
  }
 
  template <typename F>
  constexpr auto transform(F&& func) && noexcept(noexcept(func(m_value))) -> named_type
    requires std::invocable<F, value_type&&>
  {
    return named_type<std::remove_cv_t<std::invoke_result_t<F, value_type&&>>, Name>{func(std::move(m_value))};
  }
 
  //
  // Modifiers
  //
 
  constexpr void swap(named_type& rhs) noexcept(std::is_nothrow_swappable_v<value_type>)
    requires std::swappable<value_type>
  {
    using std::swap;
    swap(m_value, rhs.m_value);
  }
 
  constexpr void reset() noexcept(std::is_nothrow_default_constructible_v<value_type>)
    requires std::default_initializable<value_type>
  {
    m_value = value_type{};
  }
 
  template <typename... Args>
  constexpr auto emplace(Args&&... args) noexcept(std::is_nothrow_constructible_v<value_type, Args...>) -> reference
    requires std::constructible_from<value_type, Args...>
  {
    m_value = value_type{std::forward<Args>(args)...};
    return m_value;
  }
 
  //
  // Comparison operators
  //
 
  constexpr auto operator==(const named_type& rhs) const& noexcept(noexcept(m_value == rhs.m_value)) -> bool
    requires std::equality_comparable<value_type>
  {
    return m_value == rhs.m_value;
  }
 
  constexpr auto operator!=(const named_type& rhs) const& noexcept(noexcept(m_value != rhs.m_value)) -> bool
    requires std::equality_comparable<value_type>
  {
    return m_value != rhs.m_value;
  }
 
  constexpr auto operator<(const named_type& rhs) const& noexcept(noexcept(m_value < rhs.m_value)) -> bool
    requires std::totally_ordered<value_type>
  {
    return m_value < rhs.m_value;
  }
 
  constexpr auto operator>(const named_type& rhs) const& noexcept(noexcept(m_value > rhs.m_value)) -> bool
    requires std::totally_ordered<value_type>
  {
    return m_value > rhs.m_value;
  }
 
  constexpr auto operator<=(const named_type& rhs) const& noexcept(noexcept(m_value <= rhs.m_value)) -> bool
    requires std::totally_ordered<value_type>
  {
    return m_value <= rhs.m_value;
  }
 
  constexpr auto operator>=(const named_type& rhs) const& noexcept(noexcept(m_value >= rhs.m_value)) -> bool
    requires std::totally_ordered<value_type>
  {
    return m_value >= rhs.m_value;
  }
 
  constexpr auto operator<=>(const named_type& rhs) const& noexcept(noexcept(m_value <=>
                                                                             rhs.m_value)) -> std::strong_ordering
    requires std::three_way_comparable<value_type>
  {
    return m_value <=> rhs.m_value;
  }
 
  //
  // Conversion operators
  //
 
  constexpr explicit operator const_reference() const& noexcept { return m_value; }
 
  constexpr explicit operator reference() & noexcept { return m_value; }
 
  constexpr explicit operator const value_type&&() const&& noexcept { return std::move(m_value); }
 
  constexpr explicit operator value_type&&() && noexcept { return std::move(m_value); }
 
  //
  // Increment and decrement operators
  //
 
  constexpr auto operator++() & noexcept(noexcept(++m_value)) -> named_type&
    requires incrementable<value_type>
  {
    ++m_value;
    return *this;
  }
 
  constexpr auto operator++() && noexcept(noexcept(++m_value)) -> named_type&&
    requires incrementable<value_type>
  {
    ++m_value;
    return std::move(*this);
  }
 
  constexpr auto operator++(int) & noexcept(noexcept(m_value++)) -> named_type
    requires incrementable<value_type>
  {
    return named_type{m_value++};
  }
 
  constexpr auto operator++(int) && noexcept(noexcept(m_value++)) -> named_type
    requires incrementable<value_type>
  {
    return named_type{m_value++};
  }
 
  constexpr auto operator--() & noexcept(noexcept(--m_value)) -> named_type&
    requires decrementable<value_type>
  {
    --m_value;
    return *this;
  }
 
  constexpr auto operator--() && noexcept(noexcept(--m_value)) -> named_type&&
    requires decrementable<value_type>
  {
    --m_value;
    return std::move(*this);
  }
 
  constexpr auto operator--(int) & noexcept(noexcept(m_value--)) -> named_type
    requires decrementable<value_type>
  {
    return named_type{m_value--};
  }
 
  constexpr auto operator--(int) && noexcept(noexcept(m_value--)) -> named_type
    requires decrementable<value_type>
  {
    return named_type{m_value--};
  }
 
  //
  // Arithmetic operators
  //
 
  constexpr auto operator+() const& noexcept(noexcept(+m_value)) -> named_type
    requires std::signed_integral<value_type>
  {
    return named_type{+m_value};
  }
 
  constexpr auto operator+() && noexcept(noexcept(+m_value)) -> named_type
    requires std::signed_integral<value_type>
  {
    return named_type{+m_value};
  }
 
  constexpr auto operator-() const& noexcept(noexcept(-m_value)) -> named_type
    requires std::signed_integral<value_type>
  {
    return named_type{-m_value};
  }
 
  constexpr auto operator-() && noexcept(noexcept(-m_value)) -> named_type
    requires std::signed_integral<value_type>
  {
    return named_type{-m_value};
  }
 
  constexpr auto operator+(const named_type& rhs) const& noexcept(noexcept(m_value + rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value + rhs.m_value};
  }
 
  constexpr auto operator+(named_type&& rhs) const& noexcept(noexcept(m_value + rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value + rhs.m_value};
  }
 
  constexpr auto operator+(const named_type& rhs) && noexcept(noexcept(m_value + rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value + rhs.m_value};
  }
 
  constexpr auto operator+(named_type&& rhs) && noexcept(noexcept(m_value + rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value + rhs.m_value};
  }
 
  constexpr auto operator-(const named_type& rhs) const& noexcept(noexcept(m_value - rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value - rhs.m_value};
  }
 
  constexpr auto operator-(named_type&& rhs) const& noexcept(noexcept(m_value - rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value - rhs.m_value};
  }
 
  constexpr auto operator-(const named_type& rhs) && noexcept(noexcept(m_value - rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value - rhs.m_value};
  }
 
  constexpr auto operator-(named_type&& rhs) && noexcept(noexcept(m_value - rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value - rhs.m_value};
  }
 
  constexpr auto operator*(const named_type& rhs) const& noexcept(noexcept(m_value * rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value * rhs.m_value};
  }
 
  constexpr auto operator*(named_type&& rhs) const& noexcept(noexcept(m_value * rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value * rhs.m_value};
  }
 
  constexpr auto operator*(const named_type& rhs) && noexcept(noexcept(m_value * rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value * rhs.m_value};
  }
 
  constexpr auto operator*(named_type&& rhs) && noexcept(noexcept(m_value * rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value * rhs.m_value};
  }
 
  constexpr auto operator/(const named_type& rhs) const& noexcept(noexcept(m_value / rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value / rhs.m_value};
  }
 
  constexpr auto operator/(named_type&& rhs) const& noexcept(noexcept(m_value / rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value / rhs.m_value};
  }
 
  constexpr auto operator/(const named_type& rhs) && noexcept(noexcept(m_value / rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value / rhs.m_value};
  }
 
  constexpr auto operator/(named_type&& rhs) && noexcept(noexcept(m_value / rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value / rhs.m_value};
  }
 
  constexpr auto operator%(const named_type& rhs) const& noexcept(noexcept(m_value % rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value % rhs.m_value};
  }
 
  constexpr auto operator%(named_type&& rhs) const& noexcept(noexcept(m_value % rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value % rhs.m_value};
  }
 
  constexpr auto operator%(const named_type& rhs) && noexcept(noexcept(m_value % rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value % rhs.m_value};
  }
 
  constexpr auto operator%(named_type&& rhs) && noexcept(noexcept(m_value % rhs.m_value)) -> named_type
    requires arithmetic<value_type>
  {
    return named_type{m_value % rhs.m_value};
  }
 
  constexpr auto operator+=(const named_type& rhs) & noexcept(noexcept(m_value += rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value += rhs.m_value;
    return *this;
  }
 
  constexpr auto operator+=(named_type&& rhs) & noexcept(noexcept(m_value += rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value += rhs.m_value;
    return *this;
  }
 
  constexpr auto operator-=(const named_type& rhs) & noexcept(noexcept(m_value -= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value -= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator-=(named_type&& rhs) & noexcept(noexcept(m_value -= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value -= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator*=(const named_type& rhs) & noexcept(noexcept(m_value *= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value *= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator*=(named_type&& rhs) & noexcept(noexcept(m_value *= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value *= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator/=(const named_type& rhs) & noexcept(noexcept(m_value /= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value /= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator/=(named_type&& rhs) & noexcept(noexcept(m_value /= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value /= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator%=(const named_type& rhs) & noexcept(noexcept(m_value %= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value %= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator%=(named_type&& rhs) & noexcept(noexcept(m_value %= rhs.m_value)) -> named_type&
    requires arithmetic<value_type>
  {
    m_value %= rhs.m_value;
    return *this;
  }
 
  //
  // Bitwise operators
  //
 
  constexpr auto operator~() const& noexcept(noexcept(~m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{~m_value};
  }
 
  constexpr auto operator&(const named_type& rhs) const& noexcept(noexcept(m_value & rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value & rhs.m_value};
  }
 
  constexpr auto operator&(named_type&& rhs) const& noexcept(noexcept(m_value & rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value & rhs.m_value};
  }
 
  constexpr auto operator&(const named_type& rhs) && noexcept(noexcept(m_value & rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value & rhs.m_value};
  }
 
  constexpr auto operator&(named_type&& rhs) && noexcept(noexcept(m_value & rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value & rhs.m_value};
  }
 
  constexpr auto operator|(const named_type& rhs) const& noexcept(noexcept(m_value | rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value | rhs.m_value};
  }
 
  constexpr auto operator|(named_type&& rhs) const& noexcept(noexcept(m_value | rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value | rhs.m_value};
  }
 
  constexpr auto operator|(const named_type& rhs) && noexcept(noexcept(m_value | rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value | rhs.m_value};
  }
 
  constexpr auto operator|(named_type&& rhs) && noexcept(noexcept(m_value | rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value | rhs.m_value};
  }
 
  constexpr auto operator^(const named_type& rhs) const& noexcept(noexcept(m_value ^ rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value ^ rhs.m_value};
  }
 
  constexpr auto operator^(named_type&& rhs) const& noexcept(noexcept(m_value ^ rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value ^ rhs.m_value};
  }
 
  constexpr auto operator^(const named_type& rhs) && noexcept(noexcept(m_value ^ rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value ^ rhs.m_value};
  }
 
  constexpr auto operator^(named_type&& rhs) && noexcept(noexcept(m_value ^ rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value ^ rhs.m_value};
  }
 
  constexpr auto operator<<(const named_type& rhs) const& noexcept(noexcept(m_value << rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value << rhs.m_value};
  }
 
  constexpr auto operator<<(named_type&& rhs) const& noexcept(noexcept(m_value << rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value << rhs.m_value};
  }
 
  constexpr auto operator<<(const named_type& rhs) && noexcept(noexcept(m_value << rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value << rhs.m_value};
  }
 
  constexpr auto operator<<(named_type&& rhs) && noexcept(noexcept(m_value << rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value << rhs.m_value};
  }
 
  constexpr auto operator>>(const named_type& rhs) const& noexcept(noexcept(m_value >> rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value >> rhs.m_value};
  }
 
  constexpr auto operator>>(named_type&& rhs) const& noexcept(noexcept(m_value >> rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value >> rhs.m_value};
  }
 
  constexpr auto operator>>(const named_type& rhs) && noexcept(noexcept(m_value >> rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value >> rhs.m_value};
  }
 
  constexpr auto operator>>(named_type&& rhs) && noexcept(noexcept(m_value >> rhs.m_value)) -> named_type
    requires std::unsigned_integral<value_type>
  {
    return named_type{m_value >> rhs.m_value};
  }
 
  constexpr auto operator&=(const named_type& rhs) & noexcept(noexcept(m_value &= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value &= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator&=(named_type&& rhs) & noexcept(noexcept(m_value &= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value &= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator|=(const named_type& rhs) & noexcept(noexcept(m_value |= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value |= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator|=(named_type&& rhs) & noexcept(noexcept(m_value |= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value |= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator^=(const named_type& rhs) & noexcept(noexcept(m_value ^= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value ^= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator^=(named_type&& rhs) & noexcept(noexcept(m_value ^= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value ^= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator<<=(const named_type& rhs) & noexcept(noexcept(m_value <<= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value <<= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator<<=(named_type&& rhs) & noexcept(noexcept(m_value <<= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value <<= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator>>=(const named_type& rhs) & noexcept(noexcept(m_value >>= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value >>= rhs.m_value;
    return *this;
  }
 
  constexpr auto operator>>=(named_type&& rhs) & noexcept(noexcept(m_value >>= rhs.m_value)) -> named_type&
    requires std::unsigned_integral<value_type>
  {
    m_value >>= rhs.m_value;
    return *this;
  }
 
  //
  // Ranges interface
  //
 
  constexpr auto begin() const noexcept(noexcept(std::ranges::begin(m_value)))
    requires std::ranges::range<value_type>
  {
    return std::ranges::begin(m_value);
  }
 
  constexpr auto begin() noexcept(noexcept(std::ranges::begin(m_value)))
    requires std::ranges::range<value_type>
  {
    return std::ranges::begin(m_value);
  }
 
  constexpr auto end() const noexcept(noexcept(std::ranges::end(m_value)))
    requires std::ranges::range<value_type>
  {
    return std::ranges::end(m_value);
  }
 
  constexpr auto end() noexcept(noexcept(std::ranges::end(m_value)))
    requires std::ranges::range<value_type>
  {
    return std::ranges::end(m_value);
  }
 
  //
  // Stream operators
  //
 
  friend inline auto operator<<(std::ostream& ostream,
                                const named_type& rhs) noexcept(noexcept(ostream << rhs.m_value)) -> std::ostream&
    requires ostreamable<value_type>
  {
    return ostream << rhs.m_value;
  }
 
  friend inline auto operator>>(std::istream& istream,
                                named_type& rhs) noexcept(noexcept(istream >> rhs.m_value)) -> std::istream&
    requires istreamable<value_type>
  {
    return istream >> rhs.m_value;
  }
 
 private:
  value_type m_value{};
};
 
template <basic_inplace_string Name, typename T, typename... Args>
constexpr auto make_named_type(Args&&... args) noexcept(std::is_nothrow_constructible_v<T, Args...>)
  requires std::constructible_from<std::remove_cvref_t<T>, Args...>
{
  return named_type<std::remove_cvref_t<T>, Name>{std::forward<Args>(args)...};
}
 
template <basic_inplace_string Name, typename T, typename U, typename... Args>
constexpr auto make_named_type(std::initializer_list<U> ilist, Args&&... args) noexcept(
    std::is_nothrow_constructible_v<T, std::initializer_list<U>&, Args...>)
  requires std::constructible_from<T, std::initializer_list<U>&, Args...>
{
  return named_type<std::remove_cvref_t<T>, Name>{ilist, std::forward<Args>(args)...};
}
 
template <basic_inplace_string Name, typename T>
constexpr auto make_named_type(T&& value) noexcept(
    std::is_nothrow_constructible_v<named_type<std::remove_cvref_t<T>, Name>, T>)
  requires std::constructible_from<std::remove_cvref_t<T>, T>
{
  return named_type<std::remove_cvref_t<T>, Name>{std::forward<T>(value)};
}
 
}  // namespace gw
 
namespace std {
 
template <::gw::hashable T, ::gw::basic_inplace_string Name>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct hash<::gw::named_type<T, Name>> {
  [[nodiscard]] auto inline operator()(const ::gw::named_type<T, Name>& named_type) const noexcept -> size_t {
    using value_type = std::remove_cvref_t<T>;
    using name_type = std::remove_cvref_t<decltype(Name)>;
    auto value_hash = hash<value_type>{}(named_type.value());
    auto name_hash = hash<name_type>{}(named_type.name());
    return value_hash ^ name_hash;
  }
};
 
template <typename T, ::gw::basic_inplace_string Name, class CharT>
// NOLINTNEXTLINE(cert-dcl58-cpp)
struct formatter<::gw::named_type<T, Name>, CharT> {
  bool with_name{};  
 
  template <class ParseContext>
  constexpr auto parse(ParseContext& context) -> ParseContext::iterator {
    auto it = context.begin();
    if (it == context.end()) {
      return it;
    }
 
    if (*it == '#') {
      with_name = true;
      ++it;
    }
 
    if (it != context.end() && *it != '}') {
      throw std::format_error("Invalid format args for gw::named_type.");
    }
 
    return it;
  }
 
  template <class FormatContext>
  auto format(const ::gw::named_type<T, Name>& named_type, FormatContext& context) const -> FormatContext::iterator
#if __cplusplus > 202002L
    requires std::formattable<T, CharT>
#endif  // __cplusplus > 202002L
  {
    if (with_name) {
      return format_to(context.out(), "{}: {}", named_type.name(), named_type.value());
    }
 
    return format_to(context.out(), "{}", named_type.value());
  }
};
 
}  // namespace std