Re: [boost] review request: addition to type_traits library of is_less_comparable<T, U> and others

Subject: Re: [boost] review request: addition to type_traits library of is_less_comparable<T, U> and others
From: Christian Schladetsch (christian.schladetsch_at_[hidden])
Date: 2009-12-06 09:09:58

2009/12/7 Frédéric Bron <frederic.bron_at_[hidden]>

> > I am starting again to work on adding new traits to detect if two
> > types can be compared (is_less_comparable<T,U> and
> > has_operator_less<T,U>). Sorry for the long break but I could not find
> > any time for this in the past weeks.
> >
> > A recent post on the list makes me think that we could enlarge the
> > scope of the addition. In fact, here is the list of binary operators
> > for which we could implement type trait detection:
> >
> > * comparisons: <, <=, >, >=, ==, !=
> > * arithmetic operations: +, -, *, /, %
> > * logical operations: && (and), || (or)
> > * bitwise operations: <<, >>, ^ (xor), & (bitand), | (bitor)
>
> I would like to propose the following names for the type traits based
> on corresponding names in header <functional>. The first proposed name
> for type traits checking only for existence and the second name for
> type traits checking for existence and standard behaviour, i.e. the
> operator returns non void convertible to something the user can supply
> as template parameter (default bool for comparison operators). For
> existence, I am quite happy with the names, for existence and standard
> behaviour, I would like something shorter...
>
> One could also be in favor of has_operator_less or has_less_operator.
> The 1st one is consistant with declaration operator<(...), the 2nd one
> is consistant with already existing type trait has_new_operator and
> English I suppose.
>
> operator    name in <functional>    proposed name (existence)
> proposed name (existence and non void return type convertible to
> something)
> <           less                    has_operator_less
> operator_less_has_standard_behaviour
> <=          less_equal              has_operator_less_equal
> operator_less_equal_has_standard_behaviour
> >           greater                 has_operator_greater
> operator_greater_has_standard_behaviour
> >=          greater_equal           has_operator_greater_equal
> operator_greater_equal_has_standard_behaviour
> ==          equal_to                has_operator_equal_to
> operator_equal_to_has_standard_behaviour
> !=          not_equal_to            has_operator_not_equal_to
> operator_not_equal_to_has_standard_behaviour
> &&          logical_and             has_operator_and
> operator_and_has_standard_behaviour
> ||          logical_or              has_operator_or
> operator_or_has_standard_behaviour
>
> +           plus                    has_operator_plus
> operator_plus_has_standard_behaviour
> -           minus                   has_operator_minus
> operator_minus_has_standard_behaviour
> *           multiplies              has_operator_multiplies
> operator_multiplies_has_standard_behaviour
> /           divides                 has_operator_divides
> operator_divides_has_standard_behaviour
> %           modulus                 has_operator_modulus
> operator_modulus_has_standard_behaviour
>
> Please give your feedback and do not hesitate to make other propositions.
>

How about rationalising over the operators themselves?

boost::operator
boost::operator::plus
boost::operator::plus::exists<A,B>
boost::operator::plus::return_type<A,B>

Christian