在lua中组合两个函数

Question

我刚开始学习lua，所以我问的可能是不可能的。

现在，我有一个接受函数的方法：

function adjust_focused_window(fn)
  local win = window.focusedwindow()
  local winframe = win:frame()
  local screenrect = win:screen():frame()
  local f, s = fn(winframe, screenrect)
  win:setframe(f)
end

我有几个函数可以接受这些框架和矩形（仅显示一个）：

function full_height(winframe, screenrect)
   print ("called full_height for " .. tostring(winframe))
  local f = {
     x = winframe.x,
     y = screenrect.y,
     w = winframe.w,
     h = screenrect.h,
  }
  return f, screenrect
end

然后，我可以执行以下操作：

hotkey.bind(scmdalt, '-', function() adjust_focused_window(full_width) end)

现在，我如何在不更改其定义的情况下将多个函数组合成adjust_focused_window。比如：

hotkey.bind(scmdalt, '=', function() adjust_focused_window(compose(full_width, full_height)) end)

其中compose2 将返回一个函数，该函数接受与full_width 和full_height 相同的参数，并在内部执行如下操作：

full_height(full_width(...))

Answer 1

如 cmets 中所述，将两个函数链接在一起，您可以这样做：

function compose(f1, f2)
  return function(...) return f1(f2(...)) end
end

但是，如果您想将 2 个以上的功能连接在一起怎么办？您可能会问，是否可以将任意数量的函数“组合”在一起？

答案是肯定的——下面我展示了 3 种不同的方法来实现这一点，并简要总结了它们的后果。

迭代表方法

这里的想法是依次调用列表中的每个函数。这样做时，您将上一次调用的返回结果保存到一个表中，然后解压缩该表并将其传递给下一次调用。

function compose1(...)
    local fnchain = check_functions {...}
    return function(...)
        local args = {...}
        for _, fn in ipairs(fnchain) do
            args = {fn(unpack(args))}
        end
        return unpack(args)
    end
end

上面的check_functions 帮助器只是检查传入的东西是否确实是函数——如果不是，则会引发错误。为简洁起见省略了实现。

+：合理直接的方法。可能是您第一次尝试时想出的。

-：资源效率不高。很多垃圾表来存储调用之间的结果。您还必须处理打包和解包结果。

Y 组合模式

这里的关键见解是，即使我们调用的函数不是递归的，也可以通过将它搭载在递归函数上来实现递归。

function compose2(...)
  local fnchain = check_functions {...}
  local function recurse(i, ...)
    if i == #fnchain then return fnchain[i](...) end
    return recurse(i + 1, fnchain[i](...))
  end
  return function(...) return recurse(1, ...) end
end

+：不会像上面那样创建额外的临时表。精心编写为尾递归——这意味着调用长函数链不需要额外的堆栈空间。它有一定的优雅。

元脚本生成

通过最后一种方法，您使用一个 lua 函数，该函数实际上生成执行所需函数调用链的确切 lua 代码。

function compose3(...)
    local luacode = 
    [[
        return function(%s)
            return function(...)
                return %s
            end
        end
    ]]
    local paramtable = {}
    local fcount = select('#', ...)
    for i = 1, fcount do
        table.insert(paramtable, "P" .. i)
    end
    local paramcode = table.concat(paramtable, ",")
    local callcode = table.concat(paramtable, "(") ..
                     "(...)" .. string.rep(')', fcount - 1)
    luacode = luacode:format(paramcode, callcode)
    return loadstring(luacode)()(...)
end

loadstring(luacode)()(...) 可能需要一些解释。这里我选择将函数链编码为生成脚本中的参数名称（P1, P2, P3 等）。额外的 () 括号用于“解包”嵌套函数，因此最里面的函数就是返回的函数。 P1, P2, P3 ... Pn 参数成为链中每个函数的捕获值，例如。

function(...)
  return P1(P2(P3(...)))
end

注意，您也可以使用 setfenv 来完成此操作，但我选择这条路线只是为了避免 lua 5.1 和 5.2 之间在函数环境设置方面发生重大变化。

+：避免额外的中间表，如方法 #2。不滥用堆栈。

-：需要额外的字节码编译步骤。

Answer 2

您可以遍历传递的函数，使用前一个函数的结果依次调用链中的下一个函数。

function module._compose(...)
  local n = select('#', ...)
  local args = { n = n, ... }
  local currFn = nil

  for _, nextFn in ipairs(args) do
    if type(nextFn) == 'function' then
      if currFn == nil then
        currFn = nextFn
      else
        currFn = (function(prev, next)
          return function(...)
            return next(prev(...))
          end
        end)(currFn, nextFn)
      end
    end
  end

  return currFn
end

注意上面Immediately Invoked Function Expressions的使用，它允许重复使用的函数变量不调用无限递归循环，这发生在以下代码中：

function module._compose(...)
  local n = select('#', ...)
  local args = { n = n, ... }
  local currFn = nil

  for _, nextFn in ipairs(args) do
    if type(nextFn) == 'function' then
      if currFn == nil then
        currFn = nextFn
      else
        currFn = function(...)
          return nextFn(currFn(...)) -- this will loop forever, due to closure
        end
      end
    end
  end

  return currFn
end

虽然 Lua 不支持三元运算符，但可以使用short-circuit evaluation 去除内部的if 语句：

function module.compose(...)
  local n = select('#', ...)
  local args = { n = n, ... }
  local currFn = nil

  for _, nextFn in ipairs(args) do
    if type(nextFn) == 'function' then
      currFn = currFn and (function(prev, next)
        return function(...)
          return next(prev(...))
        end
      end)(currFn, nextFn) or nextFn
    end
  end

  return currFn
end