Bug #11704
closedRefinements only get "used" once in loop
Description
Same results on Ruby 2.2.2 through Ruby 2.3.0dev (2015-11-18 trunk 52625) [x86_64-linux]
I wrote a benchmark for testing different ways of implementing a uniq
method and I chose to do it using refinements. I looped over the results in the benchmark and refined the method with 6 different refinements which each worked. But the next iteration when using
is called it doesn't re-refine with previously used refinements.
Example benchmark output on first iteration:
Array.new(200) !self.dup.uniq! 1.770000 0.010000 1.780000 ( 1.778248)
Array.new(200) == uniq.length 1.860000 0.000000 1.860000 ( 1.866862)
Array.new(200) == uniq.sort 2.580000 0.010000 2.590000 ( 2.584515)
Array.new(200) each index 41.450000 0.080000 41.530000 ( 41.626149)
Array.new(200) combination(2) 23.460000 0.060000 23.520000 ( 23.568865)
Array.new(200) == self.uniq 1.900000 0.010000 1.910000 ( 1.909466)
After that the same methods did not get refined.
Array.new(210) !self.dup.uniq! 1.990000 0.000000 1.990000 ( 2.004269)
Array.new(210) == uniq.length 2.030000 0.010000 2.040000 ( 2.032602)
Array.new(210) == uniq.sort 1.990000 0.000000 1.990000 ( 1.999509)
Array.new(210) each index 1.990000 0.010000 2.000000 ( 2.000181)
Array.new(210) combination(2) 2.000000 0.000000 2.000000 ( 2.010159)
Array.new(210) == self.uniq 2.000000 0.010000 2.010000 ( 2.009117)
Array.new(220) !self.dup.uniq! 2.100000 0.010000 2.110000 ( 2.113701)
Array.new(220) == uniq.length 2.070000 0.000000 2.070000 ( 2.075249)
Array.new(220) == uniq.sort 2.090000 0.010000 2.100000 ( 2.102771)
Array.new(220) each index 2.070000 0.000000 2.070000 ( 2.077393)
Array.new(220) combination(2) 2.070000 0.010000 2.080000 ( 2.079561)
Array.new(220) == self.uniq 2.100000 0.010000 2.110000 ( 2.110839)
Array.new(230) !self.dup.uniq! 2.210000 0.000000 2.210000 ( 2.236008)
Array.new(230) == uniq.length 2.160000 0.010000 2.170000 ( 2.166484)
Array.new(230) == uniq.sort 2.140000 0.000000 2.140000 ( 2.150384)
Array.new(230) each index 2.130000 0.010000 2.140000 ( 2.134572)
Array.new(230) combination(2) 2.120000 0.000000 2.120000 ( 2.129683)
Array.new(230) == self.uniq 2.130000 0.010000 2.140000 ( 2.137515)
I found no way to inspect what code was being used as refinements currently don't allow introspection (I have read the Refinement Specs https://bugs.ruby-lang.org/projects/ruby-trunk/wiki/RefinementsSpec ). But I figure if I wanted to see what the refinement was I could write an additional method to document the current refinement in use.
module BooleanUniqWithEqualLength
refine Array do
def uniq?
self.length == self.uniq.length
end
def which_refinement_uniq?
"self.length == self.uniq.length"
end
end
end
But introspection is not the issue I'm raising here. The issue is that you can only use the refinement once within the scope of the loop. Look at the benchmark results and see the first 6 are correct, and the following 3 times the output is lying about what refinement is being used.
Here's the full benchmark code:
require 'securerandom'
require 'benchmark'
# written to allow 65,536 unique array items
array_of_x = lambda {|x| SecureRandom.hex(x*2).scan(/..../) }
module Refinements
module BooleanUniqWithDupUniqBang
refine Array do
def uniq?
!self.dup.uniq!
end
end
end
module BooleanUniqWithEqualLength
refine Array do
def uniq?
self.length == self.uniq.length
end
end
end
module BooleanUniqWithEqualSort
refine Array do
def uniq?
self.sort == self.uniq.sort
end
end
end
module BooleanUniqWithEachIndex
refine Array do
def uniq?
self.each_with_index { |a,b|
self.each_with_index { |c,d|
next if b == d
return false if a == c
}
}
true
end
end
end
module BooleanUniqWithCombination
refine Array do
def uniq?
self.combination(2).each {|a,b| return false if a == b}
true
end
end
end
module BooleanUniqWithUniq
refine Array do
def uniq?
self == self.uniq
end
end
end
end
bench_reps = 10_000
bench = Benchmark.benchmark("\nTesting various ways of implementing :uniq? on Array\n(smaller numbers are better)\n\n",34) do |x|
# Note doing anymore than one test per test type seems to wash the results into all things being equal.
# Only the first test gives realistic numbers.
[500].each do |qty|
x.report("Array.new(#{qty}) !self.dup.uniq!") {
using Refinements::BooleanUniqWithDupUniqBang
bench_reps.times do
array_of_x.(qty).uniq?
end
}
x.report("Array.new(#{qty}) == uniq.length") {
using Refinements::BooleanUniqWithEqualLength
bench_reps.times do
array_of_x.(qty).uniq?
end
}
x.report("Array.new(#{qty}) == uniq.sort") {
using Refinements::BooleanUniqWithEqualSort
bench_reps.times do
array_of_x.(qty).uniq?
end
}
x.report("Array.new(#{qty}) each index") {
using Refinements::BooleanUniqWithEachIndex
bench_reps.times do
array_of_x.(qty).uniq?
end
}
x.report("Array.new(#{qty}) combination(2)") {
using Refinements::BooleanUniqWithCombination
bench_reps.times do
array_of_x.(qty).uniq?
end
}
x.report("Array.new(#{qty}) == self.uniq") {
using Refinements::BooleanUniqWithUniq
bench_reps.times do
array_of_x.(qty).uniq?
end
}
end
end
Updated by danielpclark (Daniel P. Clark) almost 9 years ago
Change the
[500].each do |qty|
to
[200, 210, 220, 230].each do |qty|
For the same benchmark test.
Updated by shugo (Shugo Maeda) almost 9 years ago
- Status changed from Open to Assigned
- Assignee set to matz (Yukihiro Matsumoto)
Daniel P. Clark wrote:
I wrote a benchmark for testing different ways of implementing a
uniq
method and I chose to do it using refinements. I looped over the results in the benchmark and refined the method with 6 different refinements which each worked. But the next iteration whenusing
is called it doesn't re-refine with previously used refinements.
Once refinements are activated by using
in a specific order, the precedence of the refinements cannot be changed,
because Refinements are not designed for such dynamic use.
What do you think, Matz?
Updated by danielpclark (Daniel P. Clark) over 8 years ago
According to John (who commented on my blog on this issue) this is a Dynamic Dispatch issue. And the following example may be a related.
module Moo
refine Fixnum do
def to_s
"moo"
end
end
end
class A
using Moo
def a
[1,2,3].map {|x| x.to_s }
end
def b
[1,2,3].map(&:to_s)
end
end
A.new.a
# => ["moo", "moo", "moo"]
A.new.b
# => ["1", "2", "3"]
Updated by sawa (Tsuyoshi Sawada) over 8 years ago
Daniel P. Clark wrote:
According to John (who commented on my blog on this issue) this is a Dynamic Dispatch issue. And the following example may be a related.
I had made a feature request #12079 (later than this post) to allow refinements to be effective in such cases. It can be a way to think about this issue.
Updated by danielpclark (Daniel P. Clark) over 8 years ago
Tsuyoshi Sawada wrote:
I had made a feature request #12079 (later than this post) to allow refinements to be effective in such cases.
I like it. One note: Your code examples don't have a lexically scoped block. For them to work in Ruby 2.2.3 in the global scope as you're showing you'd need a begin/end block. Works in Ruby 2.2.3 but not 2.3.0. I believe as of Ruby 2.3 it may only be done within a class definition.
module Moo
refine Fixnum do
def to_s
"moo"
end
end
end
begin # valid Ruby 2.2.3 and NOT Ruby 2.3
using Moo
1.to_s
end
# => "moo"
Updated by jeremyevans0 (Jeremy Evans) about 3 years ago
- Related to Bug #14083: Refinement in block calling incorrect method added
Updated by matz (Yukihiro Matsumoto) over 1 year ago
- Status changed from Assigned to Rejected
The behavior is intended.
Matz.