template<typename NumberT, typename Tag = void>
  class strong_number {
    private:
      static constexpr bool is_integral = std::is_integral<NumberT>::value;
    public:
      static strong_number convert(NumberT num) {
        return { num };
      }

      strong_number(strong_number const&) = default;
      strong_number(strong_number&&) = default;

      strong_number& operator=(strong_number const&) = default;
      strong_number& operator=(strong_number&&) = default;

      NumberT value() { return val; }

      template<typename OtherNumberT>
      explicit operator strong_number<OtherNumberT, Tag>() {
        return { val };
      }

      template<typename OtherNumberT, typename OtherTag = Tag>
      strong_number<OtherNumberT, OtherTag> convert() {
        return { static_cast<OtherNumberT>(val) };
      }

      bool operator!() { return val; }
      bool operator&&(strong_number const& other) { return val && other.val; }
      bool operator||(strong_number const& other) { return val || other.val; }

      #define gen_unary_op(op, arg, cond) \
      typename std::enable_if<cond, strong_number>::type\
      operator op(arg) { return { op val }; }
        gen_unary_op(+,     , true)
        gen_unary_op(-,     , true)
        gen_unary_op(~,     , is_integral)
        gen_unary_op(++,    , is_integral)
        gen_unary_op(++, int, is_integral)
        gen_unary_op(--,    , is_integral)
        gen_unary_op(--, int, is_integral)
      #undef gen_unary_op

      #define gen_binary_op(op, cond) \
      typename std::enable_if<cond, strong_number>::type\
      operator op(strong_number other) { return { val op other.val }; }
        gen_binary_op(+,  true)
        gen_binary_op(-,  true)
        gen_binary_op(*,  true)
        gen_binary_op(/,  true)
        gen_binary_op(%,  is_integral)
        gen_binary_op(&,  is_integral)
        gen_binary_op(|,  is_integral)
        gen_binary_op(^,  is_integral)
        gen_binary_op(<<, is_integral)
        gen_binary_op(>>, is_integral)
      #undef gen_binary_op

      #define gen_comparison_op(op) \
      bool operator op(strong_number other) { return val op other.val; }
        gen_comparison_op(==)
        gen_comparison_op(!=)
        gen_comparison_op(>)
        gen_comparison_op(>=)
        gen_comparison_op(<)
        gen_comparison_op(<=)
      #undef gen_comparison_op

      #define gen_compound_assignment(op, cond) \
      typename std::enable_if<cond, strong_number&>::type\
      operator op(strong_number other) { val op other.val; return *this; }
        gen_compound_assignment(+=,  true)
        gen_compound_assignment(-=,  true)
        gen_compound_assignment(*=,  true)
        gen_compound_assignment(/=,  true)
        gen_compound_assignment(%=,  is_integral)
        gen_compound_assignment(&=,  is_integral)
        gen_compound_assignment(|=,  is_integral)
        gen_compound_assignment(^=,  is_integral)
        gen_compound_assignment(<<=, is_integral)
        gen_compound_assignment(>>=, is_integral)
      #undef gen_compound_assignment

    private:
      strong_number(NumberT val) : val(val) {}

      NumberT val;
  };