Experimenting with c++20 style concepts to design an angle type (#99) , I opted to use a postfix "_concept" naming rule to identify associated concepts.

(Bear with my use of concepts since I haven't used them much).

Nevertheless the resulting code purely seems to me to work well for legibility and understanding .
In the brave new world of in code concept names to be added to all the other types of entity names there needs to be some way to distinguish concepts. It is just unrealistic to expect to find terse meaningful names ad-hoc, therefore using a consistent scheme seems to me to be the right way to go.

No more agonising and time wasting about entity naming and distinctiveness each time you wish to deal with a new concept, juts follow the rule so you can get on with other things. It just works...

#include <ratio>
#include <type_traits>

namespace std{ namespace experimental {

   namespace detail{
      template<typename T>
      inline constexpr bool is_ratio = false;

      template<typename T>
      inline constexpr bool is_angle = false;

      template<typename T>
      inline constexpr bool is_radian = false;

      template<typename T>
      inline constexpr bool is_real_number = false;

   }

   template <typename T>
   concept ratio_concept = std::experimental::detail::is_ratio<T>;

   namespace  detail{
      template <std::intmax_t num, std::intmax_t den>
      inline constexpr bool is_ratio<std::ratio<num,den> > = true;
   }

   template <typename T>
   concept angle_concept = std::experimental::detail::is_angle<T>;

   template <typename T>
   concept radian_concept = std::experimental::detail::is_radian<T>;

   template <typename T>
   concept floating_point_concept = std::is_floating_point_v<T>;

   template <typename T>
   concept arithmetic_concept = std::is_arithmetic_v<T>;

   template <typename T>
   concept real_number_concept = std::experimental::detail::is_real_number<T>;

   namespace detail{

       template<std::experimental::floating_point_concept T>
       inline constexpr bool is_real_number<T> = true;

   }

   template <real_number_concept ValueType = double,ratio_concept Exponent = std::ratio<1U>>
   class radian;

   namespace detail{

      template <real_number_concept ValueType,ratio_concept Exponent>
      inline constexpr bool is_radian<std::experimental::radian<ValueType,Exponent> > = true;

      template <real_number_concept ValueType,ratio_concept Exponent>
      inline constexpr bool is_angle<std::experimental::radian<ValueType,Exponent> > = true;
   }

   template <real_number_concept ValueType,ratio_concept Exponent>
   class radian{
   public:
      using exponent = typename Exponent::type;
      using value_type = ValueType;

      radian() = default;
      radian(const radian & ) = default;
      radian(radian &&) = default;

      // implicit construction from numeric
      constexpr radian( arithmetic_concept const & v) : m_value{v}{}

      constexpr radian operator + () { return *this;}
      constexpr radian operator - () { return - this->m_value;}

      constexpr value_type numeric_value()const { return m_value;}
   private:
       value_type m_value{};
   };

   // addition only where exponent is the same
   template <radian_concept Lhs, radian_concept Rhs>
   inline constexpr auto 
   operator + (Lhs const & lhs, Rhs const & rhs) 
      requires  std::ratio_equal_v<
         std::ratio_subtract<typename Lhs::exponent,typename Rhs::exponent>,
         std::ratio<0>
      >
   {
      using value_type = std::common_type_t<typename Lhs::value_type,typename Rhs::value_type> ;
      using exponent = typename Lhs::exponent::type;
      typedef radian<value_type,exponent> result_type;
      return result_type{
          lhs.numeric_value() + rhs.numeric_value()
      };
   }

    // subtraction only where exponent is the same
   template <radian_concept Lhs, radian_concept Rhs>
   inline constexpr auto 
   operator - (Lhs const & lhs, Rhs const & rhs) 
      requires  std::ratio_equal_v<
         std::ratio_subtract<typename Lhs::exponent,typename Rhs::exponent>,
         std::ratio<0>
      >
   {
      using value_type = std::common_type_t<typename Lhs::value_type,typename Rhs::value_type> ;
      using exponent = typename Lhs::exponent::type;
      using result_type = radian<value_type,exponent>;
      return result_type{
          lhs.numeric_value() - rhs.numeric_value()
      };
   }

   template <radian_concept Lhs, radian_concept Rhs>
   inline constexpr auto 
   operator * (Lhs const & lhs, Rhs const & rhs) 
      requires  std::ratio_equal_v<
         std::ratio_add<typename Lhs::exponent,typename Rhs::exponent>,
         std::ratio<0>
      >
   {
      return lhs.numeric_value() * rhs.numeric_value();
   }

   template <radian_concept Lhs, radian_concept Rhs>
   inline constexpr auto 
   operator * (Lhs const & lhs, Rhs const & rhs) 
      requires ! std::ratio_equal_v<
         std::ratio_add<typename Lhs::exponent,typename Rhs::exponent>,
         std::ratio<0>
      >
   {
      using value_type = std::common_type_t<typename Lhs::value_type,typename Rhs::value_type> ;
      using exponent = std::ratio_add<typename Lhs::exponent,typename Rhs::exponent>;
      using result_type = radian<value_type,exponent>;
      return result_type {lhs.numeric_value() * rhs.numeric_value()};
   }

}} // std::experimental


struct dummy{};
int main()
{
   
   std::experimental::radian<double,std::ratio<2> > constexpr r = 1.2;

   std::experimental::angle_concept a = r;

   std::experimental::angle_concept b = r + r;

   std::experimental::radian<double,std::ratio<-2> > constexpr r1 = 1.2;
   std::experimental::angle_concept b1 = r1 + r1;

   std::experimental::radian<float,std::ratio<2> > constexpr rf = 1.2f;

   // should fail
   std::experimental::radian<int,std::ratio<2> > constexpr ri = 1;

}

Rename concepts to standard_case #93

Description

Activity

Metadata

Metadata

Assignees

Labels

Projects

Milestone

Relationships

Development

Issue actions

Rename concepts to `standard_case` #93