From: matz@... Date: 2016-08-09T14:33:52+00:00 Subject: [ruby-core:76792] [Ruby trunk Feature#12624][Rejected] !== (other) Issue #12624 has been updated by Yukihiro Matsumoto. Status changed from Open to Rejected The explicit use of `===` for type checking is against duck typing principle. I don't accept syntax enhancement proposal to encourage something against duck typing in Ruby. Matz. ---------------------------------------- Feature #12624: !== (other) https://bugs.ruby-lang.org/issues/12624#change-60015 * Author: Eike Dierks * Status: Rejected * 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: ```ruby 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: ```ruby raise TypeError() unless (SomeClass === arg) ``` You might argue that I should write instead: ```ruby 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: