Ruby » Ruby master

Feature #12624

Updated by nobu (Nobuyoshi Nakada) over 8 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: 

 ```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))` 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: 

 ```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)` !(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 















 

Back