Putting logical limitations on types

[Ido Yehieli]

Hi,
can I define types with a limitation on the data the type contain,
rather than just the size it will have in memory?

For example: a bound_int which can only be in a certain range, so
don't i don't have to have a bound checking function like this one:

int in_range(int i, int min, int max){
----if(i<min)
--------return min;
----if(i>max)
--------return max;
}

Or a prime_number type, and so on.

Thanks,
Ido.

[Eric Sosman]

Ido Yehieli wrote:

Hi,
can I define types with a limitation on the data the type contain,
rather than just the size it will have in memory?

For example: a bound_int which can only be in a certain range, so
don't i don't have to have a bound checking function like this one:

int in_range(int i, int min, int max){
----if(i<min)
--------return min;
----if(i>max)
--------return max;
}

Or a prime_number type, and so on.

A variable of type T can store any value in T's range,
without restriction. There is no way you can limit the
values to a subrange or subset:

int hour; /* 0 through 23, please */
hour = 42; /* nothing prevents this */

int odd; /* odd numbers only, please */
odd = 42; /* nothing prevents this */

--
Eric Sosman
es*****@ieee-dot-org.invalid

[Walter Roberson]

In article <92**********************************@e23g2000prf. googlegroups.com>,
Ido Yehieli <Id*********@gmail.comwrote:

can I define types with a limitation on the data the type contain,
rather than just the size it will have in memory?

>For example: a bound_int which can only be in a certain range, so
don't i don't have to have a bound checking function

No, not in C.

Note: C enumerations ("enum") are suggestive of what you are looking
for, but they do NOT prevent other values from being stored.
Effectively they just give names for integral constants, rather
than controlling the data type.
--
So you found your solution
What will be your last contribution?
-- Supertramp (Fool's Overture)

[Ben Pfaff]

Ido Yehieli <Id*********@gmail.comwrites:

can I define types with a limitation on the data the type contain,
rather than just the size it will have in memory?

Not in C.
--
char a[]="\n .CJacehknorstu";int putchar(int);int main(void){unsigned long b[]
={0x67dffdff,0x9aa9aa6a,0xa77ffda9,0x7da6aa6a,0xa6 7f6aaa,0xaa9aa9f6,0x11f6},*p
=b,i=24;for(;p+=!*p;*p/=4)switch(0[p]&3)case 0:{return 0;for(p--;i--;i--)case+
2:{i++;if(i)break;else default:continue;if(0)case 1:putchar(a[i&15]);break;}}}

[Ido Yehieli]

On Jan 25, 11:12 pm, Eric Sosman <[e-mail]:

int hour; /* 0 through 23, please */
hour = 42; /* nothing prevents this */

That's unfortunate. Thanks anyway.

[Ido Yehieli]

On Jan 25, 11:55 pm, Flash Gordon <[e-mail]:

If you want to discus the best alternatively language for your
requirements comp.programming *might* be an appropriate place.
Alternatively, if you want to explain more about what you want to
achieve it might be that someone can suggest a completely different
approach using C to solve your problem.

Never mind, I'll just use a function to check the bounds when needed.
I thought there might be a more appropriate way of doing it.

-Ido,

[Ben Bacarisse]

Ido Yehieli <Id*********@gmail.comwrites:

can I define types with a limitation on the data the type contain,
rather than just the size it will have in memory?

For example: a bound_int which can only be in a certain range

<snip>

Or a prime_number type, and so on.

You've had the C answer: no, but it is worth pointing out that a
language that the full version of what you are hinting at with a "prime
number" type would either have to abandon compile time types or the
compiler would need a complex theorem prover in it (and the compiler
might end up not guaranteed to terminate). That is far cry from C.

--
Ben.

[Ido Yehieli]

On Jan 26, 2:02 am, Ben Bacarisse <[e-mail]:

a
language that the full version of what you are hinting at with a "prime
number" type would either have to abandon compile time types or the
compiler would need a complex theorem prover in it

I guess a lazy-evaluating language could provide such a type.
But then a prime_number type is just syntactic sugar around a function
that generates prime numbers.

-Ido.

[santosh]

Ido Yehieli wrote:

On Jan 26, 2:02 am, Ben Bacarisse <[e-mail]:

>a
language that the full version of what you are hinting at with a
"prime number" type would either have to abandon compile time types
or the compiler would need a complex theorem prover in it

I guess a lazy-evaluating language could provide such a type.
But then a prime_number type is just syntactic sugar around a function
that generates prime numbers.

What is a prime number /type/ supposed to do? Signal an error when a
non-prime number is written to it?

[Ido Yehieli]

On Jan 26, 10:59 am, "Malcolm McLean" <[e-mail]>
wrote:

This isn't particularly complicated, but will
approximately halve the speed of the program.

How did you figure it will be 1/2?
I'm not saying it wouldn't, just interested to see where this estimate
came from.

-Ido.

[Kaz Kylheku]

On Jan 25, 1:56*pm, Ido Yehieli <[e-mail]:

Hi,
* * can I define types with a limitation on the data the type contain,
rather than just the size it will have in memory?

Don't you think you need a better reference manual, if it cannot
answer simple questions about what the language can or cannot do?

[Ido Yehieli]

On Jan 26, 3:40 pm, Kaz Kylheku <[e-mail]:

Don't you think you need a better reference manual, if it cannot
answer simple questions about what the language can or cannot do?

I knew the exact thing I asked is probably not possible, but hoped
someone know an elegant solution I didn't think about.

-Ido.