#include <boost/operators.hpp>

struct my_type : boost::equality_comparable2<my_type, double> {
    explicit my_type(double mem) : mem_{mem}{}
    double mem_{0};
    operator double() {
        return mem_;
    }
    bool operator==(my_type l) {
        return l.mem_ == mem_;
    }
}; 


int main() {
    my_type x{0};
    return x == double{0};
}

1. rが配列のlvalueのときは、r + 0; // つまり、配列の最初の要素へのポインタ
2. rがlvalueで、かつr.begin()がstd::ranges::iteratorコンセプトを満たす型を返す式として有効であるときは、 r.begin();
3. オーバーロード集合として、template<typename T> void begin(T&&) = delete; template<typename T> void begin(std::initializer_list<T>&&) = delete; を加えたうえで、begin(static_cast<decltype(r)&&>(r))がstd::ranges::iteratorコンセプトを満たす型を返す式として有効であるときは、begin(static_cast<decltype(r)&&>(r));

1. rが配列のlvalueのときは、r + std::extend_v<decltype(r)>;
2. rがlvalueで、r.endがstd::ranges::begin(r)の戻り値型に対するstd::ranges::sentinelコンセプトを満たす型を返す式として有効であるときは、r.end();
3. オーバーロード集合として、template<typename T> void end(T&&) = delete; template<typename T> void end(std::initializer_list<T>&&) = delete; を加えたうえで、end(static_cast<decltype(r)&&>(r))がstd::ranges::begin(r)の戻り値型に対するstd::ranges::sentinelコンセプトを満たす型を返す式として有効であるときは、end(static_cast<decltype(r)&&>(r));

namespace std::range{
  namespace __begin_impl_ns{
    template<typename T> void begin(T&&) = delete;
    template<typename T> void begin(std::initializer_list<T>&&) = delete;
    class _begin_functor{
      template<typename E, std::size_t size>
      static E* impl(E (&arr)[size]){
        return arr;
      }

     template<typename E>
      static E* impl(E (&arr)[]){
        return arr;
      }
      template<typename R> requires iterator_type<decltype((std::declval<R&>()).begin())>
      static auto impl(R& r){
        return r.begin();
      }
      template<typename R> requires iterator_type<decltype(begin(std::declval<R>()))>
      static auto impl(R&& r){
        return begin(std::forward<R>(r));
      }
    public:
      template<typename R>
      auto operator()(R&& r)->decltype(impl(std::forward<R>(r)))const{
        return impl(std::forward<R>(r));
      }
    };
  }
  inline constexpr __begin_impl_ns::_begin_functor begin{};
  
  namespace __end_impl_ns{
    template<typename T> void end(T&&) = delete;
    template<typename T> void end(std::initializer_list<T>&&) = delete;
    class _end_functor{
      template<typename E, std::size_t size>
      static E* impl(E (&arr)[size]){
        return arr + size;
      }

     template<typename E>
      static E* impl(E(&arr)[]){
        return arr;
      }
      template<typename R>
      requires sentinel_for<decltype((std::declval<R&>()).end()),decltype(ranges::begin(std::declval<R&>()))>
      static auto impl(R& r){
        return r.end();
      }
      template<typename R>
      requires sentinel_for<decltype(end(std::declval<R>())),decltype(ranges::begin(std::declval<R>()))>
      static auto impl(R&& r){
        return end(std::forward<R>(r));
      }
    public:
      template<typename R>
      auto operator()(R&& r)->decltype(impl(std::forward<R>(r)))const{
        return impl(std::forward<R>(r));
      }
    };
  }
  inline constexpr __end_impl_ns::_end_functor end{};
}

1. 直訳すると「番兵」、Rangesライブラリでは、Iteratorと比較演算子で比較でき、要素の最後の一つ後ろのIteratorと等価のものとして扱われる。Iteratorと同じ型であってもよい。
2. アルゴリズム関数は、RangeをR&&で受け取ってそのまま（perfect forwardingせずに）std::ranges::begin/endに渡すので、アルゴリズム関数にはrvalueを渡すことができます。

U func(){ return std::declval<T>();}

namespace std{
	namespace _details{
		template<typename To>
		std::void_t<To()> convert_to(To) noexcept;
		
		template<typename From, typename To, typename = void>
		struct is_nothrow_convertible_imp : std::false_type{};

		template<typename From, typename To>
		struct is_nothrow_convertible_imp<From, To, typename std::enable_if<noexcept(std::_details::convert_to<To>(std::declval<From>()))>::type> : std::true_type{};
	}

	template<typename From, typename To>
	struct is_nothrow_convertible : std::conditional<
		std::is_void<From>::value,
		std::is_void<To>,
		_details::is_nothrow_convertible_imp<From, To>
	>::type{};
}

• 関数の仮引数の型が、配列型・関数型となっている場合、decayが発生するが、戻り値型の場合はこれが起こらずエラーになる。
• 関数の戻り値型がvoidの場合にvoid型を返す関数の呼び出しをreturn文の式に記述できるが、仮引数型がvoidの場合はこれができずエラーになる。

• Fromがvoidの場合、Toがvoidかどうかを判定する。
• convert_toヘルパ関数の戻り値をstd::void_t<To()>とすることで、Toが配列型・関数型の場合にconvert_toヘルパ関数が不正なシグネチャとなるように細工する。

/*code start*/






/*in library code.*/
#include<iostream>

namespace library{
	template<typename T>
	void func(const T&){}
	
	template<typename T>
	struct X{};
	
	template<typename T>
	void func(const X<T>&){
		std::cout << "template<typename T> void func(const X<T>&);" << std::endl;
	}// ※1
}

/*user code*/

namespace user{
	class Y{};
}
namespace library{
	template<>
	void func<X<user::Y>>(const X<user::Y>&){
		std::cout << "template<> void func<X<Y>>(const X<Y>&);" <<std::endl;
	}// ※2
}

int main(){
	using namespace library;
	func(library::X<user::Y>{});//出力は？
}






//end

namespace library{
	template<>
	void func<>(const X<user::Y>&){
		std::cout << "template<> void func<X<Y>>(const X<Y>&);" <<std::endl;
	}
}

//start code
namespace std{
	namespace __swap_details{
		template<typename T>
		inline typename std::enable_if<std::is_move_constructible<T>::value&&std::is_move_assignable<T>::value>::type 
		swap(T& obj1, T& obj2)noexcept(std::is_nothrow_move_constructible<T>::value&&std::is_nothrow_move_assignable<T>::value){
			T temp(std::move(obj1));
			obj1 = std::move(obj2);
			obj2 = std::move(temp);
		} //※1
		struct _swap_functor{
			template<typename T, typename U>
			auto operator()(T& obj1, U& obj2)const noexcept(noexcept(swap(obj1, obj2)))->decltype(static_cast<void>(swap(obj1, obj2))){
				swap(obj1, obj2);
			} //※2
		};
	}
	inline constexpr __swap_details::_swap_functor swap{}; //※3













	/*
	// Eric Niebler氏のエントリでは、ODR違反の回避のため※3は次のような実装になっている。
	// C++17にはinline変数が導入されたので、変数swapはinline変数として定義できる。







	template<typename T>
	struct __static_valuable{
		static constexpr T value;
	};
	template<typename T>
	constexpr T __static_valuable<T>::value;
	
	namespace{
		constexpr auto const& swap = __static_valuable<__swap_details::_swap_functor>::value;
	}
	*/
}
//end code

//start code






namespace boost{
	namespace _swap_impl{
		using std::swap;
		struct _swap_functor{
			template<typename T, typename U>
			void operator(T& obj1, U& obj2)const noexcept(noexcept(swap(obj1, obj2))){
				swap(obj1, obj2);
			}
		};
	}
	inline constexpr _swap_impl::_swap_functor swap{}; //since C++17.
}
//end code

//start code
namespace library{
	template<typename T, typename U, typename V>
	void func(const T& t, U* u, const std::vector<V>& v){
		inner_func1(t);
		inner_func2(u);
		inner_func3(v);
	}
}
//end code

//start code






namespace library{
	template<typename T>
	void inner_func1(const T& t){/*...*/}
	
	template<typename T>
	void inner_func2(T* t){/*...*/}
	
	template<typename T>
	void inner_func3(const std::vector<T>& t){/*...*/}
}
//end code

//start code
namespace ns{
	namespace nested{
		struct X{};
	}
	
	// 次のどれでもよい。どの方法でも、ns::Xでns::nested::Xを指すことができる。
	using nested::X;    //(1)
	typedef nested::X X;//(2)
	using namespace X;  //(3)
	
	void func(X x){}
}
//end code

1. 関数テンプレートについて、template<typename T> void swap<foo<T>>(foo<T>&, foo<T>&){/*...*/} みたいな定義をすることはできない。template<typename T> void swap(foo<T>&, foo<T>&){/*...*/} とした場合、これは部分特殊化ではなくて関数テンプレートのオーバーロードとなる。
2. 現在の最新draft（N4659）の段階では、Customization point objectに指定されたものは見当たらない。これは、N4381で検討されているが、既存のCustomization pointにこれを適用すると、Customization pointを修飾名で呼び出しているコードを破壊的に変更することになるからである（Customization pointを修飾名で呼び出している場合、ユーザー定義の関数は呼ばれず、std名前空間内の関数が呼ばれる）。
3. N4659では、Customization point objectの型はliteral class typeでなければならないとされているため。一方で、boost::swapを関数オブジェクトにしてしまった場合、boost名前空間にswap関数を定義することができなくなってしまうため、boost::swapは関数として定義せざるを得ない。ところで、boost::swap自身は、std::swapを非修飾名で呼び出せる文脈においては、boost名前空間内で定義されている型に対してADLによって呼ばれることはない。なぜなら、boost::swapは、テンプレート引数を2つ取り、テンプレート引数が1つであるstd::swapよりもオーバーロード解決について劣後するためである。
4. これを利用すれば、他の名前空間で定義された関数をADLの対象にすることができる。例えば、std::rel_ops名前空間内の演算子関数については、本来ならばこの方法で使うべきではないかと思われる（もっとも、std::rel_ops名前空間内の比較演算子については、C++2aでdeprecatedとなることが決まっている）。