This is similar to a pattern I have seen somewhere else:

```
var = 123.4
var.try.round #=> 123
var = nil
var.try.round #=> nil
```

Which doesn't introduce a new operator and can be implemented like this:

```
class Object
  def try
    self
  end
end

class NilClass
  def try
    IgnoreCall
  end

  class IgnoreCall
    def method_missing(*a)
      nil
    end
  end
end
```

By the way, fun fact:

```
?????:?? #=> '?'
```

On Sun, 2015-04-05 at 05:55 +0000, grzegorz.bizon / ntsn.pl wrote:
> Issue #11034 has been updated by Grzegorz Bizon.
> 
> 
> Hi Nobuyoshi, thanks for reply !
> 
> Yes, this Nil Conditional Operator has to introduce new syntax. That is why this cannot be achieved via gem. Currently - of course - double question mark *??* violates syntax (in some cases) or is treated as tenary operator. But this doesn't have to be *??*.
> 
> I also agree that my version of nil conditional is too permissive and shouldn't return nil if variable does not exist. This was just less difficult to implement ;)
> 
> I simply believe that Nil Conditional Operator would be useful for every rubyist. In my opinion it is worth talking over, considering.
> 
> I will try to find related issue.
> 
> Kind regards,
>  Grzegorz
> 
> ----------------------------------------
> Feature #11034: Nil Conditional
> https://bugs.ruby-lang.org/issues/11034#change-52043
> 
> * Author: Grzegorz Bizon
> * Status: Open
> * Priority: Normal
> * Assignee: 
> ----------------------------------------
> Hi everyone !
> 
> Some time ago I was thinking about Nil Conditional Operator in Ruby (`??`). This would be particularly useful to avoid frequent checking for nil, and should behave and look like Null Conditional Operator introduced in C# 6.0.
> 
> I was thinking about something like this (assume `var` is nil or doesn't exist):
> 
> ~~~ruby
> var??.method1.method2(123, 345).method3 { |i| i == 1 }
> => nil
> ~~~
> 
> When `var` is nil or doesn't exist, code above should return nil or NilConditionalClass object instead of raising NoMethodError or NameError.
> This can also work with methods (assume `var` exists):
> 
> ~~~ruby
> var.method1??.method2(a, b)
> => nil
> ~~~
> 
> When `var` exists and can receive `method1`, but `method1` returns nil - this shouldn return nil instead of raising  `NoMethodError: undefined method `method2' for nil:NilClass`
> 
> When `var` exists and is not nil, and can receive `method1`, and object returned by `method1` can receive `method2` this, of course should behave as expected (like version without `??` operator) and return value according to implementation of method2.
> 
> When `var` doesn't exist - this should raise NameError.
> 
> 
> I tried to create gem for that (https://github.com/grzesiek/nil-conditional) but from now on, only native implementation seems reasonable.
> 
> What do you think about that feature ? Maybe it is already considered, but I couldn't find anything similar at Google/this issue tracker (in that case I'm sorry for duplicate).
> 
> Thanks in advance for feedback !
> 
> Kind regards,
>  Grzegorz
> 
> 
> 
>