wiki:GuideLines/Naming/OperatorTraitNames

Version 6 (modified by bronf, 11 years ago) ( diff )

--

Introduction

This page gives different proposals to name the traits that answer the following questions:

  • if "@" is a binary operator, can you write somewhere in your code "lhs @ rhs",
  • if "@" is a prefix unary operator, can you write somewhere in your code "@ rhs",
  • if "@" is a postfix unary operator, can you write somewhere in your code "lhs @",

lhs and rhs being of any types provided as template parameters to the trait. Optionnaly, the traits can also answer if the operator return type is convertible to some type.

In particular, the traits do not say if the corresponding operators are members of a given class but only if the operators can be called with given arguments. If the answer is yes, the operators can be member functions or a free functions or a built-in operators.

Proposals

Choose between A, B and C.

operator A B C standard keyword standard <functional> boost Proto boost Operators
+ can_call_addition has_plus has_plus 0 plus plus 0
- can_call_subtraction has_minus has_minus 0 minus minus 0
* can_call_multiplication has_multiplies has_multiplies 0 multiplies multiplies 0
/ can_call_division has_divides has_divides 0 divides divides 0
% can_call_modulus has_modulus has_modulus 0 modulus modulus 0
+= can_call_addition_assignment has_plus_equal has_plus_assign 0 0 plus_assign addable
-= can_call_subtraction_assignment has_minus_equal has_minus_assign 0 0 minus_assign substractable
*= can_call_multiplication_assignment has_multiplies_equal has_multiplies_assign 0 0 multiplies_assign multipliable
/= can_call_division_assignment has_divides_equal has_divides_assign 0 0 divides_assign dividable
%= can_call_modulus_assignment has_modulus_equal has_modulus_assign 0 0 modulus_assign modable
& can_call_bitwise_and has_bit_and has_bit_and bitand bit_and bitwise_and 0
| can_call_bitwise_or has_bit_or has_bit_or bitor bit_or bitwise_or 0
^ can_call_bitwise_xor has_bit_xor has_bit_xor xor bit_xor bitwise_xor 0
&= can_call_bitwise_and_assignment has_bit_and_equal has_bit_and_assign and_eq 0 bitwise_and_assign andable
|= can_call_bitwise_or_assignment has_bit_or_equal has_bit_or_assign or_eq 0 bitwise_or_assign orable
^= can_call_bitwise_xor_assignment has_bit_xor_equal has_bit_xor_assign xor_eq 0 bitwise_xor_assign xorable
<< can_call_shift_left has_left_shift has_left_shift 0 0 shift_left 0
>> can_call_shift_right has_right_shift has_right_shift 0 0 shift_right 0
<<= can_call_shift_left_assignment has_left_shift_equal has_left_shift_assign 0 0 shift_left_assign left_shiftable
>>= can_call_shift_right_assignment has_right_shift_equal has_right_shift_assign 0 0 shift_right_assign right_shiftable
== can_call_equal has_equal_to has_equal_to 0 equal_to equal_to equality_comparable
!= can_call_not_equal has_not_equal_to has_not_equal_to not_eq not_equal_to not_equal_to 0
< can_call_less has_less has_less 0 less less less_than_comparable
<= can_call_less_equal has_less_equal has_less_equal 0 less_equal less_equal 0
> can_call_greater has_greater has_greater 0 greater greater 0
>= can_call_greater_equal has_greater_equal has_greater_equal 0 greater_equal greater_equal 0
&& can_call_and has_logical_and has_logical_and and logical_and logical_and 0
|| can_call_or has_logical_or has_logical_or or logical_or logical_or 0
! can_call_not has_logical_not has_logical_not not logical_not logical_not 0
+ can_call_unary_plus has_unary_plus has_unary_plus 0 0 unary_plus 0
- can_call_unary_minus has_unary_minus has_negate 0 negate negate 0
~ can_call_complement has_complement has_complement compl 0 complement 0
* can_call_dereference has_dereference has_dereference 0 0 dereference 0
++ can_call_pre_increment has_pre_increment has_pre_increment 0 0 pre_inc incrementable
-- can_call_pre_decrement has_pre_decrement has_pre_decrement 0 0 pre_dec decrementable
++ can_call_post_increment has_post_increment has_post_increment 0 0 post_inc 0
-- can_call_post_decrement has_post_decrement has_post_decrement 0 0 post_dec 0
operator A: review B C D
+ has_operator_plus can_call_addition can_add has_plus
- has_operator_minus can_call_subtraction can_subtract has_minus
* has_operator_multiplies can_call_multiplication can_multiply has_multiplies
/ has_operator_divides can_call_division can_divide has_divides
% has_operator_modulus can_call_modulus can_call_modulus has_modulus
+= has_operator_plus_equal can_call_addition_assignment can_add_assign has_plus_assign
-= has_operator_minus_equal can_call_subtraction_assignment can_subtract_assign has_minus_assign
*= has_operator_multiplies_equal can_call_multiplication_assignment can_multiply_assign has_multiplies_assign
/= has_operator_divides_equal can_call_division_assignment can_divide_assign has_divides_assign
%= has_operator_modulus_equal can_call_modulus_assignment can_call_modulus_assign has_modulus_assign
& has_operator_bit_and can_call_bitwise_and can_bitwise_and has_bit_and
| has_operator_bit_or can_call_bitwise_or can_bitwise_or has_bit_or
^ has_operator_bit_xor can_call_bitwise_xor can_bitwise_xor has_bit_xor
&= has_operator_bit_and_equal can_call_bitwise_and_assignment can_bitwise_and_assign has_bit_and_assign
|= has_operator_bit_or_equal can_call_bitwise_or_assignment can_bitwise_or_assign has_bit_or_assign
^= has_operator_bit_xor_equal can_call_bitwise_xor_assignment can_bitwise_xor_assign has_bit_xor_assign
<< has_operator_left_shift can_call_shift_left can_left_shift has_left_shift
>> has_operator_right_shift can_call_shift_right can_right_shift has_right_shift
<<=has_operator_left_shift_equal can_call_shift_left_assignment can_left_shift_assign has_left_shift_assign
>>=has_operator_right_shift_equal can_call_shift_right_assignment can_right_shift_assign has_right_shift_assign
== has_operator_equal_to can_call_equal can_equal_compare has_equal_to
!= has_operator_not_equal_to can_call_not_equal can_not_equal_compare has_not_equal_to
< has_operator_less can_call_less can_less_compare has_less
<= has_operator_less_equal can_call_less_equal can_less_equal_compare has_less_equal
> has_operator_greater can_call_greater can_greater_compare has_greater
>= has_operator_greater_equal can_call_greater_equal can_greater_equal_compare has_greater_equal
&& has_operator_logical_and can_call_and can_logical_and has_logical_and
|| has_operator_logical_or can_call_or can_logical_or has_logical_or
! has_operator_logical_not can_call_not can_logical_not has_logical_not
+ has_operator_unary_plus can_call_unary_plus can_positivate has_unary_plus
- has_operator_unary_minus can_call_unary_minus can_negate has_negate
~ has_operator_complement can_call_complement can_complement has_complement
* has_operator_dereference can_call_dereference can_dereference has_dereference
++ has_operator_prefix_increment can_call_pre_increment can_pre_increase has_pre_increment
-- has_operator_prefix_decrement can_call_pre_decrement can_pre_decrease has_pre_decrement
++ has_operator_postfix_increment can_call_post_increment can_post_increase has_post_increment
-- has_operator_postfix_decrement can_call_post_decrement can_post_decrease has_post_decrement

Comments during the official review

date who comment
14/03/2011 vijayan12 replace _equal by _assign
14/03/2011 vicente.bote replace _equal by _assign
14/03/2011 vicente.bote shift -> bit_left/right_shift
14/03/2011 vicente.bote complement -> bit_not
14/03/2011 vicente.bote prefix_ -> pre_, postfix_ -> post_
15/03/2011 vicente.bote &,|,,~,<<,>> are bit operators and all should be named following the same schema.
15/03/2011 thom.helle WRT naming i think we should strive for consistent naming in overall boost, not just the type_traits library. Proto, for example, names the operators as well, as does Boost.Operator. FWIW both libraries agree on left_shift/right_shift.
15/03/2011 jhellrun I prefer op_equal as well, but it's not a strong preference.
15/03/2011 jhellrun I, too, prefer shift_left and shift_right, given their ubiquity related to std::iostream.
15/03/2011 pbristo There would seem to me to be a very strong case for having the same names as in Boost.Proto and Boost.Operator.
15/03/2011 vicente.bote I have a little problem with the has_operator_ prefix on the name of the traits. The traits is not checking the class parameter(s) has/have an operator, but that the application of the operator to this/these types is syntactically correct. E.g. has_operator_plus&lt;int, double&gt;::value neither int nor double have an operator+. applicable_operator_plus&lt;int, double&gt;::value or can_apply_operator_plus could be an option.
16/03/2011 eldiene has_ is fine
16/03/2011 robert.stewar replace _equal by _assign
16/03/2011 robert.stewar plus_equal -> add_assign
16/03/2011 robert.stewar multiplies -> multiply, divides -> divide
16/03/2011 robert.stewar bit -> bitwise
16/03/2011 robert.stewar prefer direction followed by shift (right/left_shift) than shift followed by direction
16/03/2011 robert.stewar I generally like the names from Proto. Consistency would be nice, but consider the names as they are likely to be standardized. Better to get the names "right" now. For example, I think "postfix_increment" is a likely name for standardization, while "post_inc" is not.
16/03/2011 joel.falco add typedefs for proto consistency
16/03/2011 vicente.bote do not mix operators and concepts (equality_comparable, addable, less_than_comparable) which are adjectives
16/03/2011 vicente.bote std::ratio uses add, subtract, multiply and divide, this corresponds to verbs not to nouns and have a semantic associated. Boost.MPL has also some names for arithmetic operators. It uses plus, minus, times and divides. I think that that the names we are looking for should be names.
16/03/2011 vicente.bote bit -> bitwise
16/03/2011 vicente.bote prefer direction followed by shift (right/left_shift) than shift followed by direction
16/03/2011 vicente.bote used in standard: prefix/postfix increment/decrement, pre/post increment/decrement
17/03/2011 boost.rege names proposed are consistent
18/03/2011 afojg has_operator_xxx is imprecise and should be operator_xxx_applicable_to or operator_xxx_callable_on instead?
18/03/2011 eldiene IMO nobody is going to be comfortable with 'operator_xxx_callable_on' as opposed to 'has_operator_xxx'.
18/03/2011 jeffrey.hellrun prefers is_xxxable to has_operator_
18/03/2011 jeffrey.hellrun prefers plus, minus to add, substract
18/03/2011 jeffrey.hellrun prefers plus_equal to plus_assign
18/03/2011 jeffrey.hellrun prefers post/pre_increment/decrement to postfix/prefix_increment/decrement
18/03/2011 jeffrey.hellrun prefers bit_ to bitwise_
18/03/2011 afojg has_operator_xxx seems to be imprecise and misleading
18/03/2011 afojg has_operator_xxx introduces a redundant prefix 'has_operator'
18/03/2011 afojg plus_assign_callable or plus_assignable
18/03/2011 boost.rege plus_assignable -> is_plus_assignable
18/03/2011 robert.stewar plus_assignable -> is_add_assignable
18/03/2011 robert.stewar can_assign_sum/difference/product/quotient
18/03/2011 robert.stewar can_add_and_assign/subtract_and_assign/multiply_and_assign/divide_and_assign
18/03/2011 vicente.bote can_add/multiply/left_shift/post_increase/add_assign/subtract_assign/multiply_assign/divide_assign
19/03/2011 afojg The name has_operator_xxx misleads to the assumption, that the signature of an operator can be checked directly. At least naive users (like me;) may fall into this trap.
19/03/2011 afojg remove operator_
19/03/2011 afojg (1) Consistency with general math and scientific knowledge (2) Consistency with standards (2.1) Consistency with c++ standards (2.2) Consistency with boost (2.3) Consistency with other standards, if they exist (3) Conciseness (3.1) Precise and descriptive (3.2) Adequate level of abstraction (3.3) Reduced for unnecessary redundancies (3.4) Relatedness to other names with similar meanings.
19/03/2011 afojg +: cross, -: dash, *: star, /: slash
19/03/2011 spillne is_callable<plus, LeftOperandType, RightOperandType>, result_of<plus, LeftOperandType, RightOperandType, ReturnType>, retval_convertible_to<plus, LeftOperand, RightOperandType, EquivalentReturnType>, is_prefix_callable<plusplus, OperandType>, is_postfix_callable<plusplus, OperandType>
21/03/2011 afojg https://svn.boost.org/trac/boost/wiki/Guidelines/Naming/Operators
24/03/2011 afojg + cross, addition, set union, concatenation, ...
24/03/2011 afojg - dash, subtraction, set difference, deletion ...
24/03/2011 afojg * star, multiplication, intersection, Cartesian product ...
24/03/2011 afojg / slash, division, factorization, ...
28/03/2011 dherrin has_op_xxx
Note: See TracWiki for help on using the wiki.