不得不说贵站管理员说话真有意思，标题求兼职，用换工作回答，并得出了找不到工作，以及自己的问题的滑坡结论。
重申：本人目前在职前端，零散时间教 Ruby。求兼职。
另外这个号才是本尊。(顺便反馈 github 关联账号似乎最近无法正常登陆)

有时候总觉得脆弱的身体支撑不住发散的精神

方法名和参数的话视你具体情况可以用自动推理，比如放在 method_missing 里面，然后参数如果是 Fixnum 就写一个 int，String 就写一个 char *，现场 attach_function

直线救国的话：

class B
    def a
       'b'
   end
end
class A < B
   def a
       #do some stuff
       super
   end
end

因为有可能是在别的地方这么弄一下的话：

obj = A.new
B.instance_method(:a).bind(obj).call

#4 楼 @gihnius 这个几乎就是 Enumerator 简化版

可以用 Fiddle::Closure(ruby ~>2.0) 或者 ffi(rubygems) 的有关方法来把一个 lambda 变成一个函数指针类似的东西，比如假设这个方法叫做 foo，那么 foo{|a| p a }可以变成一个有函数指针的东西，效果是把传进去的第一个参数 p 出来，这是 CRuby 做 Callback 的一种方法，但是如果你想把这个 Callback 作为创建线程的参数，也就是可能有真多线程，可能会因为全局虚拟机锁 (GVML/GIL，目前版本的 CRuby) 导致奇怪的问题……

http://ideone.com/iZPfls

用了比较诡异的办法，自己造了作用域，但是肯定还有一些边角问题，勉强抛砖引玉吧

可以用下面的代码测试：

1.upto(10).with_control{|i|
  eval("Control.next if i % 2 == 0")
  p i
} 

还有一个不成熟的标签，类似 Java 的 break label，这里预想也是支持 next 和 redo 的

1.upto(10).with_control{|i|
  a = Control.label                       #获得标签，标签指向的是外层的with_control
  1.upto(10).with_control{|j|
     Control.break a if i > 3 && j > 3  #满足条件时，连外层一起break掉
     p [i, j]
  }
} 

#14 楼 @reus 其实有考虑过用 llvm 来 jit 或者产生代码（但并不是即时）……

#12 楼 @luikore 恩恩，感谢，druby 这种风格的可能是我要找的，我去看看这几个

#9 楼 @luikore 感觉 1F 内透过 swig 界面调用这些函数，还是效率损失比较大的样子？ 能不能把这些函数的调用批量化。。

#7 楼 @luikore 然后就是 3D 渲染有效率问题……，直接用 Ruby 操作矩阵肯定不行，但是间接一点，矩阵作为 C++ 实现的对象，Ruby 只是决定他们乘起来的顺序，感觉效率还是有点低的样子，也不知道怎么封装比较好。。？

#4 楼 @jjym 可能这个实践不太好，准确说是不打算把 Ruby 当做一个 lua 那样的脚本，而是整体就作为框架语言的感觉。

#3 楼 @luikore luikore 大牛出现了~~ 嗯，现在的问题是 C++ 不能正确传递异常，比如 DL::CPtr 中的 win32 异常，或者干脆就是 C++ 中的错误指针就直接崩了，fiddle/dl/win32api 都试过……，感觉 Ruby 或者 C++ 单独都 hold 不住全局的样子……

目前的想法是转换成 C++，objc 不太了解，打算去了解下……

#1 楼 @jjym 可以想象成 RPGMaker 那种，或者 RubySDL 的，或者 Rubygame 的那种风格

嗯，用 case 匹配的: 或者http://codepad.org/TES3Rb1Y

def matchlist(mdata, x, xs)
  ->list{
     Array === list && ->list{ 
        mdata[x], *mdata[xs] = list; mdata[x]
     }.(list) ## 木有 >>=要手动传递真不爽……
  }
end

def reverse list, mdata = {}; case list
    when [] then []
    when matchlist(mdata, :x, :xs) then reverse(mdata[:xs]) << mdata[:x]
end;end

p reverse [1,2,3,4,5]

#2 楼 @iBachue local_variables 的取法才 evil…… 单纯 global_variables 还好…… (不过也没有检测变量名)

def gv_get(a)
  eval a.to_s
end

def gv_set(a, b)
  eval "#{a}=b"
end

def lv_get(a, binding = nil, &block)
  eval a.to_s, binding || block.binding
end

def lv_set(a, b, binding = nil, &block)
  eval "#{a}=ObjectSpace._id2ref(#{b.object_id})", binding || block.binding
end



gv_set(:$a, 3)
gv_get(:$a)

a = 3
p lv_get(:a){}
lv_set(:a, 5){}
p a

r = lambda{
  a = 3
  b = 5
  binding
}.call

p lv_get(:a, r) + lv_get(:b, r)

因为楼主的代码看起来也是在匿名 Module m 的上下文运行 yield 等价的东西……，但 yield 是和写块的位置绑定的，所以干脆手动制作一个上下文。。。除了闭包上下文还有 self 上下文呢，啊哈：（楼上 Fiber 的自动切换上下文很厉害的~）

def filter(name, &blk)
  @__filters ||= []
  @__filters << [name, blk]
end

def run_filters(&blk)
  m = Module.new do
    extend self
    @__filter_endpoint = blk

    def scope
      Thread.current[:__myblock] ||= []
    end
    def go
       scope[-1].call
    end
    private :scope, :go
  end
  code = '@__filter_endpoint.call'
  @__filters.each do |name, block|
    m.send(:define_method, :"__filter_#{name}"){|&b|
       scope.push b
       ret = instance_eval &block  
       scope.pop
       ret
    }
  end
  @__filters.each do |name, block|
    code = "send(:\"__filter_#{name}\") { #{code} } "
  end
  m.module_eval code.tap {|c| puts c}
end

filter '1' do
  puts 1
  go
  puts 1
end

filter '2' do
  puts 2
  go
  puts 2
end

filter '3' do
  puts 3
  go
  puts 3
end

run_filters do
  puts 'core'
end

非要 Ruby 的话，干脆拿 Win32 SDK 函数写吧，加上 Ruby 本身能力可以和 VB6 很像……