Why don't Java, C# and C++ have ranges?

Question

Ada, Pascal and many other languages support ranges, a way to subtype integers. A range is a signed integer value which ranges from a value (first) to another (last). It's easy to implement a class that does the same in OOP but I think that supporting the feature natively could let the compiler to do additional static checks.

I know that it's impossible to verify statically that a variabile defined in a range is not going to "overflow" runtime, i.e. due to bad input, but I think that something could be done. I think about the Design by Contract approach (Eiffel) and the Spec# ( C# Contracts ), that give a more general solution.

Is there a simpler solution that checks, at least, static out-of-bound assignment at compile time in C++, C# and Java? Some kind of static-assert?

edit: I understand that "ranges" can be used for different purpose:

1. iterators
2. enumerators
3. integer subtype

I would focus on the latter, because the formers are easily mappable on C* language . I think about a closed set of values, something like the music volume, i.e. a range that goes from 1 up to 100. I would like to increment or decrement it by a value. I would like to have a compile error in case of static overflow, something like:

volume=rangeInt(0,100);
volume=101;  // compile error!
volume=getIntFromInput(); // possible runtime exception

Thanks.

Answer 1

Subrange types are not actually very useful in practice. We do not often allocate fixed length arrays, and there is also no reason for fixed sized integers. Usually where we do see fixed sized arrays they are acting as an enumeration, and we have a better (although "heavier") solution to that.

Subrange types also complicate the type system. It would be much more useful to bring in constraints between variables than to fixed constants.

(Obligatory mention that integers should be arbitrary size in any sensible language.)

Answer 2

One way to accomplish this in .NET when 8 or less elements are needed is by using a Tuple.

(More than 8 elements are also supported by Tuples, but not easily: they must use the Tuple<T1,T2,T3,T4,T5,T6,T7,TRest> constructor, which is not as straightforward to assign or read, especially if looking for compile-time bounds checking.)

Ref https://learn.microsoft.com/en-us/dotnet/api/system.tuple?view=net-8.0

Example with 3 elements, causing compile-time error instead of run-time out-of-bounds exception:

var range = Tuple.Create(3, 2, 5);
// compile-time error for out-of-bounds - if you happen to miss the intellisense error!
range.Item4 = someNumber;

Answer 3

JSR-305 provides some support for ranges but I don't know when if ever this will be part of Java.

Answer 4

The flexibility to roll your own is better than having it built into the language. What if you want saturating arithmetic for example, instead of throwing an exception for out of range values? I.e.

MyRange<0,100> volume = 99;
volume += 10; // results in volume==100

Answer 5

I would add to Tom Hawtin response (to which I agree) that, for C++, the existence of ranges would not imply they would be checked - if you want to be consistent to the general language behavior - as array accesses, for instance, are also not range-checked anyway. For C# and Java, I believe the decision was based on performance - to check ranges would impose a burden and complicate the compiler.

Notice that ranges are mainly useful during the debugging phase - a range violation should never occur in production code (theoretically). So range checks are better to be implemented not inside the language itself, but in pre- and post- conditions, which can (should) be stripped out when producing the release build.

Answer 6

Java has had an assert keyword since version 1.4. If you're doing programming by contract, you're free to use those to check proper assignment. And any mutable attribute inside an object that should fall within a certain range should be checked prior to being set. You can also throw an IllegalArgumentException.

Why no range type? My guess is that the original designers didn't see one in C++ and didn't consider it as important as the other features they were trying to get right.

Answer 7

Pascal (and also Delphi) uses a subrange type but it is limited to ordinal types (integer, char and even boolean).

It is primarilly an integer with extra type checking. You can fake that in an other language using a class. This gives the advantage that you can apply more complex ranges.

Answer 8

In C# you can do this:

foreach(int i in System.Linq.Enumerable.Range(0, 10))
{
    // Do something
}

Answer 9

Ranges are most useful when you can do something over that range, concisely. That means closures. For Java and C++ at least, a range type would be annoying compared to an iterator because you'd need to define an inner class to define what you're going to do over that range.

Answer 10

C++ allows you to implement such types through templates, and I think there are a few libraries available doing this already. However, I think in most cases, the benefit is too small to justify the added complexity and compilation speed penalty.

As for static assert, it already exists. Boost has a BOOST_STATIC_ASSERT, and on Windows, I think Microsoft's ATL library defines a similar one.

boost::type_traits and boost::mpl are probably your best friends in implementing something like this.

Answer 11

For C++, a lib for constrained values variables is currently being implemented and will be proposed in the boost libraries : http://student.agh.edu.pl/~kawulak/constrained_value/index.html

Answer 12

This is an old question, but just wanted to update it. Java doesn't have ranges per-se, but if you really want the function you can use Commons Lang which has a number of range classes including IntRange:

IntRange ir = new IntRange(1, 10);

Bizarrely, this doesn't exist in Commons Math. I kind of agree with the accepted answer in part, but I don't believe ranges are useless, particularly in test cases.