namespace other_a {
namespace other_b {

struct Point {
  float x;
  float y;
  float z;
};
// REFL_AUTO(type(Point), field(x), field(y), field(z)) // <- would like to define it here

// [..] many unrelated lines of code [..]

} // namespace other_a
} // namespace other_b

REFL_AUTO(type(Point), field(x), field(y), field(z)) // <- have to define it here (global namespace)

 template <typename ...Ts>
 using meta::map = std::tuple<Ts...>;

struct transform_2d
    {
        transform_2d() noexcept = default;

        transform_2d(float x_,
                     float y_, float width_, float height_, float scale_x_, float scale_y_,
                     float angle_) noexcept :
            x(x_),
            y(y_),
            width(width_),
            height(height_),
            scale_x(scale_x_),
            scale_y(scale_y_),
            angle(angle_),
            original_x(x_)
        {
        }

        float x{0.0f}; //!< x
        float y{0.0f}; //!< y
        float width{0.0f};
        float height{0.0f};
        float scale_x{1.0f};
        float scale_y{1.0f};
        float angle{0.0f};
        bool rotating{false};

        //! Original (mutable because of EnTT, (should not be modified))
        mutable float original_x{x};
        mutable float original_y{y};
        mutable float original_width{width};
        mutable float original_height{height};

        reflect_class(transform_2d)

        static constexpr auto reflected_functions() noexcept
        {
            return meta::makeMap();
        }

        static constexpr auto reflected_members() noexcept
        {
            return meta::makeMap(reflect_member(&transform_2d::y),
                                 reflect_member(&transform_2d::x),
                                 reflect_member(&transform_2d::width),
                                 reflect_member(&transform_2d::height),
                                 reflect_member(&transform_2d::scale_x),
                                 reflect_member(&transform_2d::scale_y),
                                 reflect_member(&transform_2d::angle),
                                 reflect_member(&transform_2d::rotating));
        }
    };


 template <typename T>
    void register_type(sol::state &state, shiva::logging::logger logger) noexcept
    {
        const auto table = std::tuple_cat(
            std::make_tuple(T::class_name()),
            T::reflected_functions(),
            T::reflected_members());

        try {
            std::apply(
                [&state](auto &&...params) {
                    state.new_usertype<T>(std::forward<decltype(params)>(params)...);
                }, table);
        }
        catch (const std::exception &error) {
            logger->error("error: {}", error.what());
            return;
        }

        logger->info("successfully registering type: {}", T::class_name());
    }


register_type<transform2d>();

new_usertype<transform_2d>("transform_2d",
		"x", &my_class::x,
		"y", &my_class::y); /

/**
             * Explicitly converts to std::string.
             */
            explicit constexpr operator std::string() const noexcept
            {
                return data;
            }

REFL_TYPE(MyType)
   REFL_FUNC(Func1)
   ...
   REFL_FUNC(Func193)
REFL_END

/* fantasy syntax: see edit above. This makes no sense based on that edit, but it was my original post. */

REFL_AUTO
(
   type(mytype, continues()),
   func(func1),
   ...
   func(func99)
)

REFL_CONTINUES
(
   type(mytype),   // plus, ideally, the option to continue again with continues()
   func(func101),
   ...
)

for_each(refl::reflect(x).members, [&](auto member) {
	if constexpr (std::is_same<member.type, bool>) { // or member.typename == "bool"
		std::cout << "bool " << member.name << " = " << (member(x) ? "true" : "false") << ";";
	}
});

class Circle {
    double r;
public:
    Circle(double val) : r(val) {}
    double getRadius() const { return r; }
    void setRadius(double radius) { r = radius; }
    std::string getFunc(int a, double b, std::string c) const { return fmt::format("{}{}{}",a,b,c); }
    double getDiameter() const { return 2 * r; }
    double getArea() const { return M_PI * r * r; }
};

using refl::reflect;
using refl::util::find_one;
constexpr auto type = reflect<Circle>();
 
constexpr auto func = find_one(type.members, [](auto m) { return m.name == "getRadius"; }); // -> function_descriptor<Circle, 0>{...}

func.name; // -> const_string<6>{"getRadius"}
func.attributes; // -> std::tuple<>{}
func.is_resolved; // -> true
func.pointer; // -> pointer of type double (Circle::* const)()
 
using radius_t = double (Circle::* const)();
func.template resolve<radius_t>; // -> pointer of type radius_t on success, nullptr_t on fail.
 
Circle c(2.0);
func.invoke(c); // -> the result of c.getRadius()

struct foo {
   int _bar;
   int get_bar() const {return _bar;}
   void set_bar(int val) {_bar = val;}
};
REFL_AUTO
(
   type(foo),
   func(get_bar, property()),
   func(set_bar, property())
)
template<class T>
static void ProcessClass()
{
   constexpr auto type = refl::reflect<T>();
   constexpr auto members = get_members(type);

   for_each(members, [&](auto member)
   {
      if constexpr (refl::descriptor::is_property(member) && !refl::descriptor::is_writable(member))
      {
         constexpr auto propertyName = refl::descriptor::get_display_name_const(member);
         constexpr auto setters = filter(get_members(refl::reflect<T>()), [&propertyName](auto chkMember) {
            if constexpr (!refl::descriptor::is_property(chkMember) || !refl::descriptor::is_writable(chkMember))
               return false;
            constexpr auto candidateName = refl::descriptor::get_display_name_const(chkMember);
            // This line generates C2131 expression did not evaluate to a constant (in Visual Studio 2019)
            // Comment it out and the code compiles
            if constexpr (propertyName == candidateName) return true;
            return false;
            });
      }
   });
}
static void my_runtime_func()
{
   ProcessClass<foo>();
}

struct foo {
   int _bar;
   int get_bar() const {return _bar;}
   void set_bar(int val) {_bar = val;}
};
REFL_AUTO
(
   type(foo),
   func(get_bar, property()),
   func(set_bar, property())
)
template<class T>
static void ProcessClass()
{
   constexpr auto type = refl::reflect<T>();
   constexpr auto members = get_members(type);

   for_each(members, [&](auto member)
   {
      if constexpr (refl::descriptor::is_property(member) && ! refl::descriptor::is_writable(member))
      {
         // this line causes compile errors on Visual Studio 2019
         // comment it out and the program compiles without error   
         constexpr auto prop_name = refl::descriptor::get_display_name_const(member);
      }
   });
}
static void my_runtime_func()
{
   ProcessClass<foo>();
}

#include <https://raw.githubusercontent.com/veselink1/refl-cpp/master/include/refl.hpp>
#include <iostream>
#include <fmt/format.h>

struct Point {
    int e0 = 1;
    int e1 = 2;
    int e2 = 3;
};
REFL_AUTO(type(Point),field(e0),field(e1),field(e2))

constexpr auto type = refl::reflect<Point>();

template<typename T>
int setField(const T& value, const std::string_view fieldName /* unused */) {
    constexpr auto field = refl::util::find_one(refl::reflect<T>().members, [&fieldName](auto m) { return m.name == "e0"; }); // N.B static field name
    // field(value) = ... ; // write data to member field (run-time)
    return field(value);
}

template<typename T>
int setField2(const T& value, const std::string_view fieldName) {
    auto field = refl::util::find_one(refl::reflect<T>().members, [&fieldName](auto m) { return m.name.str() == fieldName; }); // does not work/not constexpr
    //field(value) = ; // write data to member field (run-time)
    return field(value);
}

template<typename T>
int setField3(const T& value, const std::string_view fieldName) {
    int retValue = -1;
    refl::util::for_each(refl::reflect<T>().members, [&fieldName, &value, &retValue](auto field) {
            if (field.name.str() == fieldName) { // comparison OK but looping over each field              
                //field(value) = ; // write data to member field (run-time)
                retValue = field(value);
            }
    });
    
    return retValue;
}


int main(int argc, const char** argv) {
    Point a;
    const std::string fieldName = fmt::format("e{}", argc); // stand-in for dynamic data

    std::cout << "looking for " << fieldName << '\n';
    std::cout << setField(a, fieldName) << '\n'; // OK -- works but only for static field mappings
    // std::cout << setField2(a, fieldName) << '\n'; // does non work because of non-constexpr filter criteria
    std::cout << setField3(a, fieldName) << '\n'; // OK -- but loops through all member fields (ie. no early return)
}

#define REFL_METADATA_FILE "reflmd/main.cpp"
#include "libs/refl.hpp"
#include <iostream>

struct pdu_types_struct
{
    REFL() // the reflmd file has been generated
    int var1= 28;
};

struct pdu_types_struct pdu_types;

int main(int argc, char **argv)
{
     for_each(refl::reflect(pdu_types).members, [&](auto member) {
      std::cout << member.name << "=" << member(pdu_types) << ";";
   });
    return 0;
} 

#include REFL_METADATA_FILE

	template <Checksum CRC, char... Chars> struct Crc32Impl
	{
	};

	template <Checksum CRC, char Head, char... Tail> struct Crc32Impl<CRC, Head, Tail...>
	{
		static constexpr Checksum value = Crc32Impl<crcTable[static_cast<unsigned char>(CRC) ^ static_cast<unsigned char>(Head)] ^ (CRC >> 8), Tail...>::value;
	};

	template <Checksum CRC> struct Crc32Impl<CRC>
	{
		static constexpr Checksum value = CRC ^ 0xFFFFFFFF;
	};

	template <char... Chars> using Crc32 = Crc32Impl<0xFFFFFFFF, Chars...>;

	constexpr Checksum Crc32Rec(const char * s, const Checksum crc = 0xFFFFFFFF) noexcept
	{
		return *s == 0 ? crc ^ 0xFFFFFFFF : Crc32Rec(s + 1, crcTable[static_cast<unsigned char>(crc) ^ static_cast<unsigned char>(*s)] ^ (crc >> 8));
	}

class MyClass
{
public:
   void SetDateFormat(int x);
   int GetDateFormat() const;
...
  // many dozens more getters and setters so that REFL_AUTO is not an option, if it matters.
};

REFL_TYPE(MyClass)
   REFL_FUNC(SetDateFormat, property())
   REFL_FUNC(GetDateFormat, property())
... // a lot more
REFL_END

constexpr auto type = refl::reflect<MyClass>();
constexpr auto members = get_members(type);

for_each(members, [&](auto member)
{
   if constexpr (refl::descriptor::is_property(member)
      if constexpr (refl::descriptor::is_writable(member))
      {
         auto reader = refl::descriptor::get_reader(member); // fails in Windows VS 2022
      }
      else
         ...
});

    struct address {
        std::string city;
    };

    struct person {
        address addr;
    };

template <typename T>
void myBindMembers(T *instance)
{
	for_each(refl::reflect<T>().baseClasses, [&](auto baseClass) {
		// Call recursive to catch all
		myBindMembers((typename decltype(baseClass)::value_type*) instance);		
	})
	// Access Attributes of base Type
	// Bind all members defined in the instance and it's base classes.
	
}

struct MyBase{
	int BaseA;
	int BaseB;
};

REFL_TYPE(MyBase, attr("Attribute for BaseA and BaseB"))
REFL_FIELD(BaseA)
REFL_FIELD(BaseB)
REFL_END

struct Sub{
	int SubC;
};

REFL_TYPE(Sub, attr("Attribute for SubC"))
// Base classes are defined at the beginning and terminated (so the counter can be reused)
REFL_BASE(MyBase)
// Possible more Base classs definitions.
REFL_BASE_END
REFL_FIELD(SubC)
REFL_END

//#define REFL_NO_STD_SUPPORT // Q2-alt: enable this to skip parsing std templates (notably std::string)
#include <https://raw.githubusercontent.com/veselink1/refl-cpp/master/include/refl.hpp>
#include <iostream>

namespace unique {
    template <typename, template <typename...> typename>
    struct is_instance_impl : public std::false_type {};

    template <template <typename...> typename U, typename...Ts>
    struct is_instance_impl<U<Ts...>, U> : public std::true_type {};
    template <typename T, template <typename ...> typename U>

    using is_instance = unique::is_instance_impl<std::decay_t<T>, U>;
}

template < class T >
constexpr bool isStdTemplate() {    
    return std::is_same<T, std::string>{}
    || unique::is_instance<T, std::basic_string>::value
    || unique::is_instance<T, std::basic_string_view>::value
    || unique::is_instance<T, std::tuple>::value
    || unique::is_instance<T, std::unique_ptr>::value
    || unique::is_instance<T, std::shared_ptr>::value
    || unique::is_instance<T, std::pair>::value
    || unique::is_instance<T, std::complex>::value;
}

template<class T>
concept ReflectableClass = refl::is_reflectable<T>() && std::is_class<T>::value /*&& !isStdTemplate<T>()*/; // Q2-alt: add perhaps trait to identify std templates

template<class T>
constexpr bool isReflectableClass() {
    return refl::is_reflectable<T>() && std::is_class<T>() /*&& !isStdTemplate<T>()*/;
}

// automatically generate/enable the '<<' stream operator for REFL_... annotated classes
template <ReflectableClass T>
constexpr std::ostream& operator<<(std::ostream& os, const T& value) {
    os << refl::reflect(value).name << "(";
    if constexpr (std::is_class<std::remove_reference_t<decltype(value)>>::value) {
        for_each(refl::reflect(value).members, [&](const auto member, const auto index) constexpr {
            if (index > 0) { // how to make this constexpr??
                os << ", ";
            }
            os << get_display_name(member) << '=' << member(value);
        });
        os << ')';
    }
    return os;
}

// Q3 - custom macros to shorten simple declarations with only member fields - Q: incorporate to refl-cpp? user-code?
// there must be something smarter?!?
// perhaps something like: https://stackoverflow.com/questions/29224493/wrap-each-element-in-variadic-macro-with-an-expression#answer-29225568
#define REFL_CUSTOM(typeName, ...) REFL_AUTO(type(typeName), __VA_ARGS__)
#define REFL_CUSTOM1(typeName, f1) REFL_AUTO(type(typeName), field(f1))
#define REFL_CUSTOM2(typeName, f1, f2) REFL_AUTO(type(typeName), field(f1), field(f2))
#define REFL_CUSTOM3(typeName, f1, f2, f3) REFL_AUTO(type(typeName), field(f1), field(f2), field(f3))
#define REFL_CUSTOM4(typeName, f1, f2, f3, f4) REFL_AUTO(type(typeName), field(f1), field(f2), field(f3), field(f4))
// [..]

// ############## test classes (user code) ###################################

struct OtherStruct {    
    const char* name = "test";
    int a; // default init value (int -> '0')
    int b{-1};
    std::string otherString = "Hello";
};

// following line is important for serialisation until 'reflexpr' is available (target: ~C++23)
//REFL_AUTO(type(OtherStruct), field(name), field(a), field(b), field(otherString))
//REFL_CUSTOM(OtherStruct, field(name), field(a), field(b), field(otherString))
REFL_CUSTOM4(OtherStruct, name, a, b, otherString) // much shorter than the 'official version below


struct UnknownClass {
    int unknownValue;
};

struct DomainObject {    
    float x;
    float y;
    OtherStruct innerClass;
};

// alt declaration option (more verbose)
REFL_TYPE(DomainObject)    
    REFL_FIELD(x)
    REFL_FIELD(y)
    REFL_FIELD(innerClass)
REFL_END

#include <list> // just needed for test-case
int main() {
    const auto obj = DomainObject{41, 42};
    std::cout << "toStream: " << obj << "\n";
    std::cout << "toStream: " << DomainObject{43, 44} << "\n\n";

    std::cout << std::boolalpha;
    std::cout << "isReflectableClass(DomainObject) = " << isReflectableClass<DomainObject>() << '\n';  // true, OK
    std::cout << "isReflectableClass(OtherStruct) = " << isReflectableClass<OtherStruct>() << '\n';    // true, OK
    std::cout << "isReflectableClass(int) = " << isReflectableClass<int>() << '\n';                    // false, OK -- skip non-classes
    std::cout << "isReflectableClass(UnknownClass) = " << isReflectableClass<UnknownClass>() << '\n';  // false, OK -- skip non-REFL_AUTO classes
    std::cout << "isReflectableClass(std::string) = " << isReflectableClass<std::string>() << "\n\n";  // true, not OK --Q-B) should skip, why is std::string being reflected?

    std::cout << "isStdTemplate(std::string) = " << isStdTemplate<std::string>() << '\n';        // true, OK - not implemented
    std::cout << "isStdTemplate(std::tuple) = " << isStdTemplate<std::tuple<int,int>>() << '\n'; // true, OK - not implemented
    std::cout << "isStdTemplate(std::list) = " << isStdTemplate<std::list<int>>() << '\n';       // false, OK - not implemented
}

refl::runtime::debug_str(std::tuple{1, "Hello, World!"}); // -> (1Hello, World!)

template<class T>
void ProcessClass()
{
   constexpr auto type = refl::reflect<T>();
   constexpr auto members = get_members(type);

   for_each(members, [&](auto member)
   {
      if constexpr (refl::descriptor::is_property(member))
      {
         if constexpr (refl::descriptor::is_writable(member))
         {
            auto reader = refl::descriptor::get_reader(member);
            // etc.
         }
         else if constexpr (! refl::descriptor::has_writer(member))
         {
            // etc.
         }
      }
   });
}

constexpr auto contains(type_list<Ts...> list, const const_string<N>& name);
constexpr auto find_one(type_list<Ts...> list, const const_string<N>& name);

find_one(member_list<T>{}, [](auto member) { return member.name == "mymethod"; });

#include "antara/gaming/core/safe.refl.hpp"
#include "antara/gaming/math/vector.hpp"

namespace antara::gaming::transform
{
    struct position_2d : public math::vec2f
    {
        template<typename ... Args>
        position_2d(Args&& ...args) noexcept: math::vec2f(std::forward<Args>(args)...)
        {

        }

        decltype(auto) x()
        {
            return math::vec2f::x();
        }

        decltype(auto) y()
        {
            return math::vec2f::y();
        }
    };
}

REFL_AUTO(type(antara::gaming::transform::position_2d), func(x), func(y))

namespace antara::gaming::math
{
    template<class Unit, size_t Size, template<class> class...Mixins>
    class basic_vector : public Mixins<basic_vector<Unit, Size, Mixins...>> ...
    {

        template<class, size_t, template<class> class...>
        friend
        class basic_vector;

        using sequence_type = std::make_index_sequence<Size>;

        template<class Res, size_t...Is>
        constexpr auto implicit_cast_to(std::index_sequence<Is...>) const noexcept
        {
            return Res{std::get<Is>(data_)...};
        }

        template<class Res, size_t...Is>
        constexpr auto explicit_cast_to(std::index_sequence<Is...>) const noexcept
        {
            using NewUnit = typename Res::value_type;
            return Res{static_cast<NewUnit>(std::get<Is>(data_))...};
        }

        template<class F, size_t...Is>
        constexpr basic_vector make_vec(F &&f, std::index_sequence<Is...>) const noexcept
        {
            return {f(std::get<Is>(data_))...};
        }

        template<class F, size_t...Is>
        constexpr basic_vector make_vec(F &&f, basic_vector const &rhs, std::index_sequence<Is...>) const noexcept
        {
            return {f(std::get<Is>(data_), std::get<Is>(rhs.data_))...};
        }

        template<class F, size_t...Is>
        constexpr void update_vec(F &&f, std::index_sequence<Is...>) noexcept
        {
            (f(std::get<Is>(data_)), ...);
        }

        template<class F, size_t...Is>
        constexpr void update_vec(F &&f, basic_vector const &rhs, std::index_sequence<Is...>) noexcept
        {
            (f(std::get<Is>(data_), std::get<Is>(rhs.data_)), ...);
        }

        template<size_t...Is>
        constexpr Unit square_length(std::index_sequence<Is...>) const noexcept
        {
            return (... + (std::get<Is>(data_) * std::get<Is>(data_)));
        }

        template<class F, class Vec, size_t...Is>
        constexpr bool test_predicate(F &&f, Vec const &rhs, std::index_sequence<Is...>) const noexcept
        {
            return (f(std::get<Is>(data_), std::get<Is>(rhs.data_)) && ...);
        }

        std::array<Unit, Size> data_;
    public:
        using value_type = Unit;

        // Aggregate-like constructor
        template<class...Args, class = std::enable_if_t<
                std::conjunction_v<std::is_convertible<Args, Unit>...>
        >>
        constexpr basic_vector(Args...args) noexcept : data_{args...}
        {}

        constexpr basic_vector(Unit single_value) noexcept
        {
            std::fill(begin(), end(), single_value);
        }

        static constexpr auto scalar(Unit single_value) noexcept
        {
            return basic_vector(single_value);
        }

        constexpr Unit operator[](int i) const noexcept
        { return data_[i]; }

        constexpr Unit &operator[](int i) noexcept
        { return data_[i]; }

        template<size_t I>
        constexpr Unit get() const noexcept
        {
            static_assert(I >= 0 && I < Size, "Index outside of bounds");
            return std::get<I>(data_);
        }

        template<size_t I>
        constexpr Unit &get() noexcept
        {
            static_assert(I >= 0 && I < Size, "Index outside of bounds");
            return std::get<I>(data_);
        }

        constexpr Unit *data() noexcept
        { return data_.data(); }

        constexpr Unit const *data() const noexcept
        { return data_.data(); }

        constexpr int size() const noexcept
        { return Size; }

        constexpr auto begin() noexcept
        { return data_.begin(); }

        constexpr auto begin() const noexcept
        { return data_.begin(); }

        constexpr auto end() noexcept
        { return data_.end(); }

        constexpr auto end() const noexcept
        { return data_.end(); }

        // Implicit cast
        template<class NewUnit, template<class> class...NewMixins>
        constexpr operator basic_vector<NewUnit, Size, NewMixins...>() const noexcept
        {
            static_assert(std::is_convertible_v<Unit, NewUnit>, "Impossible cast from [value_type] to [NewUnit]");
            return implicit_cast_to<basic_vector<NewUnit, Size, NewMixins...>>(sequence_type{});
        }

        // Explicit cast
        template<class Vec>
        constexpr Vec to() const noexcept
        {
            using NewUnit = typename Vec::value_type;
            static_assert(std::is_convertible_v<Unit, NewUnit>,
                          "Impossible cast from [value_type] to [Vec::value_type]");
            return explicit_cast_to<Vec>(sequence_type{});
        }

        constexpr basic_vector operator+(Unit b) const noexcept
        {
            return make_vec([b](Unit a) { return a + b; }, sequence_type{});
        }

        constexpr basic_vector operator-(Unit b) const noexcept
        {
            return make_vec([b](Unit a) { return a - b; }, sequence_type{});
        }

        constexpr basic_vector operator*(Unit b) const noexcept
        {
            return make_vec([b](Unit a) { return a * b; }, sequence_type{});
        }

        constexpr basic_vector operator/(Unit b) const noexcept
        {
            return make_vec([b](Unit a) { return a / b; }, sequence_type{});
        }

        constexpr basic_vector operator+(basic_vector const &rhs) const noexcept
        {
            return make_vec([](Unit a, Unit b) { return a + b; }, rhs, sequence_type{});
        }

        constexpr basic_vector operator-(basic_vector const &rhs) const noexcept
        {
            return make_vec([](Unit a, Unit b) { return a - b; }, rhs, sequence_type{});
        }

        constexpr basic_vector operator*(basic_vector const &rhs) const noexcept
        {
            return make_vec([](Unit a, Unit b) { return a * b; }, rhs, sequence_type{});
        }

        constexpr basic_vector operator/(basic_vector const &rhs) const noexcept
        {
            return make_vec([](Unit a, Unit b) { return a / b; }, rhs, sequence_type{});
        }

        constexpr basic_vector &operator+=(Unit b) noexcept
        {
            update_vec([b](Unit &a) { a += b; }, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator-=(Unit b) noexcept
        {
            update_vec([b](Unit &a) { a -= b; }, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator*=(Unit b) noexcept
        {
            update_vec([b](Unit &a) { a *= b; }, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator/=(Unit b) noexcept
        {
            update_vec([b](Unit &a) { a /= b; }, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator+=(basic_vector const &rhs) noexcept
        {
            update_vec([](Unit &a, Unit b) { a += b; }, rhs, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator-=(basic_vector const &rhs) noexcept
        {
            update_vec([](Unit &a, Unit b) { a -= b; }, rhs, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator*=(basic_vector const &rhs) noexcept
        {
            update_vec([](Unit &a, Unit b) { a *= b; }, rhs, sequence_type{});
            return *this;
        }

        constexpr basic_vector &operator/=(basic_vector const &rhs) noexcept
        {
            update_vec([](Unit &a, Unit b) { a /= b; }, rhs, sequence_type{});
            return *this;
        }

        constexpr basic_vector operator-() const noexcept
        {
            return make_vec([](Unit x) { return -x; }, sequence_type{});
        }

        constexpr Unit square_length() const noexcept
        {
            return square_length(sequence_type{});
        }

        constexpr Unit length() const noexcept
        {
            return std::sqrt(square_length());
        }

        constexpr basic_vector normalized() const noexcept
        {
            return *this / length();
        }

        template<class NewUnit, template<class> class...NewMixins>
        constexpr bool operator==(basic_vector<NewUnit, Size, NewMixins...> const &rhs) const noexcept
        {
            return test_predicate([](Unit a, Unit b) { return a == b; }, rhs, sequence_type{});
        }

        template<class NewUnit, template<class> class...NewMixins>
        constexpr bool operator!=(basic_vector<NewUnit, Size, NewMixins...> const &rhs) const noexcept
        {
            return !(*this == rhs);
        }

        template<class NewUnit, template<class> class...NewMixins>
        constexpr bool operator<(basic_vector<NewUnit, Size, NewMixins...> const &rhs) const noexcept
        {
            return test_predicate([](Unit a, Unit b) { return a < b; }, rhs, sequence_type{});
        }

        template<class NewUnit, template<class> class...NewMixins>
        constexpr bool operator>=(basic_vector<NewUnit, Size, NewMixins...> const &rhs) const noexcept
        {
            return !(*this < rhs);
        }

        template<class NewUnit, template<class> class...NewMixins>
        constexpr bool operator>(basic_vector<NewUnit, Size, NewMixins...> const &rhs) const noexcept
        {
            return rhs < *this;
        }

        template<class NewUnit, template<class> class...NewMixins>
        constexpr bool operator<=(basic_vector<NewUnit, Size, NewMixins...> const &rhs) const noexcept
        {
            return !(rhs < *this);
        }
    };

    namespace vector_mixins
    {
        template<class Derived>
        class access_xy
        {
        public:
            constexpr auto x() const noexcept
            { return static_cast<Derived const *>(this)->template get<0>(); }

            constexpr auto &x() noexcept
            { return static_cast<Derived *>(this)->template get<0>(); }

            constexpr auto y() const noexcept
            { return static_cast<Derived const *>(this)->template get<1>(); }

            constexpr auto &y() noexcept
            { return static_cast<Derived *>(this)->template get<1>(); }
        };

        template<class Derived>
        class access_z
        {
        public:
            constexpr auto z() const noexcept
            { return static_cast<Derived const *>(this)->template get<2>(); }

            constexpr auto &z() noexcept
            { return static_cast<Derived *>(this)->template get<2>(); }
        };
    }

    template<class Unit>
    using vec2 = basic_vector<Unit, 2, vector_mixins::access_xy>;

    using vec2c   = vec2<char>;
    using vec2uc  = vec2<unsigned char>;
    using vec2s   = vec2<short>;
    using vec2us  = vec2<unsigned short>;
    using vec2i   = vec2<int>;
    using vec2u   = vec2<unsigned>;
    using vec2l   = vec2<long>;
    using vec2ul  = vec2<unsigned long>;
    using vec2ll  = vec2<long long>;
    using vec2ull = vec2<unsigned long long>;
    using vec2f   = vec2<float>;
    using vec2d   = vec2<double>;
    using vec2ld  = vec2<long double>;

    template<class Unit>
    using vec3 = basic_vector<Unit, 3, vector_mixins::access_xy, vector_mixins::access_z>;

    using vec3c   = vec3<char>;
    using vec3uc  = vec3<unsigned char>;
    using vec3s   = vec3<short>;
    using vec3us  = vec3<unsigned short>;
    using vec3i   = vec3<int>;
    using vec3u   = vec3<unsigned>;
    using vec3l   = vec3<long>;
    using vec3ul  = vec3<unsigned long>;
    using vec3ll  = vec3<long long>;
    using vec3ull = vec3<unsigned long long>;
    using vec3f   = vec3<float>;
    using vec3d   = vec3<double>;
    using vec3ld = vec3<long double>;
}

namespace std {

    template<class Unit, size_t Size, template<class> class...Mixins>
    struct tuple_size<antara::gaming::math::basic_vector<Unit, Size, Mixins...>> : integral_constant<size_t, Size> {};

    template <size_t I, class Unit, size_t Size, template<class> class...Mixins>
    struct tuple_element<I, antara::gaming::math::basic_vector<Unit, Size, Mixins...>> { using type = Unit; };
}