从迭代器调用迭代器，绑定参数

Question

为了简单起见，我们假设以下方法：

def inner(p)
%w(a b c d).each {|x| yield("#{p} inner #{x}")}
end

我想要一个函数outer，它与inner相同，但参数p绑定到某个值，例如

def outer
inner('haha') // This is NOT correct. It's just to give you an idea.
end

这不起作用：如果我做一个

outer {|q| puts q}

我收到一个LocalJumpError：收益被调用出块。

一种解决方法显然是：

def outer
inner('haha') { |x| yield(x) }
end

不是很优雅，因为一个产量只是产生下一个产量。一种更简洁的方法是显式传递块：

def inner(p, &block)
%w(a b c d).each {|x| block.yield("#{p} inner #{x}")}
end
def outer(&block)
inner('haha', &block)
end

虽然有人可能会争辩说，无论如何，显式编写块参数是更好的解决方案，因为我们可以从方法签名中看到块是预期的，但我仍然想知道是否有一种干净的方法可以在没有&block参数的情况下实现我的目标。

更新：修复代码中缺少&。

Answer 1

这工作正常

def inner(p)
%w(a b c d).each {|x| yield("#{p} inner #{x}")}
end
def outer(&block)
inner('haha', &block)
end
def outer(&block)
inner('haha', &block)
end
outer {|haha_and_item| puts haha_and_item}
# haha inner a
# haha inner b
# haha inner c
# haha inner d

outer似乎只是一个包装方法，其唯一目的是存储字符串haha。然后，它接受将根据inner方法定义执行的块或Proc。

如果你想使用一种方法，你的示例是我知道的唯一可用的语法。但似乎你正在寻找一个closure也许是一个携带的。

下面是一个示例：

def inner(parameter)
inner_closure = -> (runable) do
%w(a b c d).each { |x| runable.("#{parameter} inner #{x}") }
end
inner_closure.curry
end
parameter = 'ahah'
runable = proc {|haha_and_item| puts haha_and_item}
outer = inner(parameter)
outer[runable] 
outer = inner('closure')
outer[runable]
# ahah inner a
# ahah inner b
# ahah inner c
# ahah inner d
# closure inner a
# closure inner b
# closure inner c
# closure inner d