将 splat 参数映射到方法参数上

Question

我们创建一个带有散装参数的方法，并对其调用Method#parameters：

def splatter(x, *y, z); end
params = method(:splatter).parameters
  # => [[:req, :x], [:rest, :y], [:req, :z]]

我正在寻找一个函数f，它将参数列表映射到其相应的变量名称上。该函数应该足够灵活，可以在任何其他具有任意放置的 splat 参数的方法上工作。例如：

args = [:one, :two, :three, :four]
f(params, args)
  # => [[:x, :one], [:y, :two], [:y, :three], [:z, :four]]

或类似的东西（翻转的元素也可以）。我觉得必须有一个灵活、优雅的解决方案，使用 inject 或其他东西，但我似乎想不出它。

Answer 1

def f(params,*args)
    # elements to be assigned to splat parameter
    splat = args.count - params.count + 1
    # will throw an error if splat < 0 as that means not enough inputs given        
    params.map{ |p|     
            [ p[1] , ( p.first == :rest ? args.shift(splat) : args.shift  ) ]
           }
end

例子

def splatter(x,*y,z)
    # some code
end
f(method(:splatter).parameters, 1,2,3,4)
#=>[[:x, 1], [:y, [2, 3]], [:z, 4]]
def splatter(x,y,*z)
    # some code
end
f(method(:splatter).parameters, 1,2,3,4)
# => [[:x, 1], [:y, 2], [:z, [3, 4]]]
def splatter(x,*z)
    # some code
end
f(method(:splatter).parameters, 1)
# => [[:x, 1], [:z, []]]

Answer 2

我认为这是一个很好的例子，eval很有用。下面的代码生成一个 lambda，它采用与指定相同的参数并吐出已解析的参数列表。这种方法的优点是使用了 Ruby 自己的算法来解析 splats。

def resolve(parameters,args)
  param_list = parameters.map do |type,name|
    splat = '*' if type == :rest
    "#{splat}#{name}"
  end.join(',')
  source = ""
  source << "->(#{param_list}) don"
  source << "  res = []n"
  parameters.each do |type,name|
    if type == :rest
      source << "  res += #{name}.map {|v| [:'#{name}',v] }n"
    else
      source << "  res << [:'#{name}',#{name}]n"
    end
  end
  source << "end"
  eval(source).call(*args)
end

例：

params = ->(x,*y,z){}.parameters
resolve(params,[:one, :two, :three, :four])
#=> [[:x, :one], [:y, :two], [:y, :three], [:z, :four]]

在

后台，生成了以下代码：

->(x,*y,z) do
  res = []
  res << [:'x',x]
  res += y.map {|v| [:'y',v] }
  res << [:'z',z]
end

另一个有两个参数的例子，首先是splat：

params = ->(*x,y){}.parameters
resolve(params,[:one, :two, :three, :four])
#=> [[:x, :one], [:x, :two], [:x, :three], [:y, :four]]

生成的代码是

->(*x,y) do
  res = []
  res += x.map {|v| [:'x',v] }
  res << [:'y',y]
end

Answer 3

编辑：在我最初的困惑之后：

def doit(params, args)
  rest_ndx = params.map(&:first).index(:rest)
  to_insert = [params[rest_ndx].last]*(args.size-params.size) if rest_ndx
  params = params.map(&:last)
  params.insert(rest_ndx,*to_insert) if rest_ndx
  params.zip(args)
end