Sneaky Internal State

I've boiled what I want out of a programming language down to a single example.  Problems like this bite me in the ass often and I haven't used a language, yet, that helps.

Suppose I'm writing a library for working with vectors.  For simplicity, it's not fancy n-dimensional vectors, etc., let's say just three floats.  So I write some code to perform operations on vectors, like add, subtract, dot product, cross product, rotate, scale... and then I come to "normalize."

Here, I come up with this optimization that vectors could also store a flag indicating whether or not they are normal.  If that flag is set, then normalize has no work to do.  The catch is that I have to decide which operations clear the flag, which operations set it, and which operations leave it unchanged.  So I do the work and end up with a nice, efficient vector library.

I use my library for a long time -- long enough that I stop caring how that optimization worked.  Eventually, months later, I decide to add some new functions to my vector library.  Of course, I've forgotten all about the "normal" flag, and I forget to set/clear it in the new functions.  Of course, there's no compile error or even a run-time error.  I just observe strange behavior when the application runs and I have to spend hours stepping through floating-point math to figure out what's wrong.

How does your language of choice improve this situation?

>>20
>The vectors you'd be working with would be generated at run-time, and they could come from anywhere (maybe user input, maybe some 3D model loaded from disk, etc...),

That's a good point. In such a case I would either explicitly normalize the vector, and then the compiler would know that it was normalized. Or I would trust that the file contained normalized vector, and I would need to establish a way to communicate this to the compiler. In a language like seeples, I'd probably make normalized vector a derived class of vector, and override the operations to skip the normalization part. And then have a method for directly reading a normalized vector from a file, without verifying its length (because at that point, you may as well just normalize it).