Project

General

Profile

Bug #11704

Refinements only get "used" once in loop

Added by danielpclark (Daniel P. Clark) over 3 years ago. Updated about 3 years ago.

Status:
Assigned
Priority:
Normal
Target version:
-
[ruby-core:71528]

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

History

Updated by danielpclark (Daniel P. Clark) over 3 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) over 3 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 when using 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) about 3 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) about 3 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) about 3 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"

Also available in: Atom PDF