[ruby-dev:29078] Re: block wrapper

In article <[e-mail]>,
  Tanaka Akira <[e-mail]> writes:

> 系統的に調べる気になって、スクリプトを書いて調べて見ました。

このスクリプトが間違っていたので直して、いろいろと考えてみました。

% ~/ruby/19/ruby/ruby block-wrapper.rb
...
{|*v|yield(*v)}:        1259/43956      2.86422786422786%
{|v|yield(v)}:          11945/43956     27.1749021749022%
{|*v|b.call(*v)}:       2463/43956      5.6033306033306%
{|v|b.call(v)}:         36199/43956     82.3528073528073%
{|*v|b.yield(*v)}:      1589/43956      3.61497861497861%
{|v|b.yield(v)}:        11910/43956     27.0952770952771%

% ~/ruby/18/ruby/ruby block-wrapper.rb
...
{|*v|yield(*v)}:        2332/29304      7.95795795795796%
{|v|yield(v)}:          7092/29304      24.2014742014742%
{|*v|b.call(*v)}:       2260/29304      7.71225771225771%
{|v|b.call(v)}:         14470/29304     49.3789243789244%

1.8 の {|*v|yield(*v)} で約8% だった失敗率が 1.9 の
{|*v|yield(*v)} で約3% に下がっているので、数としては減って
います。

ただ、pp.rb の失敗のように、個々の例については以前は wrapper
になっていたものが wrapper にならなくなってしまったものもあ
りますから、単純に改善とはいえません。

というか、失敗した例を比べてみると、1.9 での失敗はすべて受け
側のブロックが {|v| ... } というひとつの変数のケースであるの
に対し、1.8 での失敗は全てそうでない ({|| ... } と変数がひと
つもないか {|v1, v2| ... } など変数が 2つ以上ある) ケースで
す。wrapper の観点から見ると、改善というよりは、うまくいかな
い仕掛けからやっぱりうまくいかない他の仕掛けに変わったという
印象です。

そして、1.9 で {|*v|yield(*v)} という wrapper がうまくいかな
い例を調べてみると、ほとんどは b.call でブロックを呼んだ場合
です。考えてみると、これは yield と call の違いを使って工夫
しようという方針から納得できます。yield と call は違うのです
から、それらを区別せずに yield で中継すればおかしなことにな
るのは想像に難くありません。

また、{|*v|b.call(*v)} を wrapper として使うと、うまくいかな
いケースはすべてが yield か b.yield でブロックを呼んだ場合で
す。これも同様に件の方針から納得できます。

ここで、興味深いのは、{|*v|yield(*v)} の場合には失敗の
「ほとんど」が b.call に関するものであるのに対し、
{|*v|b.call(*v)} の場合には失敗の「すべて」が yield と
b.yield に関するものだという違いです。

ここで疑問があるのですが、yield を 現在の 1.9 の b.call の動
作にしてしまわないのはなんででしょう?

もしそうなってくれれば、現在の ({|*v|b.call(*v)} での失敗の
原因の) yield/b.yield はなくなって、完全に動く wrapper が実
現できるのですが。

ARGS = [
  #nil,
  "",
  "v1",
  "v1,v2",
  "*v1",
  "v1,*v2",
  "v1,v2,*v3",
  #"v1,*v2,v3",
  #"*v1,v2",
  #"*v1,v2,v3"
]

YIELDS = %W[
  yield
  b.yield
  b.call
]

VALUES = [
  0,
  [],
  [0],
  [[]],
  [[0]],
  [[[]]],
  [0,0],
  [0,[]],
  [[],0],
  [[],[]]
]

WRAPBLOCKS = [
  "{|*v|yield(*v)}",
  "{|v|yield(v)}",
  "{|*v|b.call(*v)}",
  "{|v|b.call(v)}",
  "{|*v|b.yield(*v)}",
  "{|v|b.yield(v)}",
]

unless lambda{}.respond_to? :yield
  YIELDS.delete("b.yield")
  WRAPBLOCKS.reject! {|b| /b.yield/ =~ b }
end

# def calleeNN(vv) YIELD(ARGS) end
# def callerNN(callee_name, *vs) __send__(callee_name, *vs) {|ARGS| ... } end
# def callerNN(callee_name, *vs) __send__(callee_name, *vs, &lambda {|ARGS| ... }) end
#
# def wrapperNN(callee_name, *vs) __send__(callee_name, *vs) WRAPBLOCK end

CALLEE = []
def define_callee
  name = "callee00"
  ARGS.each {|as|
    next if !as
    vars = as.scan(/v\d/)
    varsb = (vars+['&b']).join(',')
    YIELDS.each {|y|
      name.succ!
      n = name.dup
      eval "def #{n}(#{varsb}) #{y}(#{as}) end"
      CALLEE << [n, [vars.length, "#{y}(#{as})"]]
    }
  }
end
define_callee

CALLER = []
def define_caller
  name = "caller00"
  ARGS.each {|as|
    vars = as ? as.scan(/v\d/) : []
    as = as ? "|#{as}|" : ''
    name.succ!
    n = name.dup
    eval "def #{n}(callee_name, *vs) __send__(callee_name, *vs) {#{as} [#{vars.join(',')}] } end"
    CALLER << [n, "{#{as}}"]
  }
  ARGS.each {|as|
    vars = as ? as.scan(/v\d/) : []
    as = as ? "|#{as}|" : ''
    name.succ!
    n = name.dup
    eval "def #{n}(callee_name, *vs) __send__(callee_name, *vs, &lambda {#{as} [#{vars.join(',')}] }) end"
    CALLER << [n, "&{#{as}}"]
  }
end
define_caller

WRAPPER = []
def define_wrapper
  name = "wrapper00"
  WRAPBLOCKS.each {|w|
    name.succ!
    n = name.dup
    w2 = w.sub(/\|.*\|/) { $& + "$wrapper_value = v;"  }
    eval "def #{n}(callee_name, *vs, &b) __send__(callee_name, *vs) #{w2} end"
    WRAPPER << [n, w]
  }
end
define_wrapper

def perm(vs, n)
  if n == 0
    yield []
  else
    perm(vs, n-1) {|vv|
      vs.each {|v| yield vv + [v] }
    }
  end
end

$VERBOSE = nil

def check(callee_name, callee_desc, wrapper_name, wrapper_desc, caller_name, caller_desc, vs)
  r1 = (__send__(caller_name, callee_name, *vs) rescue $!)
  r2 = (__send__(caller_name, wrapper_name, callee_name, *vs) rescue $!)
  wv = $wrapper_value
  success = r1 == r2 || (r1.kind_of?(Exception) && r2.kind_of?(Exception) && r1.class == r2.class && r1.message == r2.message)
  print(success ? "succ\t" : "fail\t")
  vs2 = vs.dup
  cd = callee_desc.gsub(/v\d/) { vs2.shift.inspect }.gsub(/ /, '')
  wd = (wrapper_desc + '/' + wv.inspect).gsub(/ /, '')
  r1 = r1.inspect.gsub(/ /, r1.kind_of?(Exception) ? '_' : '')
  r2 = r2.inspect.gsub(/ /, r2.kind_of?(Exception) ? '_' : '')
  print cd, "\t"
  print wd, "\t"
  print caller_desc, "\t"
  print r1, "\t"
  print r2, "\n"
  success
end

count = {}
error = {}
WRAPPER.each {|wrapper_name, wrapper_desc|
  count[wrapper_desc] = 0
  error[wrapper_desc] = 0
  CALLEE.each {|callee_name, (callee_arity, callee_desc)|
    perm(VALUES, callee_arity) {|vs|
      CALLER.each {|caller_name, caller_desc|
        count[wrapper_desc] += 1
        success = check(callee_name, callee_desc, wrapper_name, wrapper_desc, caller_name, caller_desc, vs)
        error[wrapper_desc] += 1 if !success
      }
    }
  }
  puts
}

WRAPPER.each {|wrapper_name, wrapper_desc|
  c = count[wrapper_desc]
  e = error[wrapper_desc]
  puts "#{wrapper_desc}:\t#{e}/#{c}\t#{e*100.0/c}%"
}
-- 
[田中 哲][たなか あきら][Tanaka Akira]