From: eike@... Date: 2016-07-24T22:02:28+00:00 Subject: [ruby-core:76552] [Ruby trunk Feature#12624] !== (other) Issue #12624 has been reported by Eike Dierks. ---------------------------------------- Feature #12624: !== (other) https://bugs.ruby-lang.org/issues/12624 * Author: Eike Dierks * Status: Open * Priority: Normal * Assignee: ---------------------------------------- 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) end 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)) does the job, while, (a !== 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) 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 -- https://bugs.ruby-lang.org/ Unsubscribe: