stdcxx-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Martin Sebor <>
Subject Re: __rw_and (Was RE: Some internal aliases for __rw_integral_constant?)
Date Thu, 26 Jun 2008 20:11:47 GMT
Eric Lemings wrote:
>> -----Original Message-----
>> From: Martin Sebor [] On Behalf Of Martin Sebor
>> Sent: Thursday, June 26, 2008 12:32 PM
>> To:
>> Subject: Re: __rw_and (Was RE: Some internal aliases for 
>> __rw_integral_constant?)
> ...
>> I can't say I understand this use case. What's S meant to represent?
> That was just a contrived example; not intended to be realistic.

Sorry, but I find it difficult to think about the utility of a feature
without a realistic example.

>> It looks like some sort of a type trait. If so, why isn't plain &&
>> sufficient?
> Portability.  As I said, some compilers have problems evaluating certain
> expressions at compile-time without metafunction wrappers.

Okay, I can understand that. Do we have test cases for these bugs
and have they been reported? It's important that every bug we run
into be distilled to a test case and reported to the compiler
vendor before we implement a workaround. That way we can expect
the bugs to be fixed and the workarounds to be removed.

>>      template <class T, int I>
>>      struct S:
>>          __rw_conditional<__rw_is_class<T>::value && 0 != I, T,
>>      { };
>> (Or enable_if instead of conditional, depending on what you want
>> to do with S).
>>> 	template <class... T> struct O {
>>> 	    template <class... U> struct I
>>> 	        : __rw_and<std::is_convertible<T, U>::value...> {}; //
>>> variable arguments
>> Same here.
> Try writing that without __rw_and.  :)  I did.  Well, tried at least.
> It is NOT easy.  In fact, this was the main reason I wrote the __rw_and
> class template to begin with.

I would if I knew what I is supposed to be/do.

>>> 	};
>>> The other reason is portability.  Case in point.  Travis 
>> recently ran
>>> into a problem where the compiler rejected a simple 
>> constant expression
>>> like `sizeof (T) < sizeof (U)' but worked with the metafunction
>>> equivalent of `__rw_less_than<sizeof (T), sizeof (U)>::value'.
>> This sounds like an argument for __rw_less_than, not for __rw_and.
>> Btw., I'm not opposed to __rw_and in principle. I just want to see
>> some of its uses and the rationale for it (in case there's a better
>> or simpler way of doing the same thing).
> The "is_convertible" use case is the best rationale for it that I can
> think of.

std::is_convertible? But that doesn't make use of anything that
resembles __rw_and.

>  Such metafunctions essentially allow type traits to be used
> on type _lists_ rather than individual types; e.g.,
> 	template <class... Types>
> 	struct all_integral_types
> 	    : __rw_and<std::is_integral<Types>::value...> {};
> I dunno 'bout you, but I think that's pretty darn cool.  :)  Oh, and a
> lot simpler than the alternative.  (I'm not convinced there even is
> one.)

Is this the alternative you're looking for?

     template <class... Types>
     struct all_integral_types;

    template <class T>
    struct all_integral_types<T>: is_integral<T> { };

     template <class T, class... Types>
     struct all_integral_types<T, Types...>
         : const_integral<bool, is_integral<T>::value
                                && all_integral_types<Types...>::value>
     { };

> Brad.

View raw message