hawx · February 10, 2011 17:19
diff --git a/a_bench.rb b/a_bench.rb
 require_relative 'local_in_procs'

 f = lambda { message }
 a = {:message => "Hello, world!"}

 # Test the speed when using normal proc params
 f_control = lambda {|a| a[:message] }

 def rand_letters(n, l)
  r = []
  n.times do
    a = ""
    l.times do
      a << ("a".."z").to_a[rand(26)]
    end
    r << a
  end
  r
 end

 def rands(n)
  r = []
  n.times do
    r << rand
  end
  r
 end


 a_1 = {:message => "Hello, world!"}
 a_10 = Hash[ rand_letters(9, 8).zip(rands(9)) << [:message, "Hello, world!"] ]
 a_100 = Hash[ rand_letters(99, 8).zip(rands(99)) << [:message, "Hello, world!"] ]
 a_1000 = Hash[ rand_letters(999, 8).zip(rands(999)) << [:message, "Hello, world!"] ]

 n = 1000
 as = [a_1, a_10, a_100, a_1000]

 require 'benchmark'

 Benchmark.bm(20) do |x|
  as.each do |a|
    puts "\na.size = #{a.size} ----------------------------------------------------------"
    x.report "  in a class:" do 
      n.times { in_class(a, f) }
    end
    
    x.report "  multi-use class:" do
      n.times { in_missing_class(a, f) } 
    end
    
    x.report "  multi-use object:" do
      n.times { in_missing_object(a, f) }
    end
    
    x.report "  control case:" do
      n.times { f_control.call(a) }
    end
    
    x.report "  control in class:" do
      n.times { in_missing_class(a, f_control) }
    end
    
    x.report "  control in object:" do
      n.times { in_missing_object(a, f_control) }
    end
    
    GC.start # Make sure to run each run as though freshly started
  end
 end
diff --git a/local_in_procs.rb b/local_in_procs.rb
 # Here are three ways of running a proc with "local variables" set.
 # Really they aren't local variables but functions, it seems it is 
 # impossible to set local variables or run procs with bindings which
 # have the variables set. Trust me I've tried.


 # METHOD 1: WITH A CLASS
 # ----------------------
 # Create a class then set methods for each arg, then run the proc in
 # the newly created class.
 #
 def in_class(args, proc)
  k = Class.new
  
  args.each do |a,v|
    k.send(:define_method, a) { v }
  end
  
  k.new.instance_exec &proc
 end

 # METHOD 2: USING METHOD MISSING
 # ------------------------------
 # Only create one class, which is then stored in a @var, this then
 # takes the arguments and uses method missing to pass the correct
 # value from the hash.
 #
 def in_missing_class(a, f)
  if @k
    if f.arity > 0
      @k.new(a).instance_exec(a, &f)
    else
      @k.new(a).instance_exec(&f)
    end
  else
    @k = Class.new {
      def initialize(args)
        @a = args
      end
    
      def method_missing(sym, *args)
        if @a.has_key?(sym)
          @a[sym]
        else
          super
        end
      end
    }
    in_missing_class(a, f)
  end
 end

 # METHOD 3: USING METHOD MISSING AGAIN
 # ------------------------------------
 # This time create a single instance of a class which has a method
 # allowing you to set the hash of args each time it is called, this
 # way you aren't creating lots of different instances of a class.
 #
 def in_missing_object(a, f)
  if @o
    @o._run a, f
  else
    @o = Class.new {
      def _run(a, f)
        @a = a
        if f.arity > 0
          instance_exec(a, &f)
        else
          instance_exec &f
        end
      end
      
      def method_missing(sym, *args)
        if @a.has_key?(sym)
          @a[sym]
        else
          super
        end
      end
    }.new
  end
 end

 a = {:name => "world"}
 f = proc { puts "Hello, #{name}!" }

 in_class(a, f)
 #=> Hello, world!
 in_missing_class(a, f)
 #=> Hello, world!
 in_missing_object(a, f)
 #=> Hello, world!
diff --git a/n_bench.rb b/n_bench.rb
 require_relative 'local_in_procs'

 f = lambda { message }
 a = {:message => "Hello, world!"}

 # Test the speed when using normal proc params
 f_control = lambda {|a| a[:message] }


 require 'benchmark'

 ns = [10, 100, 1000, 10_000, 100_000]
 Benchmark.bm(20) do |x|
  ns.each do |n|
    puts "\nn = #{n} ----------------------------------------------------------"
    x.report "  in a class:" do 
      n.times { in_class(a, f) }
    end
    
    x.report "  multi-use class:" do
      n.times { in_missing_class(a, f) } 
    end
    
    x.report "  multi-use object:" do
      n.times { in_missing_object(a, f) }
    end
    
    x.report "  control case:" do
      n.times { f_control.call(a) }
    end
    
    x.report "  control in class:" do
      n.times { in_missing_class(a, f_control) }
    end
    
    x.report "  control in object:" do
      n.times { in_missing_object(a, f_control) }
    end
    
    GC.start # Make sure to run each run as though freshly started
  end
 end
diff --git a/results.md b/results.md
	require_relative 'local_in_procs'

	f = lambda { message }
	a = {:message => "Hello, world!"}

	# Test the speed when using normal proc params
	f_control = lambda {\|a\| a[:message] }

	def rand_letters(n, l)
	r = []
	n.times do
	a = ""
	l.times do
	a << ("a".."z").to_a[rand(26)]
	end
	r << a
	end
	r
	end

	def rands(n)
	r = []
	n.times do
	r << rand
	end
	r
	end


	a_1 = {:message => "Hello, world!"}
	a_10 = Hash[ rand_letters(9, 8).zip(rands(9)) << [:message, "Hello, world!"] ]
	a_100 = Hash[ rand_letters(99, 8).zip(rands(99)) << [:message, "Hello, world!"] ]
	a_1000 = Hash[ rand_letters(999, 8).zip(rands(999)) << [:message, "Hello, world!"] ]

	n = 1000
	as = [a_1, a_10, a_100, a_1000]

	require 'benchmark'

	Benchmark.bm(20) do \|x\|
	as.each do \|a\|
	puts "\na.size = #{a.size} ----------------------------------------------------------"
	x.report " in a class:" do
	n.times { in_class(a, f) }
	end

	x.report " multi-use class:" do
	n.times { in_missing_class(a, f) }
	end

	x.report " multi-use object:" do
	n.times { in_missing_object(a, f) }
	end

	x.report " control case:" do
	n.times { f_control.call(a) }
	end

	x.report " control in class:" do
	n.times { in_missing_class(a, f_control) }
	end

	x.report " control in object:" do
	n.times { in_missing_object(a, f_control) }
	end

	GC.start # Make sure to run each run as though freshly started
	end
	end
	# Here are three ways of running a proc with "local variables" set.
	# Really they aren't local variables but functions, it seems it is
	# impossible to set local variables or run procs with bindings which
	# have the variables set. Trust me I've tried.


	# METHOD 1: WITH A CLASS
	# ----------------------
	# Create a class then set methods for each arg, then run the proc in
	# the newly created class.
	#
	def in_class(args, proc)
	k = Class.new

	args.each do \|a,v\|
	k.send(:define_method, a) { v }
	end

	k.new.instance_exec &proc
	end

	# METHOD 2: USING METHOD MISSING
	# ------------------------------
	# Only create one class, which is then stored in a @var, this then
	# takes the arguments and uses method missing to pass the correct
	# value from the hash.
	#
	def in_missing_class(a, f)
	if @k
	if f.arity > 0
	@k.new(a).instance_exec(a, &f)
	else
	@k.new(a).instance_exec(&f)
	end
	else
	@k = Class.new {
	def initialize(args)
	@a = args
	end

	def method_missing(sym, *args)
	if @a.has_key?(sym)
	@a[sym]
	else
	super
	end
	end
	}
	in_missing_class(a, f)
	end
	end

	# METHOD 3: USING METHOD MISSING AGAIN
	# ------------------------------------
	# This time create a single instance of a class which has a method
	# allowing you to set the hash of args each time it is called, this
	# way you aren't creating lots of different instances of a class.
	#
	def in_missing_object(a, f)
	if @o
	@o._run a, f
	else
	@o = Class.new {
	def _run(a, f)
	@a = a
	if f.arity > 0
	instance_exec(a, &f)
	else
	instance_exec &f
	end
	end

	def method_missing(sym, *args)
	if @a.has_key?(sym)
	@a[sym]
	else
	super
	end
	end
	}.new
	end
	end

	a = {:name => "world"}
	f = proc { puts "Hello, #{name}!" }

	in_class(a, f)
	#=> Hello, world!
	in_missing_class(a, f)
	#=> Hello, world!
	in_missing_object(a, f)
	#=> Hello, world!