Argument Dependent Lookup ADL

namespace pixl {
  class point { …
      point(int x, int y); …
  };
  // cannot be member function:
  point operator * (int factor, point const&);
}
namespace geom {
  class point { …
      point(double x, double y); …
  };
  point operator * (double factor, point const&);
}

pixl::point px {640, 480};
geom::point gm {1.1, 2.3};

// px has type pixl::point// ⇒ ADL selects pixl::operator*
auto p = 2 * px;  

// gm has type geom::point// ⇒ ADL selects geom::operator*
auto x = 2 * gm;

namespace ns {
  class T { … };
  void g (T*);
}

namespace na {  
  class A { }; 
  void f ( void(*)(A) ) {}
}

void g(na::A);

namespace na {
  class A { … };
}
namespace nc {
  class C { public: …
    void set(na::A);
  };
  void f ( void(nc::C::*)(na::A) );
}

namespace na {
  class A { … };
  // set of overloads
  void f (A);
  void f (A, int);

  void g ( void(*)(A) );
}

// ADL finds math::operator+(ratio,ratio)
math::ratio x {2,3}, y {1,6};
math::ratio z = x + y;  
// qualified call ⇒ No ADL ⇒ operator+ not found!
math::ratio x {2,3}, y {1,6};
math::ratio w = math::operator+(x,y);  //  COMPILER ERROR

namespace math {
  class tiny_ratio {
    // no operator+! (on purpose)
    …
  };
  class ratio { 
    …
  public:
    explicit
    ratio(int64_t numerator,           int64_t denominator=1);
    // implicit conversion from tiny_ratio:
    ratio(tiny_ratio r);
    …
    friend ratio operator + (ratio a, ratio b)     { … }
  };
}
// No implicit conversions possible:
math::tiny_ratio r{1,2}, s{1,4};
auto t = r + s;   //  COMPILER ERROR ⇒ good!

namespace math {
  class ratio { 
    …
  public: 
    friend ratio operator + (ratio a, ratio b)     { … }
    …
  };
  class my_num {
    …
  public: 
    …
    // conversion operator that can
    // create a 'ratio' from a 'my_num'
    operator ratio() const     { return ratio{…}; }
    // forgot operator + for my_num!
  };
}
math::my_num u = 23;
math::my_num v = 47;
auto w = u + v ;  //  COMPILER ERROR: operator+ not found

#include <iostream>

namespace lib {
  namespace detail {
    struct foo_fn {
      template<class T>
      void operator() (T const& x) const { 
        std::cout << "lib::detail::foo_fn::operator()\n"; 
      }
    };
  }
  // global function object lib::foo
  inline constexpr detail::foo_fn foo {};
  // note: inline variable requires C++17
}

namespace na {
  class A { … };
}
namespace nb {
  class B { … };
  // custom foo
  void foo(B const& b) {std::cout << "nb::foo\n";…}
}

int main () {
na::A a;
nb::B b;
// with explicit qualification:
lib::foo(a);  // lib::foo → lib::detail::foo
lib::foo(b);  // lib::foo → lib::detail::foo
// same with using statement:
using lib::foo;
foo(a);      // lib::foo → lib::detail::foo
foo(b);      // lib::foo → lib::detail::foo
}

#include <iostream>

namespace lib {
  template<class T>   concept Fooable = requires (T x) { 
    {x.size()} -> std::integral; };

  namespace detail {
    // prevent ADL from picking up 'foo' in 'lib'
    void foo () = delete;

    inline namespace defaults {
      template<Fooable T>  // constrained!
      void foo (T const&) { std::cout << "lib::detail::defaults::foo\n";… }
    }
    struct foo_fn {
      template<Fooable T>  // constrained!
      void operator() (T const& x) const {
        // calls custom foo found by ADL
        // or fallback defaults::foo
        foo(x);
      }
    };
  }

  // expose default impl. (if we want that)
  namespace defaults = detail::defaults;

  // prevent conflicts with hidden friends 'foo' in 'lib'
  inline namespace foo_cpo {
    // global function object lib::foo
    inline constexpr detail::foo_fn foo {};
  }
}
namespace na {
  class A { public: size_t size() const; };
}
namespace nb {
  class B { public: int size() const; };
  void foo(B const&) { std::cout << "nb::foo\n";}
}

int main () {
  na::A a;
  nb::B b;
  using lib::foo;
  foo(a);
  foo(b);
  // explicit qualification has no effect:
  lib::foo(a);
  lib::foo(b);
  // force default implementation:
  lib::defaults::foo(a);
  lib::defaults::foo(b);
}

#include <iostream>

namespace lib {
  template<class T> concept Fooable = requires (T x) { 
    {x.size()} -> std::integral; };

  namespace detail {
    // prevent ADL from picking up 'foo' in 'lib'
    void foo () = delete;

    inline namespace defaults {
      template<Fooable T>  // constrained!
      void foo(T const&) { std::cout << "lib::detail::defaults::foo\n"; }
    }
    struct foo_fn {
      template<Fooable T>  // constrained!
      void operator() (T const& x) const {
        // calls custom foo found by ADL
        // or fallback defaults::foo
        foo(x);
      }
    };
  }

  namespace defaults = detail::defaults;

  inline namespace foo_fpo {
    // global function object lib::foo
    inline constexpr detail::foo_fn foo {};
  }
}

namespace na {
  class A { public: size_t size() const; };
}
namespace nb {
  class B { public: int size() const; };
  void foo (B const&){ std::cout << "nb::foo\n";};
}

int main () {
na::A a;
nb::B b;
using lib::foo;
foo(a);      // lib::foo → fallback lib::defaults::foo
foo(b);      // lib::foo → custom   nb::foo
// explicit qualification has no effect:
lib::foo(a);  // lib::foo → fallback lib::defaults::foo
lib::foo(b);  // lib::foo → custom   nb::foo
// force default implementation:
lib::defaults::foo(a);
lib::defaults::foo(b);
}

namespace lib {
  template<class T>   concept Fooable = requires (T x) { 
    {x.size()} -> std::integral; };
  …
}

namespace nc {
  class C {   };  // no member 'size()'
  void foo (C const&);
}
nc::C c;
lib::foo(c);  COMPILER ERROR: C doesn't satisfy 'lib::Fooable'
using lib::foo;
foo(c);       COMPILER ERROR: C doesn't satisfy 'lib::Fooable'

class D { public: 
  // non-integral return type:
  double size() const { … } 
  friend void foo (D const&) { … }
};
D d;
lib::foo(d);  COMPILER ERROR: D doesn't satisfy 'lib::Fooable'
using lib::foo;
foo(d);       COMPILER ERROR: D doesn't satisfy 'lib::Fooable'