Why does defining a method called ! break IRB?

Question

IRB appears to have strange behaviour when defining a method called !.

To reproduce this, enter the following into IRB:

def !
  puts "foo"
end

Upon creating the method, IRB infinitely prints foo:

irb(main):001:0> def !
irb(main):002:1>   puts "foo"
irb(main):003:1> end
foo
foo
foo
...

~~As far as I know, you can't directly call a method named ! from Ruby syntax; you have to use send instead.~~ Edit: You can invoke ! as a prefix operator; it's just negation: !x

Why does this definition cause IRB to loop infinitely? Does IRB rely on a method named ! for printing its prompt or something similar?

I'm using Ruby 2.4.3 and IRB 0.9.6 on Windows 10.

You're overriding [`BasicObject#!`](http://ruby-doc.org/core-2.5.0/BasicObject.html#method-i-21) — Stefan, Mar 28 '18 at 18:51
@Stefan I had no idea it was even possible to override negation. Thanks! — Aaron Christiansen, Mar 28 '18 at 18:54
Ruby is nice in that, if you ask it to slowly burn to death, it will put on a smile and douse itself in gasoline. — Silvio Mayolo, Mar 28 '18 at 19:05
FYI – just type `method(:!)` in IRB to see the method's origin. — Stefan, Mar 28 '18 at 19:08
@SilvioMayolo hands you enough rope to shoot your self in the foot :) — engineersmnky, Mar 28 '18 at 19:31

Tom Lord · Accepted Answer · 2018-03-28T19:58:40.963

tl;dr: Overriding ! outside of a class is a very weird thing to do! There are countless ways that you can "break" ruby by doing crazy things like this - so you may find it fun to play around with such strange ideas, but obviously don't do this in important code!

In ruby, all classes inherit from the top-level base class: BasicObject. This class defines top-level object negation - i.e. Whenever you write

!foo

this is actually calling a method called ! on your object foo:

foo.send(:!)

This makes it possible (although it's a very rare thing to do!) to redefine the method on a specific class. For example, when implementing the null object pattern you could do something like this:

class NullObject
  def !
    true
  end
end

my_null = NullObject.new
!!my_null #=> false

(Normally, the only objects that would return false in the above line are nil and false!)

Now then, back to your example. What you actually did here was define a method called ! on the class Object (and didn't call super to trigger the original method!). In other words, you basically re-defined the response a fundamental method that gets used all over the place internally. Something, somewhere (??) got confused by this bizarre behaviour and failed non-gracefully.

irb(main):001:0> def !
irb(main):002:1> puts "foo"
irb(main):003:1> super # <-- !! This stops it from breaking completely !!
irb(main):004:1> end
=> :!
irb(main):005:0* method(:!)
foo
foo
=> #<Method: Object#!>
irb(main):006:0> method(:!).source_location
foo
foo
=> ["(irb)", 1]
irb(main):007:0> method(:!).super_method
foo
foo
=> #<Method: BasicObject#!>

Here are some other ways you could re-define methods to cause bizarre behaviour/errors, for example:

def nil?
  true
end
# Will now die in weird ways!

class String
  def ===(other)
    true
  end
end

"ruby" === "awesome"
#=> true

Why does defining a method called ! break IRB?

1 Answers1