From: nobu@... Date: 2016-07-26T01:55:48+00:00 Subject: [ruby-core:76564] [Ruby trunk Feature#12624] !== (other) Issue #12624 has been updated by Nobuyoshi Nakada. Description updated I'm sometimes wanting it, too. And can find some lines in standard libraries. ```ruby ext/psych/lib/psych/visitors/yaml_tree.rb:334: elsif not String === @ss.tokenize(o) or /\A0[0-7]*[89]/ =~ o lib/irb.rb:500: !(SyntaxError === exc) lib/optparse.rb:1353: if (!(String === o || Symbol === o)) and o.respond_to?(:match) lib/rdoc/class_module.rb:777: !(String === mod) && @store.modules_hash[mod.full_name].nil? lib/rdoc/class_module.rb:793: !(String === mod) && @store.modules_hash[mod.full_name].nil? lib/rdoc/parser/ruby.rb:244: break if first_comment_tk_class and not first_comment_tk_class === tk lib/resolv.rb:534: if reply.tc == 1 and not Requester::TCP === requester lib/resolv.rb:1028: !(Array === ns_port) || lib/resolv.rb:1030: !(String === ns_port[0]) || lib/resolv.rb:1031: !(Integer === ns_port[1]) lib/rubygems/security/signer.rb:51: @key and not OpenSSL::PKey::RSA === @key test/objspace/test_objspace.rb:76: assert_empty(arg.select {|k, v| !(Symbol === k && Integer === v)}, bug8014) test/rinda/test_rinda.rb:212: assert(!(tmpl === ro)) test/rinda/test_rinda.rb:218: assert(!(tmpl === ro)) test/rinda/test_rinda.rb:221: assert(!(tmpl === ro)) test/rinda/test_rinda.rb:230: assert(!(tmpl === ro)) test/ruby/test_m17n_comb.rb:1131: if [s, *args].all? {|o| !(String === o) || o.valid_encoding? } ``` https://github.com/ruby/ruby/compare/trunk...nobu:feature/!== ---------------------------------------- Feature #12624: !== (other) https://bugs.ruby-lang.org/issues/12624#change-59792 * 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: ```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: