Feature #12624

Updated by nobu (Nobuyoshi Nakada) over 3 years ago

I'd like to suggest a new syntactic feature.

There should be an operator `!==` !==
which should just return the negation of the `===` === operator

### aka:


def !==(other)

! (self === other)


### Rationale:
The `===` === operator is well established.
The `!==` !== operator would just return the negated truth value of `===` ===
That syntax would mimick the duality of `==` == vs `!=` !=

### Impact:
To my best knowledge, `!==` !== is currently rejected by the parser,
so there should be no exsiting code be affected by this change.

### Do we really need that?
obviously `(! (! (a === b))` b)) does the job,
while, `(a (a !== b)` b) looks a bit more terse to me.

### What's the use case?
I personally got a habit of using `===` === in type checking arguments:


raise TypeError() unless (SomeClass === arg)

You might argue that I should write instead:


raise TypeError() unless arg.kind_of?(SomeClass)

(you are obviously right in that)

But the `===` === operator is there for a reason,
and it is actually a strong point of ruby,
that we do not only have identity or equivalence,
but this third kind of object defined equality.

I believe, that in some cases
the intention of a boolean clause
would be easier to understand if we had that `!==` !== operator
instead of writing `!(a===b)` !(a===b)

I agree, syntax ahould not change.
But I believe that would add to the orthogonality.


Please see also:
my request on reserving the UTF operator plane for operators