From: "UlyssesZhan (Ulysses Zhan) via ruby-core" <ruby-core@...>
Date: 2026-10-29T17:59:22+00:00
Subject: [ruby-core:127278] [Ruby Bug#4559] Proc#== does not match the documented behaviour

Issue #4559 has been updated by UlyssesZhan (Ulysses Zhan).


I don't know whether this should be the place to discuss it anymore because it is old, but I think currently `Proc#==` still does not match the documented behavior. The current documentation in Ruby 4 says `self == other` "returns whether `self` and `other` were created from the same code block." However, the following code shows otherwise:

```ruby
def f = proc { 1 }
f == f # => false
```

Note that here we have both `f` returning the code block from the same Ruby code, but they are considered different. A more reliable way to determine this, although only working in CRuby, is

```ruby
def f = proc { 1 }
RubyVM::InstructionSequence.of(f) == RubyVM::InstructionSequence.of(f) # => true
```

I don't think the current behavior is necessarily wrong, but the documentation must be misleading if the current behavior is intended.

----------------------------------------
Bug #4559: Proc#== does not match the documented behaviour
https://bugs.ruby-lang.org/issues/4559#change-119698

* Author: aprescott (Adam Prescott)
* Status: Closed
* Assignee: ko1 (Koichi Sasada)
* Target version: 2.0.0
* ruby -v: ruby 1.9.2p180 (2011-02-18 revision 30909) [i686-linux]
----------------------------------------
=begin
To see a paste concisely showing the problem, see https://gist.github.com/899026/ba84d66b02727675320dc4f031637d753a41c209

Code is shown below for 1.9.2p180.

The documented behaviour (and my own expectation for (({#==}))) is: "Return true if prc is the same object as other_proc, or if they are both procs with the same body."

 RUBY_DESCRIPTION #=> ruby 1.9.2p180 (2011-02-18 revision 30909) [i686-linux]
 
 proc { 1 }     == proc { 1 }      # => true
 proc { 1 + 1 } == proc { 1 + 1 }  # => false
 
 proc { |x| x }     == proc { |x| x }      # => true
 proc { |x| x.foo } == proc { |x| x.foo }  # => false
 
 lambda { 1 }     == lambda { 1 }      # => true
 lambda { 1 + 1 } == lambda { 1 + 1 }  # => false
 
 lambda { |x| x }     == lambda { |x| x }      # => true
 lambda { |x| x.foo } == lambda { |x| x.foo }  # => false
 
 Proc.new { 1 }     == Proc.new { 1 }      # => true
 Proc.new { 1 + 1 } == Proc.new { 1 + 1 }  # => false
 
 Proc.new { |x| x }     == Proc.new { |x| x }      # => true
 Proc.new { |x| x.foo } == Proc.new { |x| x.foo }  # => false

Similar also occurs on 1.8.7; on version 1.8.7 (2011-02-18 patchlevel 334), all returned values are (({false})). I also reproduced this behaviour on 1.9.2p136 (2010-12-25 revision 30365) [i686-linux].

Attached is a file which will (({puts})) the values.
=end


---Files--------------------------------
proc-equality.rb (550 Bytes)


-- 
https://bugs.ruby-lang.org/
______________________________________________
 ruby-core mailing list -- ruby-core@ml.ruby-lang.org
 To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org
 ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/