Re: [boost] type_traits: value tags

From: David Abrahams (david.abrahams_at_[hidden])
Date: 2002-02-23 08:47:28

----- Original Message -----
From: "John Maddock" <John_Maddock_at_[hidden]>
To: <boost_at_[hidden]>
Sent: Saturday, February 23, 2002 7:27 AM
Subject: Re: [boost] type_traits: value tags

>
> > In my use of type_traits, I've frequently wanted to be able to turn
> > boolean
> > values into tags for tag dispatching, e.g.:
> >
> >     return dispatch_function(&x, boost::is_const<X>::type());
> >
> > As it stands, I can write:
> >
> >     template <bool> struct bool_t {};
> >     return dispatch_function(&x, bool_t<boost::is_const<X>::value>());
> >
> > But, it's a little cumbersome, and nearly all of type_traits ICEs are
> > expressed in terms of yes_type and no_type anyway. Any chance of
> > institutionalizing this and making it public?
>
> There are no internal types that can be just exposed, however there is an
> overlooked section in my type_traits proposal which can come to the rescue
> here:
>
> "There is one potential problem with integral constant members that should
> be raised: these require an out of line definition as well as an inline
> initialisation (but see issues 48 and 82). One implementation strategy
that
> avoids the problem of having to provide lots of definitions for these
> static members, would be to have the traits classes inherit from a common
> base class:
>
> template <bool b> struct boolian_traits{ static const bool value = b; };
> template <bool b> bool boolian_traits<b>::value;
>
> typedef boolian_traits<true> true_type;
> typedef boolian_traits<false> false_type;

Prefer:

template <bool b> struct boolean_traits
{
    static const bool value = b;
    typedef boolean_traits<b> type;
};

template <bool b> bool boolean_traits<b>::value;
typedef boolean_traits<true> true_type;
typedef boolean_traits<false> false_type;

> template <class T> struct is_void : public false_type {};
> template <> struct is_void<void> : public true_type {};
> // etc
> This does not form part of this proposal, and this particular issue
> is ignored in the boost library, however there may be sufficient merit to
> this scheme to make it worth while adding to the proposed text. This
scheme
> also makes it trivial to select a function overload based on whether a
> traits class inherits from true_type or false_type."
>
> To flesh this out some more - if the traits classes all inherit from
either
> true_type or false_type, then we can just write something like:
>
> template <class T>
> inline void do_destroy(T* p, const false_type&)
> {
>    p->~T();
> }
>
> inline void do_destroy(void*, const true_type&)
> {}

Have you found some advantages to passing tags by const reference instead of
by-value?

> template <class T>
> inline void destroy(T* p)
> {
>   do_destroy(p, has_trivial_destructor<T>());
> }
>
> I don't have time to do any more with this right now, but if you want to
> run with it do :-)

What did you have in mind, edits to the proposal, or re-writing the entire
library and a batallion of associated tests? ;-)

-Dave