Re: [boost] safe integer library -- the scope

Subject: Re: [boost] safe integer library -- the scope
From: Robert Ramey (ramey_at_[hidden])
Date: 2015-12-14 11:19:25

On 12/14/15 12:43 AM, Andrzej Krzemienski wrote:

> Ok, now I think I understand the scope of the library. You give me the tool
> for representing a mathematical notion of an integral number within *some*
> limited range. The contract is:
>
> You guarantee:
> 1. Either correct result or a compile time error or a run-time exception.
> 2. No memory management: you will only take the space of one scalar type.

I would (and have) phrase it differently.

1. Either correct result or a compile time error or a run-time exception.
2. Best runtime performance possible subject to 1. above.

So "No memory management" isn't a fundamental principle, but rather 
implied by 2. above in our current machines.

> I specify the range of the representable values. I can say:
> 1. "From -100 to +100", or
> 2. "Whatever range 'int' as on my machine".

If you look at the code you'll see something like

template<T, Min, Max>
struct safe_base {
...
};

template<T>
using safe<T> = safe_base<T,
     std::numeric_limits<T>::min(),
     std::numeric_limits<T>::max()
 >;

> But if I got it right, I would say that the choice of the name, and the
> interface do not indicate the intent as clear as they could. Imagine the
> following alternative interface:
>
> small_int<p_range<-100, 100>>; // range-based policy

I call this safe_integer_range<-100, 100> - I don't think that's 
significantly different.

> small_int<p_type<int>>; // underlying-type-based policy

I'm not sure what this is meant to mean.  But note than many of my tests 
and examples I often use something like the following to make this clearer

template
using short_int_t = safe_range<0, 32>;

>
> In the first case, the user specifies the range, and the library can choose
> the best underlying type for the job.

that's what safe_... range does.
>
> In the second case, the user chooses the underlying type, and this implies
> the range [numeric_limits<T>::min(), numeric_limits<T>::max()]

that's what safe<T> does.

Robert Ramey