(or, stop me if you've heard this one before)

A good friend of mine first wore glasses in college. He hadn't realized that the world had been blurry for 20 years until his doctor demonstrated exactly how clear the world can be.

If you visit the optometrist and get fitted for corrective lenses, the doctor will put a viewfinder over your face and fiddle with dials, asking "Better or worse". Your task is to squint and squirm and try to read the optical equivalent of lorem ipsum until everything becomes clear and you no longer have to worry about your focal depth. If you get it wrong, you'll have slight headaches for a year until you correct things again. If you get it right—well, that's a matter of preference.

After all, no one can decide your own tolerance for clarity.

Some people believe that Perl has too many operators and they ask questions like why are there separate comparison operators for strings and numbers, for example.

Better or worse?

$x eq $y $x.to_str == $y.to_str (String)$x == (String)$y

Granted, the underlying mechanism in a virtual machine might perform the same operations:

get_string %SREG(0), $x get_string %SREG(1), $y compare %SREG(0), %SREG(1)

... but people like me write lots of code so you don't have to write code like that, or even know how that code works.

Suppose the optometrist knows all about Hindley-Milner, and over a second round of delicious beverages, he asks the programming language designer about typeclasses and inference:

$x == $y

Better or worse than the previous examples?

Of course, your optometrist probably isn't even an amateur programming language designer, so it's easy to counter the argument:

Does this operator compare container equivalence or value equivalence?

If value equivalence, must the values be the same or equivalent?

If container equivalence, how deep is the container equivalence?

Must the inferred types be the same, or can they be contra/covariant?

If deep container equivalence, how does this comparison interact with laziness or infinite data structures?

If value equivalence, are coercions allowable between potentially comparable representations?

What happens if someone overloads this comparison operator for one type or another?

Better or worse?

$x == $y $x.CONTAINER == $y.CONTAINER $x.VALUE == $y.VALUE typeof $x == typeof $y <contravariant_type>$x == <contravariant_type>$y LAZY($x == $y)

... and so on.

Over a third round of drinks, the programming language designer might get the optometrist to admit that the reason some languages have so many operators is because there are so many possible operations. The question, as always, is "What's the most clear to read and to understand?"