Re: [boost] Re: Customization via Overloading in Namespace

From: Brian McNamara (lorgon_at_[hidden])
Date: 2004-02-20 13:26:18

On Fri, Feb 20, 2004 at 12:25:49PM -0500, David Abrahams wrote:
> Brian McNamara <lorgon_at_[hidden]> writes:
> > On Thu, Feb 19, 2004 at 11:35:13PM -0500, David Abrahams wrote:
> >> Brian McNamara <lorgon_at_[hidden]> writes:
> >> > (Despite the fact that no one wants to hear it, I would feel remiss if I
> >> > didn't play Chicken Little and say "Fool's gold!  Qualified calls and
> >> > template specialization are the one true path to such customization!
> >> 
> >> You'd be wrong.  It'd be nice if it were true, but qualified calls
> >> are subject to order dependencies, among other problems.
> >
> > I'm not clear about this.
> >
> >    // lib.hpp
> >    namespace lib {
> >       template <class T> void f(T);
> >       template <class T> void g(T x) { lib::f(x); }
> >    }
> >    
> >    // user.hpp 
> >    #include "lib.hpp"
> >    namespace user {
> >       struct MyClass {};
> >    }
> >    namespace lib {
> >       template <> void f( user::MyClass ) { /* print "foo" */ }
> Not an overload.

Yes, I know.  Chicken Little says

   Qualified calls and _template_specialization_ are the one true path
   to such customization!  [emphasis added]

> >    } 
> >       
> >    // user.cpp
> >    #include "user.hpp"
> >    int main() {
> >       user::MyClass m;
> >       lib::g(m);
> >    }
> >    
> > Would that not print "foo"?  What is the order dependency? 
> 
> That's a specialization.  Actually, there'd still be an order
> dependency if g wasn't a function template, but that's beside the
> point.

I'm not sure what your second sentence there is trying to tell me; can
you give a short example?  (If g isn't a function template, what would
it be?)

> > (I don't
> > think I have access to a compiler that supposedly does this right, or
> > else I'd try it myself.) What are the other problems?  (I know one:
> > function templates can't be "partially" specialized, which means you
> > sometimes need to use a class helper, ugh.)
> 
> specialization interacts badly with overloading too:
> 
>   template <class T> int f(T);
>   template <> int f(int*);
>   template <class T> void f(T*);
> 
>   int x = 0;
>   int y = f(&x); // error; can't convert void to int.

Indeed; recall that part of Chicken Little's thesis is

   All designs based on overloading or ADL will end in tears!

the relevant part here being "Overloading bad!" (in the context of
library/user customization designs).

-- 
-Brian McNamara (lorgon_at_[hidden])