Точка настройки псевдонима для стандартных типов

Допустим, я пишу некий общий алгоритм в пространстве имен lib, который вызывает точку настройки my_func.

Первая попытка использует ADL для my_func один из пользователей хочет специализироваться my_func для своего типа, который является псевдонимом для std типа. Конечно, определить это в его пространстве имен не получится, потому что ADL не будет работать для псевдонима. Определение его в пространстве имен std не разрешено стандартом. кажется, что единственный оставшийся вариант определяется в пространстве имен алгоритма lib. Но это также не работает, если конечный пользователь включает заголовок алгоритма перед включением заголовка настройки.

#include <iostream>
#include <array>

// my_algorithm.hpp
namespace lib{

template<typename T>
void my_algorithm(const T& t){
    my_func(t);
}

} // namespace lib

// user1.hpp
namespace user1{

struct Foo1{
    // this is working as expected (ADL)
    friend void my_func(const Foo1&){
        std::cout << "called user1's customisation\n";
    }
};

} // namespace user1

// user2.hpp
namespace user2{

using Foo2 = std::array<int,1>;

// this won't work because Foo2 is actually in std namespace
void my_func(const Foo2&){
        std::cout << "called user2's customisation\n";
}

} // namespace user2

/* surely this isn't allowed
namespace std{
void my_func(const user2::Foo2&){
        std::cout << "called user2's customisation\n";
}
} //namespace std
*/

// another attempt to costomize in the algorithm's namespace
// this won't work because my_func isn't seen before my_algorithm
namespace lib{
    void my_func(const user2::Foo2&){
        std::cout << "called user2's customisation\n";
    }
}



// main.cpp
// #include "algorithm.hpp"
// #include "user1.hpp"
// #include "user2.hpp"
int main(){
    lib::my_algorithm(user1::Foo1{});
    lib::my_algorithm(user2::Foo2{});
}

https://godbolt.org/z/bfdP8s

Вторая попытка — использовать niebloids для my_func, что имеет ту же проблему, что и ADL.

Третья попытка использует tag_invoke, которая должна иметь ту же проблему, что и ADL, т.е.

• настройка в пространстве имен пользователя не будет работать, потому что мой тип является псевдонимом для типа std
• настройка в std запрещена
• настройка в пространстве имен lib зависит от порядка включения заголовка Первые пункты кажутся правдой, а последний пункт нет. Кажется, это работает

#include <iostream>
#include <array>

// tag_invoke.hpp  overly simplified version
namespace lib_ti{

inline namespace tag_invoke_impl{

inline constexpr struct tag_invoke_fn{

template<typename CP, typename... Args>
decltype(auto) operator()(CP cp, Args&&... args) const{
    return tag_invoke(cp, static_cast<Args&&>(args)...);
}

} tag_invoke{};

} // namespace tag_invoke_impl
} // namespace lib_to


// my_algorithm.hpp

// #include "tag_invoke.hpp"
namespace lib{

inline constexpr struct my_func_fn {
    
template <typename T>
void operator()(const T& t) const{
    lib_ti::tag_invoke(*this, t);
}

} my_func{};


template<typename T>
void my_algorithm(const T& t){
    my_func(t);
}

} // namespace lib

// user1.hpp
namespace user1{

struct Foo1{
    // this is working as expected (ADL)
    friend void tag_invoke(lib::my_func_fn, const Foo1&){
        std::cout << "called user1's customisation\n";
    }
};

} // namespace user1

// user2.hpp
namespace user2{

using Foo2 = std::array<int,1>;

// this won't work because Foo2 is actually in std namespace
void tag_invoke(lib::my_func_fn, const Foo2&){
        std::cout << "called user2's customisation\n";
}

} // namespace user2

/* surely this isn't allowed
namespace std{
void tag_invoke(lib::my_func_fn, const user2::Foo2&){
        std::cout << "called user2's customisation\n";
}
} //namespace std
*/

// another attempt to customise in the algorithm's namespace
// In ADL case, this does not work. But in this case, it seems to work. why?
namespace lib{
    void tag_invoke(lib::my_func_fn, const user2::Foo2&){
        std::cout << "called user2's customisation\n";
    }
}



// main.cpp
int main(){
    lib::my_algorithm(user1::Foo1{});
    lib::my_algorithm(user2::Foo2{});
}

https://godbolt.org/z/hsKbKE

Почему у этого нет той же проблемы, что и у первого (необработанный ADL)?

Четвертая попытка использует специализацию шаблона, которая работает нормально, как и ожидалось.

#include <iostream>
#include <array>




// my_algorithm.hpp

namespace lib{

template<typename T, typename = void>
struct my_func_impl{
    //void static apply(const T&) = delete;
};

inline constexpr struct my_func_fn {
    
template <typename T>
void operator()(const T& t) const{
    using impl = my_func_impl<std::decay_t<T>>;
    impl::apply(t);
}

} my_func{};


template<typename T>
void my_algorithm(const T& t){
    my_func(t);
}

} // namespace lib

// user1.hpp
namespace user1{

struct Foo1{};

} // namespace user1

namespace lib{

template<>
struct my_func_impl<user1::Foo1>{
    void static apply(const user1::Foo1&){
        std::cout << "called user1's customisation\n";
    }
};

} //namespace lib



// user2.hpp
namespace user2{

using Foo2 = std::array<int,1>;

} // namespace user2

namespace lib{

template<>
struct my_func_impl<user2::Foo2>{
    void static apply(const user2::Foo2&){
        std::cout << "called user2's customisation\n";
    }
};

}



// main.cpp
int main(){
    lib::my_algorithm(user1::Foo1{});
    lib::my_algorithm(user2::Foo2{});
}

https://godbolt.org/z/r71x6c

Как лучше всего написать общие алгоритмы и точки настройки и разрешить клиентам настраивать псевдонимы для стандартных типов?