How do you control a range for type safety?

Question

Imagine you have a function that converts ints to roman string:

public String roman(int)

Only numbers from 1 to 3999 (inclusive) are valid for conversion.

So what do you do if someone passes 4000 in any OO language?

1. raise an exception
2. return “” or some other special string
3. write an assert
4. …

Answer 1

Number 1: raise an exception. That's what ArgumentOutOfRangeException is for (at least in .NET):

if (intToConvert >= 4000)
{
    throw new ArgumentOutOfRangeException("intToConvert ", "Only numbers 1-3000 are valid for conversion.");
}

Answer 2

I find the validation topic very interesting in general. In my opinion option 2 (returning a special value) is not a good one, since you are forcing the client to do if/case to check for the returned value and that code must be repeated everywhere. Also, unlike exceptions that propagate through the calling stack, in this scenario the caller is almost always the one that has to handle that special value.

In the context of OOP raising an exception or having an assertion is, IMO, a more elegant way to cope with it. However i find that inlining verification code in every method doesn't scale well for some reasons:

• Many times your validation logic ends up being greater than the method logic itself, so you end up cluttering your code with things that are not entirely relevant to it.
• There is no proper validation code reuse (e.g. range validation, e-mail validation, etc).
• This one depends on your tastes, but you will be doing defensive programming.

Some years ago I attended to a talk about validators (a similar talk slide's are here. The document explaining it used to be in http://www.caesarsystems.com/resources/caesarsystems/files/Extreme_Validation.pdf but now its a 404 :( ) and totally like the concept. IMHO having a validation framework that adopts the OO philosophy is the way to go. In case you want to read about it I've written a couple of posts about it here and here (disclaimer: the posts are part of the blog of the company I work for).

HTH