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: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>