本站页面（多半）转载自萌娘百科的同名页面，依CC BY-NC-SA 3.0引入，贡献者可以在历史页查询。
因各种原因页面内容可能和源页面有所出入，非本站特有页面内容请以萌娘百科为准。此外，因萌百的api限制，本站部分页面和图片同步自另一个镜像站。
置顶公告：【置顶】关于临时开启评论区所有功能的公告(2022.10.22) | 【置顶】关于本站Widget恢复使用的公告
  • 你好～！欢迎来到萌娘百科镜像站！如需查看或编辑，请联系本站管理员注册账号。
  • 本镜像站和其他萌娘百科的镜像站无关，请注意分别。

Module:Luaq

猛汉♂百科，万男皆可猛的百科全书！转载请标注来源页面的网页链接，并声明引自猛汉百科。内容不可商用。
跳到导航 跳到搜索
Template-info.svg 模块文档  [查看] [编辑] [历史] [刷新]
这个文档嵌入自Module:Luaq/doc。

LUAQ是Lua Query的缩写，通过一系列查询函数让以Lua表（table）为主的数据源查询代码更加简洁。

使用配置

在模块代码中添加如下代码： 

  1. require("Module:Luaq")

之后便可以通过luaq使用各种查询函数。

使用

本章节将会介绍LUAQ的基本概念、查询函数的文档说明以及使用时必须或可选的注意事项。

若您想要了解查询函数的实现细节，或者希望修改结构、添加更多查询函数，请参阅#开发章节。

基本概念

查询对象

查询对象是由LUAQ的查询函数按照某种规范生成的特殊对象，它的本质是Lua表，但由于其内部的结构对于使用者来说是未知的，所以无法通过一般的手段获取它的内部结构。

实际上，使用者没有必要尝试去获取它的内部结构，若要获取它包含的内容，请参阅#查询展开章节。

延迟查询

延迟查询是LUAQ的重要特征之一，它表现为——当查询对象被生成时，查询对象并不会立即展开。唯有调用某些查询函数时，查询对象才会被计算，并返回查询结果。

在“查询对象被生成时”和“调用立即展开查询对象的函数”之间，改变作为数据源的Lua表内容将对最终查询结果会造成影响；当查询对象被展开后，无论数据源发生任何改变，都不会改变查询结果。

在#查询函数章节中，会立即展开查询对象的函数将注有说明。

查询展开

查询展开是指将包含了一系列指令的查询对象转化为结果的过程。一共有两种方式进行展开。

enum：

enum(query)

全局函数，返回展开查询对象的迭代器。

函数返回三个值：

  1. 迭代器函数
  2. 查询对象本身
  3. 0

迭代器用在泛型for循环中。

luaq.query：

请参阅luaq.query。

查询函数调用格式

为了使代码更加直观简洁，LUAQ在Lua函数调用语法糖的基础上支持了更简洁的写法。以下两种写法是等价的：

函数：

luaq.<查询函数名称>(查询对象[, 参数1[, 参数2[..., 参数n]]])

语法糖：

查询对象:<查询函数名称>([, 参数1[, 参数2[..., 参数n]]])

当您使用了语法糖调用形式，并且遇到了莫名其妙的“函数“...”的第1个参数类型错误（应为table，实为...）。"”报错，不妨检查一下是否将:错写成了.。

查询函数

luaq.query

luaq.query(query)

展开一个查询对象。

这个函数将立即展开查询对象，并将查询结果包装为一个Lua表返回。
参数：
返回：
一个Lua表，其数值类型的键即为查询结果每一项的位置索引。

luaq.asQuery

luaq.asQuery(t)

将一个Lua表包装为查询对象。

当参数t已经是查询对象时，将返回其本身。
参数：
  • t：一个Lua表。
返回：
一个查询对象。
若参数t为一个查询对象时，函数将会返回t自身。
否则将会返回一个包装了t的查询对象。
错误：
  1. 函数“asQuery”的第1个参数类型错误（应为table，实为...）。"：当参数t的值不是一个Lua表的时候抛出此错误。
示例：
  • 代码：
  1. <strong class="error"><span class="scribunto-error" id="mw-scribunto-error-0">脚本错误：函数“main”不存在。</span></strong>
  • 结果：
<strong class="error"><span class="scribunto-error" id="mw-scribunto-error-1">脚本错误：函数“main”不存在。</span></strong>

luaq.select

luaq.select(query, func)

对旧查询对象的每一个项进行指定的转换，并将结果形成新的查询对象。

参数：
  • query：一个查询对象，其每一个项将要被转换。
  • func：对query的每一个项进行的转换函数。转换函数将会接受到两个参数值：
    • 第1个参数值：query的当前项。
    • 第2个参数值：从开始到当前的索引。
返回：
一个查询对象。它由转换后的项组成。
错误：
  1. bad argument #2 to 'select' (table expected, got ...)：当参数func的值不是一个函数的时候抛出此错误。
示例1：

在本示例中，转换函数返回当前项的值的类型。

  • 代码：
  1. <strong class="error"><span class="scribunto-error" id="mw-scribunto-error-2">脚本错误：函数“main”不存在。</span></strong>
  • 结果：
<strong class="error"><span class="scribunto-error" id="mw-scribunto-error-3">脚本错误：函数“main”不存在。</span></strong>
示例2：

在本示例中，luaq.select函数判断当前索引的奇偶性。若索引为奇数，则返回key字段的值；若索引为偶数，则返回value字段的值。

  • 代码：
  1. local t = { 5, 4, 3, str = "string" , 2, 1}
  2. local q = luaq.asQuery(t)
  3.     :select(
  4.         function(pair, i)
  5.             if math.fmod(i, 2) == 1 then return pair.key
  6.             else return pair.value
  7.             end
  8.         end
  9.     )
  10. local r = q:query()
  11.  
  12. for key, value in pairs(t) do
  13.     print("key = "..key.."\tvalue = "..value)
  14. end
  15.  
  16. print()
  17. print("查询结果：")
  18. for i, v in ipairs(r) do
  19.     print(v)
  20. end
  • 结果：
key = 1         value = 5
key = 2         value = 4
key = 3         value = 3
key = 4         value = 2
key = 5         value = 1
key = str       value = string

查询结果：
1
4
3
2
5
string

luaq.where

luaq.where(query, func)

对旧查询对象的每一个项进行指定的筛选，并将符合条件的结果形成新的查询对象。

参数：
  • query：一个查询对象，其每一个项将要被筛选。
  • func：对query的每一个项进行检测的筛选函数。检测函数应返回true或false，且将会接受到两个参数值：
    • 第1个参数值：query的当前项。
    • 第2个参数值：从开始到当前的索引。
返回：
一个查询对象。它由筛选后的项组成。
错误：
  1. bad argument #2 to 'where' (table expected, got ...)：当参数func的值不是一个函数的时候抛出此错误。
示例：

本示例在luaq.select函数的示例1的基础上进行筛选。luaq.where函数的筛选机制为“项的值是字符串类型”或“项的值不小于3”。

  • 代码：
  1. local t = { 5, 4, 3, str = "string" , 2, 1}
  2. local q = luaq.asQuery(t)
  3.     :select(
  4.         function(pair)
  5.             return type(pair.value)
  6.         end
  7.     )
  8.     :where(
  9.         function(e)
  10.             return type(e) == "string" or e >= 3
  11.         end
  12.     )
  13. local r = q:query()
  14.  
  15. for key, value in pairs(t) do
  16.     print("key = "..key.."\tvalue = "..value)
  17. end
  18.  
  19. print()
  20. print("查询结果：")
  21. for i, v in ipairs(r) do
  22.     print(v)
  23. end
  • 结果：
key = 1         value = 5
key = 2         value = 4
key = 3         value = 3
key = 4         value = 2
key = 5         value = 1
key = str       value = string

查询结果：
4
3
5
string

luaq.count

luaq.count(query)

获取查询结果中项的数量。

这个函数将立即展开查询对象。
参数：
  • query：一个查询对象。
返回：
查询结果中项的数量。
示例：

本示例同时演示了LUAQ的延迟查询。表中含有6对值键对，因此第一次luaq.count查询的结果为6。

删去表中的第二个元素后，已通过调用luaq.query展开查询的变量r，其循环遍历输出的内容不变，但第二次luaq.count查询的结果变为5。

  • 代码：
  1. local t = { 5, 4, 3, str = "string" , 2, 1}
  2. local q = luaq.asQuery(t)
  3. local r = q:query()
  4. for i, pair in ipairs(r) do
  5. 	print(pair.key.."\t"..pair.value)
  6. end
  7. print("count() = "..q:count())
  8.  
  9. print()
  10. table.remove(t, 2) --删去表中的第二个元素
  11. for i, pair in ipairs(r) do
  12. 	print(pair.key.."\t"..pair.value)
  13. end
  14. print("count() = "..q:count())
  • 结果：
1       5
2       4
3       3
4       2
5       1
str     string
count() = 6

1       5
2       4
3       3
4       2
5       1
str     string
count() = 5

luaq.any

luaq.all

luaq.distinct

luaq.groupBy

开发

本章节将会介绍LUAQ的实现细节、开发相关的文档说明等。

查询对象保留字段

查询对象本质是一个Lua表。为了判断一个Lua表是否为查询对象，同时为了实现LUAQ核心功能，该Lua表必须设置元表（metatable）并且遵守以下约束：

  • __enum：（必须）一个函数，返回查询对象的枚举器。
  • __reset：（可选）一个函数，用于重置查询对象的状态。
  • __index：（可选）一个函数，用于按数字索引获取对应的查询结果的项目。
  • __ipairs：（可选）一个函数，用于重写_G.ipairs函数逻辑。
  • __pairs：（可选）一个函数，用于重写_G.pairs函数逻辑。

除此之外，各个LUAQ查询函数生成的查询对象的元表也有各自的保留字段，请在开发中避免占用。

各查询函数的保留字段将分别说明。

枚举器

对每一个查询对象调用__getenumerator函数即可获得其枚举器。

枚举器是支持LUAQ延迟查询的基石，通过改变其内部的状态可以实现向前、向后查询等操作。

可以通过以下两种方式获取枚举器的对象：

  • 函数：

<查询对象>.__getenumerator(<查询对象>)

  • 语法糖：

<查询对象>:__getenumerator()

枚举器字段

枚举器是一个Lua表，为了正常工作，它必须具有以下字段：

  • current：这个字段的类型为函数，用以获取当前查询的项。
    调用：
    • 函数：<枚举器对象>.current(self, query)
    • 语法糖：<枚举器对象>:current(query)
    参数：
    self：即<枚举器对象>本身，用以支持语法糖调用。
    query：包含<枚举器对象>的查询对象。
    返回：
    当前查询的项。
  • moveLast：这个字段的类型为返回值为true或false函数，用以将枚举器内部的状态向后回退一次。
    调用：
    • 函数：<枚举器对象>.moveLast(self, query)
    • 语法糖：<枚举器对象>:moveLast(query)
    参数：
    self：即<枚举器对象>本身，用以支持语法糖调用。
    query：包含<枚举器对象>的查询对象。
    返回：
    一个值，指示回退操作是否成功。
  • moveNext：这个字段的类型为返回值为true或false函数，用以将枚举器内部的状态向前前进一次。
    调用：
    • 函数：<枚举器对象>.moveNext(self, query)
    • 语法糖：<枚举器对象>:moveNext(query)
    参数：
    self：即<枚举器对象>本身，用以支持语法糖调用。
    query：包含<枚举器对象>的查询对象。
    返回：
    一个值，指示前进操作是否成功。
  • saveState：这个字段的类型为函数，用以获取枚举器内部的当前状态。
    调用：
    • 函数：<枚举器对象>.saveState(self, query)
    • 语法糖：<枚举器对象>:saveState(query)
    参数：
    self：即<枚举器对象>本身，用以支持语法糖调用。
    query：包含<枚举器对象>的查询对象。
    返回：
    枚举器内部的当前状态。
  • resetState：这个字段的类型为函数，用以设置枚举器内部的当前状态。
    调用：
    • 函数：<枚举器对象>.resetState(self, query, state)
    • 语法糖：<枚举器对象>:resetState(query, state)
    参数：
    self：即<枚举器对象>本身，用以支持语法糖调用。
    query：包含<枚举器对象>的查询对象。
    state：要设置的枚举器内部的状态。

枚举器工作原理

  1. 获取查询对象query。
  2. 通过query:__getenumerator()获取枚举器enumerator。除非特殊设计，一般的枚举器的初始状态为起点。
  3. 调用enumerator:moveNext(query)将枚举器内部状态前进一次，若返回值为true，则继续下一步。
  4. 调用enumerator:current(query)获取当前的项current。
  5. 对current进行后续处理。
示例：
  1. local query = luaq.asQuery({ 5, 4, 3, 2, 1 })
  2. local enumerator = query:__getenumerator()
  3. while enumerator:moveNext(query) do
  4.     local current = enumerator:current(query)
  5.     print(current.key.."\t"..current.value)
  6. end
结果：
1       5
2       4
3       3
4       2
5       1

查询函数实现细节

实现细节：linq.query

  1. _G.luaq = {
  2.     util = {}
  3. }
  4.  
  5. function luaq.util.errBadArgType(funcName, paramIndex, expectedType, arg)
  6.     error(mw.ustring.format("函数“%s”的第%d个参数类型错误（应为%s，实为%s）。", funcName, paramIndex, expectedType, type(arg)))
  7. end
  8.  
  9. function luaq.util.errBadArgValue(funcName, paramIndex, expectedValue, arg, message, ...)
  10.     local gotValue = type(arg)
  11.     if gotValue == "number" or gotValue == "string" or gotValue == "boolean" then gotValue = mw.dumpObject(arg) end
  12.     if type(message) == "string" then
  13.         message = mw.ustring.format(message,expectedValue, arg, ...)
  14.     else
  15.         message = mw.ustring.format("（应为%s，实为%s）", expectedValue, mw.dumpObject(arg))
  16.     end
  17.     error(mw.ustring.format("函数“%s”的第%d个参数的值错误%s。", funcName, paramIndex, message))
  18. end
  19.  
  20. function luaq.util.equal(l, r)
  21.     -- 对键的每一个项目进行相等比较。
  22.     local maxIndex = math.max(select("#", unpack(l)), select("#", unpack(r)))
  23.     for _index = 1, maxIndex do
  24.         if l[_index] ~= r[_index] then
  25.             return false
  26.         end
  27.     end
  28.     return true
  29. end
  30.  
  31. function luaq.util.compare(l, r)
  32.     -- 对键的每一个项目进行大小比较。
  33.     local maxIndex = math.max(select("#", unpack(l)), select("#", unpack(r)))
  34.     -- 越靠前的项目遇到不相等时，则两个键的大小关系等于这两个项目的大小关系。
  35.     for _index = 1, maxIndex do
  36.         local le, re = l[_index], r[_index]
  37.         if le < re then return -1
  38.         elseif le > re then return 1
  39.         end
  40.     end
  41.     return 0 -- 所有项目均相等，则两个键相等。
  42. end
  43.  
  44. local function isQuery(t)
  45.     if type(t) ~= "table" then return false end
  46.  
  47.     local mt = getmetatable(t)
  48.     return type(mt) == "table" and type(mt.__enum) == "function" and (mt.__reset == nil or type(mt.__reset) == "function")
  49. end
  50.  
  51. -- 查询对象的默认索引元函数。（必须提供缓存元函数的实现。）
  52. local function __index(query, k)
  53.     if type(k) == "number" and k > 0 then
  54.         local self = getmetatable(query)
  55.         self:__cachetill(k) -- 计算查询结果到索引k的项并缓存。
  56.  
  57.         return self.__cache[k]
  58.     end
  59. end
  60.  
  61. -- 查询对象的默认枚举元函数。（必须提供索引元函数的实现。）
  62. local function __enum(query, index)
  63.     index = index + 1
  64.     local current = query[index]
  65.     if current then
  66.         return index, current
  67.     end
  68. end
  69.  
  70. -- 查询对象的默认有序迭代元函数。
  71. local function __ipairs(query)
  72.     return getmetatable(query).__enum, query, 0
  73. end
  74.  
  75. -- 查询对象的默认无序迭代元函数。
  76. local __pairs = __ipairs
  77.  
  78. local function enext(query, index)
  79.     local index, current = getmetatable(query).__enum(query, index)
  80.     if current then
  81.         return index, unpack(current)
  82.     end
  83. end
  84. function _G.enum(query)
  85.     if not isQuery(query) then luaq.util.errBadArgValue("enum", 1, "查询对象", t, "（不是%s）。") end
  86.  
  87.     return enext, query, 0
  88. end
  89.  
  90. function _G.resetstate(query)
  91.     if not isQuery(query) then luaq.util.errBadArgValue("enum", 1, "查询对象", t, "（不是%s）。") end
  92.  
  93.     local __reset = getmetatable(query).__reset -- 获取重置元函数。
  94.     if __reset then
  95.         __reset(query) -- 调用重置元函数。
  96.     end
  97. end
  98.  
  99. -- 将一个Lua表的所有值键对包装成查询对象。
  100. function luaq.asQuery(t)
  101.     if type(t) ~= "table" then luaq.util.errBadArgType("asQuery", 1, "table", t) end
  102.  
  103.     if isQuery(t) then return t end -- 已经是查询对象了，不再重复操作。
  104.  
  105.     local rtenum, rt, rtstate -- 内部表的枚举函数、固定值、以及初始状态。
  106.     local mt = {
  107.         __cache = {},
  108.         __cachedone = false
  109.     }
  110.     mt.__index = __index
  111.     mt.__cachetill = function(self, index)
  112.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  113.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  114.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  115.  
  116.         local c = self.__cache -- 获取缓存数组。
  117.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  118.  
  119.         if rtenum == nil then
  120.             rtenum, rt, rtstate = _G.pairs(t) -- 获取内部表的枚举函数、固定值、以及初始状态。
  121.         end
  122.         if type(rtenum) ~= "function" then luaq.util.errBadArgValue("asQuery", 1, nil, nil, "（全局pairs函数返回意外的值，找不到迭代函数）") end
  123.  
  124.         local state = c[#c] -- 当前起始状态为缓存数组的最末项。
  125.         if state then
  126.             state = state[1] -- 取键为起始状态。
  127.         else
  128.             state = rtstate -- 使用内部表提供的初始值为起始状态。
  129.         end
  130.         local k, v = state, nil -- （优化）
  131.         while index > #c do
  132.             k, v = rtenum(rt, k)
  133.             if k == nil then break end
  134.  
  135.             table.insert(c, { k, v }) -- 向缓存数组中插入新项。
  136.         end
  137.  
  138.         if k == nil then self.__cachedone = true end -- 仅当没有下一个键时设置缓存完毕标识符。
  139.     end
  140.     mt.__enum = __enum
  141.     mt.__reset = function(q)
  142.         local self = getmetatable(q)
  143.         self.__cache = {}
  144.         self.__cachedone = false
  145.  
  146.         rtenum, rt, rtstate = nil, nil, nil
  147.     end
  148.     mt.__ipairs = __ipairs
  149.     mt.__pairs = __pairs
  150.  
  151.     local qResult = {}
  152.     luaq.util.attachLuaq(qResult, mt)
  153.  
  154.     return qResult
  155. end
  156.  
  157. -- 将一个Lua表的第一个不包含nil的序列包装成查询对象。
  158. function luaq.iasQuery(t)
  159.     if type(t) ~= "table" then luaq.util.errBadArgType("iasQuery", 1, "table", t) end
  160.  
  161.     if isQuery(t) then return t end -- 已经是查询对象了，不再重复操作。
  162.  
  163.     local rtenum, rt, rtstate -- 内部表的枚举函数、固定值、以及初始状态。
  164.     local mt = {
  165.         __cache = {
  166.             states = {} -- 保存状态的数组。
  167.         },
  168.         __cachedone = false
  169.     }
  170.     mt.__index = __index
  171.     mt.__cachetill = function(self, index)
  172.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  173.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  174.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  175.  
  176.         local c = self.__cache -- 获取缓存数组。
  177.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  178.  
  179.         if rtenum == nil then
  180.             rtenum, rt, rtstate = _G.ipairs(t) -- 获取内部表的枚举函数、固定值、以及初始状态。
  181.         end
  182.         if type(rtenum) ~= "function" then luaq.util.errBadArgValue("iasQuery", 1, nil, nil, "（全局ipairs函数返回意外的值，找不到迭代函数）") end
  183.  
  184.         local state, v
  185.         if #c.states > 0 then
  186.             state = c.states[#c.states] -- 当前起始状态为状态数组的最末项索引（或数组长度）。
  187.         else
  188.             state = rtstate -- 使用内部表提供的初始值为起始状态。
  189.         end
  190.         while index > #c do
  191.             state, v = rtenum(rt, state)
  192.             if v == nil then break end
  193.  
  194.             table.insert(c, { v }) -- 向缓存数组中插入新项。
  195.             table.insert(c.states, state) -- 向状态数组中插入新项。
  196.         end
  197.  
  198.         if v == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  199.     end
  200.     mt.__enum = __enum
  201.     mt.__reset = function(q)
  202.         local self = getmetatable(q)
  203.         self.__cache = {
  204.             states = {}
  205.         }
  206.         self.__cachedone = false
  207.  
  208.         rtenum, rt, rtstate = nil, nil, nil
  209.     end
  210.     mt.__ipairs = __ipairs
  211.     mt.__pairs = __pairs
  212.  
  213.     local qResult = {}
  214.     luaq.util.attachLuaq(qResult, mt)
  215.  
  216.     return qResult
  217. end
  218.  
  219. -- 将可变参数序列包装成查询对象。
  220. function luaq.asQueryFrom(...)
  221.     local rt = { ... }
  222.     local count = select("#", unpack(rt)) -- 获取可变参数序列的长度。
  223.  
  224.     local mt = {
  225.         __cache = {},
  226.         __cachedone = false
  227.     }
  228.     mt.__index = __index
  229.     mt.__cachetill = function(self, index)
  230.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  231.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  232.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  233.  
  234.         local c = self.__cache -- 获取缓存数组。
  235.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  236.  
  237.         local state = #c -- 当前起始状态为缓存数组的最末项索引（或数组长度）。
  238.         while index <= count and index > state do
  239.             local v = rt[state + 1]
  240.             table.insert(c, { v }) -- 向缓存数组中插入新项。
  241.             state = state + 1
  242.         end
  243.  
  244.         if state == count then self.__cachedone = true end -- 仅当缓存数组长度与可变参数序列长度一致时设置缓存完毕标识符。
  245.     end
  246.     mt.__enum = __enum
  247.     mt.__reset = nil -- 常量可变参数序列不再变化，无重置必要。
  248.     mt.__ipairs = __ipairs
  249.     mt.__pairs = __pairs
  250.  
  251.     local qResult = {}
  252.     luaq.util.attachLuaq(qResult, mt)
  253.  
  254.     return qResult
  255. end
  256.  
  257. function luaq.select(query, func)
  258.     if type(query) == "table" then
  259.         if not isQuery(query) then
  260.             query = luaq.iasQuery(query)
  261.         end
  262.     else
  263.         luaq.util.errBadArgValue("select", 1, "查询对象", query, "（不是%s）。")
  264.     end
  265.     if type(func) ~= "function" then luaq.util.errBadArgType("select", 2, "function", func) end
  266.  
  267.     local iqenum, iq -- 内部查询对象的枚举元函数以及固定值。
  268.     local mt = {
  269.         __cache = {},
  270.         __cachedone = false
  271.     }
  272.     mt.__index = __index
  273.     mt.__cachetill = function(self, index)
  274.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  275.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  276.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  277.  
  278.         local c = self.__cache -- 获取缓存数组。
  279.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  280.  
  281.         if iqenum == nil then
  282.             iqenum, iq = getmetatable(query).__enum, query -- 获取内部查询对象的枚举元函数以及固定值。
  283.         end
  284.  
  285.         local state, next = #c, nil -- 当前起始状态为缓存数组的最末项索引（或数组长度）。
  286.         while index > #c do
  287.             state, next = iqenum(iq, state)
  288.             if next == nil then break end
  289.  
  290.             next = { func(state, unpack(next)) } -- 调用选择函数。
  291.             table.insert(c, next) -- 向缓存数组中插入新项。
  292.         end
  293.  
  294.         if next == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  295.     end
  296.     mt.__enum = __enum
  297.     mt.__reset = function(q)
  298.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  299.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  300.  
  301.         local self = getmetatable(q)
  302.         self.__cache = {}
  303.         self.__cachedone = false
  304.  
  305.         iqenum, iq = nil, nil
  306.     end
  307.     mt.__ipairs = __ipairs
  308.     mt.__pairs = __pairs
  309.  
  310.     local qResult = {}
  311.     luaq.util.attachLuaq(qResult, mt)
  312.  
  313.     return qResult
  314. end
  315.  
  316. function luaq.selectMany(query, func)
  317.     if type(query) == "table" then
  318.         if not isQuery(query) then
  319.             query = luaq.iasQuery(query)
  320.         end
  321.     else
  322.         luaq.util.errBadArgValue("selectMany", 1, "查询对象", t, "（不是%s）。")
  323.     end
  324.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("selectMany", 2, "nil或function", func) end
  325.  
  326.     local iqenum, iq, iqstate -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  327.     local tqenum, tq, tqstate -- 临时查询对象的枚举元函数、固定值以及迭代器的起始状态。
  328.     local mt = {
  329.         __cache = {},
  330.         __cachedone = false
  331.     }
  332.     mt.__index = __index
  333.     mt.__cachetill = function(self, index)
  334.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  335.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  336.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  337.  
  338.         local c = self.__cache -- 获取缓存数组。
  339.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  340.  
  341.         if iqenum == nil then
  342.             iqenum, iq, iqstate = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  343.             iqstate, tq = iqenum(iq, iqstate)
  344.         end
  345.  
  346.         local next
  347.         while index > #c do
  348.             if tq == nil then break end
  349.  
  350.             if tqenum == nil then
  351.                 if func == nil then
  352.                     tq = unpack(tq) -- 拆包，获取元组第一个项目，进行下一步处理。
  353.                 else
  354.                     tq = { func(iqstate, unpack(tq)) }
  355.                 end
  356.                 if type(tq) == "table" then
  357.                     if not isQuery(tq) then
  358.                         tq = luaq.iasQuery(tq)
  359.                     end
  360.                 else
  361.                     error(mw.ustring.format("处理序列中的第%d项时发生错误（不是查询对象）。", iqstate))
  362.                 end
  363.                 tqenum, tqstate = getmetatable(tq).__enum, 0 -- 获取临时查询对象的枚举元函数以及迭代器的起始状态。
  364.             end
  365.             tqstate, next = tqenum(tq, tqstate)
  366.  
  367.             if next == nil then
  368.                 iqstate, tq = iqenum(iq, iqstate) -- 获取内部查询对象的枚举元函数以及迭代器的起始状态。
  369.                 tqenum, tqstate = nil, nil
  370.             else
  371.                 table.insert(c, next) -- 向缓存数组中插入新项。
  372.             end
  373.         end
  374.  
  375.         if tq == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  376.     end
  377.     mt.__enum = __enum
  378.     mt.__reset = function(q)
  379.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  380.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  381.  
  382.         local self = getmetatable(q)
  383.         self.__cache = {}
  384.         self.__cachedone = false
  385.  
  386.         iqenum, iq, iqstate = nil, nil, nil
  387.         tqenum, tq, tqstate = nil, nil, nil
  388.     end
  389.     mt.__ipairs = __ipairs
  390.     mt.__pairs = __pairs
  391.  
  392.     local qResult = {}
  393.     luaq.util.attachLuaq(qResult, mt)
  394.  
  395.     return qResult
  396. end
  397.  
  398. function luaq.selectYield(query, func)
  399.     if type(query) == "table" then
  400.         if not isQuery(query) then
  401.             query = luaq.iasQuery(query)
  402.         end
  403.     else
  404.         luaq.util.errBadArgValue("select", 1, "查询对象", query, "（不是%s）。")
  405.     end
  406.     if type(func) ~= "function" then luaq.util.errBadArgType("select", 2, "function", func) end
  407.  
  408.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  409.     local mt = {
  410.         __cache = {},
  411.         __cachedone = false
  412.     }
  413.     local yield = function(...) table.insert(mt.__cache, { ... }) end -- 迭代器产出函数。
  414.     mt.__index = __index
  415.     mt.__cachetill = function(self, index)
  416.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  417.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  418.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  419.  
  420.         local c = self.__cache -- 获取缓存数组。
  421.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  422.  
  423.         if iqenum == nil then
  424.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  425.         end
  426.  
  427.         local next
  428.         while index > #c do
  429.             state, next = iqenum(iq, state)
  430.             if next == nil then break end
  431.  
  432.             func(yield, state, unpack(next)) -- 调用迭代函数。
  433.         end
  434.  
  435.         if next == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  436.     end
  437.     mt.__enum = __enum
  438.     mt.__reset = function(q)
  439.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  440.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  441.  
  442.         local self = getmetatable(q)
  443.         self.__cache = {}
  444.         self.__cachedone = false
  445.  
  446.         iqenum, iq, state = nil, nil, nil
  447.     end
  448.     mt.__ipairs = __ipairs
  449.     mt.__pairs = __pairs
  450.  
  451.     local qResult = {}
  452.     luaq.util.attachLuaq(qResult, mt)
  453.  
  454.     return qResult
  455. end
  456.  
  457. function luaq.where(query, func)
  458.     if type(query) == "table" then
  459.         if not isQuery(query) then
  460.             query = luaq.iasQuery(query)
  461.         end
  462.     else
  463.         luaq.util.errBadArgValue("where", 1, "查询对象", query, "（不是%s）。")
  464.     end
  465.     if type(func) ~= "function" then luaq.util.errBadArgType("where", 2, "function", func) end
  466.  
  467.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  468.     local mt = {
  469.         __cache = {},
  470.         __cachedone = false
  471.     }
  472.     mt.__index = __index
  473.     mt.__cachetill = function(self, index)
  474.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  475.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  476.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  477.  
  478.         local c = self.__cache -- 获取缓存数组。
  479.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  480.  
  481.         if iqenum == nil then
  482.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  483.         end
  484.  
  485.         local next = nil
  486.         while index > #c do
  487.             state, next = iqenum(iq, state)
  488.             if next == nil then break end
  489.  
  490.             if func(state, unpack(next)) then -- 调用筛选函数。
  491.                 table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  492.             end
  493.         end
  494.  
  495.         if next == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  496.     end
  497.     mt.__enum = __enum
  498.     mt.__reset = function(q)
  499.         local __reset = getmetatable(query).__reset
  500.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  501.  
  502.         local self = getmetatable(q)
  503.         self.__cache = {}
  504.         self.__cachedone = false
  505.  
  506.         iqenum, iq, state = nil, nil, nil
  507.     end
  508.     mt.__ipairs =__ipairs
  509.     mt.__pairs = __pairs
  510.  
  511.     local qResult = {}
  512.     luaq.util.attachLuaq(qResult, mt)
  513.  
  514.     return qResult
  515. end
  516.  
  517. -- 创建一个空的查询对象。
  518. function luaq.empty()
  519.     local mt = {}
  520.     mt.__enum = function(q, index) return nil end
  521.     mt.__reset = nil
  522.     mt.__ipairs = __ipairs
  523.     mt.__pairs = __pairs
  524.  
  525.     local qResult = {}
  526.     luaq.util.attachLuaq(qResult, mt)
  527.  
  528.     return qResult
  529. end
  530.  
  531. -- 获取一个查询对象的结果的项个数。
  532. function luaq.count(query)
  533.     if type(query) == "table" then
  534.         if not isQuery(query) then
  535.             query = luaq.iasQuery(query)
  536.         end
  537.     else
  538.         luaq.util.errBadArgValue("count", 1, "查询对象", t, "（不是%s）。")
  539.     end
  540.  
  541.     local count = 0
  542.     for _ in enum(query) do
  543.         count = count + 1
  544.     end
  545.  
  546.     return count
  547. end
  548.  
  549. function luaq.any(query, func)
  550.     if type(query) == "table" then
  551.         if not isQuery(query) then
  552.             query = luaq.iasQuery(query)
  553.         end
  554.     else
  555.         luaq.util.errBadArgValue("any", 1, "查询对象", t, "（不是%s）。")
  556.     end
  557.  
  558.     local qenum = getmetatable(query).__enum -- 获取枚举元函数。
  559.     if type(func) == "nil" then
  560.         local _, v = qenum(query, 0)
  561.         return v ~= nil
  562.     elseif type(func) ~= "function" then
  563.         luaq.util.errBadArgType("any", 2, "function", func)
  564.     end
  565.  
  566.     local i, v = qenum(query, 0)
  567.     while v ~= nil do
  568.         if func(unpack(v)) then return true end
  569.         i, v = qenum(query, i)
  570.     end
  571.     return false
  572. end
  573.  
  574. function luaq.all(query, func)
  575.     if type(query) == "table" then
  576.         if not isQuery(query) then
  577.             query = luaq.iasQuery(query)
  578.         end
  579.     else
  580.         luaq.util.errBadArgValue("all", 1, "查询对象", t, "（不是%s）。")
  581.     end
  582.     if type(func) ~= "function" then
  583.         luaq.util.errBadArgType("all", 2, "function", func)
  584.     end
  585.  
  586.     local qenum = getmetatable(query).__enum -- 获取枚举元函数。
  587.     local i, v = qenum(query, 0)
  588.     while v ~= nil do
  589.         if not func(unpack(v)) then return false end
  590.         i, v = qenum(query, i)
  591.     end
  592.     return true
  593. end
  594.  
  595. function luaq.groupBy(query, keySelectFunc, entrySelectFunc, keyEqualityFunc)
  596.     if type(query) == "table" then
  597.         if not isQuery(query) then
  598.             query = luaq.iasQuery(query)
  599.         end
  600.     else
  601.         luaq.util.errBadArgValue("groupBy", 1, "查询对象", query, "（不是%s）。")
  602.     end
  603.     if type(keySelectFunc) ~= "function" then luaq.util.errBadArgType("groupBy", 2, "function", keySelectFunc) end
  604.     if entrySelectFunc ~= nil and type(entrySelectFunc) ~= "function" then
  605.         luaq.util.errBadArgType("groupBy", 3, "nil或function", entrySelectFunc)
  606.     end
  607.     if keyEqualityFunc ~= nil and type(keyEqualityFunc) ~= "function" then
  608.         luaq.util.errBadArgType("groupBy", 4, "nil或function", keyEqualityFunc)
  609.     end
  610.  
  611.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  612.     local mapcache = { -- 缓存所有项到键数组索引的映射。
  613.         keys = {}, -- 储存所有键的数组。
  614.         cachedone = false,
  615.         cachenext = function(self)
  616.             if self.cachedone then return end -- 如果已缓存完毕则退出。
  617.  
  618.             if iqenum == nil then
  619.                 iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  620.             end
  621.  
  622.             local next = nil
  623.             state, next = iqenum(iq, state)
  624.             if next == nil then
  625.                 self.cachedone = true -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  626.                 return
  627.             end
  628.  
  629.             local knext = { keySelectFunc(state, unpack(next)) } -- 调用键选择函数。
  630.  
  631.             -- 遍历键数组中所有已有键，与新键进行相等比较判断是否相等。
  632.             local hasKey = false
  633.             for _keyindex, _key in ipairs(self.keys) do
  634.                 local keyTest -- 键相等检查
  635.                 if keyEqualityFunc == nil then
  636.                     keyTest = luaq.util.equal(_key, knext)
  637.                 else
  638.                     keyTest = keyEqualityFunc(_key, knext)
  639.                 end
  640.                 if keyTest then -- 找到已有的相同的键，则将当前项归组至这个键。
  641.                     hasKey = true
  642.                     table.insert(self, { _keyindex, next }) -- 缓存数组中保存指向键数组的索引+项。
  643.                     break
  644.                 end
  645.             end
  646.             if not hasKey then -- 未找到已有的相同的键，则创建新键以归组当前项。
  647.                 table.insert(self.keys, knext) -- 向键数组插入一个不同的键。
  648.                 table.insert(self, { #self.keys, next }) -- 向缓存数组插入指向键数组末尾的索引+项。
  649.             end
  650.         end,
  651.         reset = function(self)
  652.             local __reset = getmetatable(query).__reset -- 获取重置元函数。
  653.             if __reset then __reset(query) end -- 首先重置内部查询对象。
  654.  
  655.             self.keys = {} -- 重置键数组
  656.             self.cachedone = false -- 重置缓存完毕标识符。
  657.             local length = #self
  658.             for i = 1, length do self[i] = nil end -- 清空映射缓存。
  659.  
  660.             iqenum, iq, state = nil, nil, nil
  661.         end
  662.     }
  663.  
  664.     local gmt = {
  665.         __cache = {},
  666.         __cachedone = false
  667.     }
  668.     gmt.__index = __index
  669.     gmt.__cachetill = function(gself, gindex)
  670.         if gself.__cachedone then return end -- 如果已缓存完毕则退出。
  671.         if type(gindex) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", gindex) end
  672.         if gindex <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", gindex) end
  673.  
  674.         local gc = gself.__cache -- 获取缓存数组。
  675.         if gindex <= #gc then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  676.  
  677.         while gindex > #gc do
  678.             local nextKeyIndex = #gc + 1 -- 获取下一个键的索引。
  679.             local nextKey = mapcache.keys[nextKeyIndex] -- 获取下一个键。
  680.             while nextKey == nil and not mapcache.cachedone do -- 获取键时映射缓存未完成。
  681.                 -- 重复向后缓存一个项并检查是否得到下一个键。
  682.                 mapcache:cachenext()
  683.                 nextKey = mapcache.keys[nextKeyIndex]
  684.             end
  685.             if nextKey == nil then
  686.                 gself.__cachedone = true -- 映射缓存完毕时仍未找到下一个键，仅当此时设置缓存完毕标识符。
  687.                 break
  688.             end
  689.  
  690.             local nextEntryIndex = 1 -- 获取下一个项的索引。
  691.             local emt= {
  692.                 __cache = {},
  693.                 __cachedone = false
  694.             }
  695.             emt.__index = __index
  696.             emt.__cachetill = function(eself, eindex)
  697.                 if eself.__cachedone then return end -- 如果已缓存完毕则退出。
  698.                 if type(eindex) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", eindex) end
  699.                 if eindex <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", eindex) end
  700.  
  701.                 local ec = eself.__cache -- 获取缓存数组。
  702.                 if eindex <= #ec then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  703.  
  704.                 while eindex > #ec do
  705.                     local nextEntry = mapcache[nextEntryIndex] -- 获取下一个项。
  706.                     while (nextEntry == nil or nextEntry[1] ~= nextKeyIndex) do -- 获得的下个项不符合条件。
  707.                         -- 重复向后缓存一个项并检查是否得到下一个符合条件的项。
  708.                         if nextEntry == nil then -- 若当前索引位置未缓存，则缓存一个位置。
  709.                             if mapcache.cachedone then break end -- 映射缓存已完毕。
  710.                             mapcache:cachenext()
  711.                         else -- 若当前索引位置的项不符合条件，则尝试下一个索引位置。
  712.                             nextEntryIndex = nextEntryIndex + 1
  713.                         end
  714.                         nextEntry = mapcache[nextEntryIndex]
  715.                     end
  716.                     if nextEntry == nil then
  717.                         eself.__cachedone = true -- 映射缓存完毕时仍未找到下一个项，仅当此时设置缓存完毕标识符。
  718.                         break
  719.                     end
  720.  
  721.                     local newEntry
  722.                     if entrySelectFunc == nil then
  723.                         newEntry = { nextKey, unpack(nextEntry[2]) }
  724.                     else
  725.                         newEntry = { nextKey, entrySelectFunc(eindex, mapcache.keys[nextKeyIndex], unpack(nextEntry[2])) } -- 调用项选择函数。
  726.                     end
  727.                     table.insert(ec, newEntry) -- 向缓存数组中插入新项。
  728.  
  729.                     nextEntryIndex = nextEntryIndex + 1
  730.                 end
  731.             end
  732.             emt.__enum = __enum
  733.             emt.__reset = function(q)
  734.                 -- 项查询对象的重置将不改变分组结果，仅重新获取项选择函数的返回值。
  735.                 local self = getmetatable(q)
  736.                 self.__cache = {}
  737.                 self.__cachedone = false
  738.  
  739.                 nextEntryIndex = 1
  740.             end
  741.             emt.__ipairs = __ipairs
  742.             emt.__pairs = __pairs
  743.  
  744.             local eqResult = {}
  745.             luaq.util.attachLuaq(eqResult, emt)
  746.  
  747.             -- 将项查询对象添加入缓存。
  748.             table.insert(gc, { nextKey, eqResult })
  749.         end
  750.     end
  751.     gmt.__enum = __enum
  752.     gmt.__reset = function(q)
  753.         mapcache:reset() -- 首先重置映射缓存。
  754.  
  755.         local self = getmetatable(q)
  756.         self.__cache = {}
  757.         self.__cachedone = false
  758.     end
  759.     gmt.__ipairs = __ipairs
  760.     gmt.__pairs = __pairs
  761.  
  762.     local gqResult = {}
  763.     luaq.util.attachLuaq(gqResult, gmt)
  764.  
  765.     return gqResult
  766. end
  767.  
  768. local function isSort(sort) return type(sort) == "table" and type(sort.start) == "function" end
  769. local function isOrderedQuery(t)
  770.     return isQuery(t) and type(getmetatable(t).__group) == "function"
  771. end
  772. -- 获取默认排序器。
  773. local function getDefaultSort(stages)
  774.     return {
  775.         start = function(self, info, desc, ...)
  776.             -- 冒泡排序。
  777.             local count = info.length(...)
  778.             for i = 1, count do
  779.                 local swaped = false
  780.                 for j = 1, count - i do
  781.                     if (info.compare(j, j + 1, ...) < 0) == desc then
  782.                         swaped = info.swap(j, j + 1, ...) or swaped
  783.                     end
  784.                 end
  785.                 if not swaped then break end
  786.             end
  787.         end
  788.     }
  789. end
  790. function luaq.orderBy(query, func, comp, desc, sort)
  791.     if type(query) == "table" then
  792.         if not isQuery(query) then
  793.             query = luaq.iasQuery(query)
  794.         end
  795.     else
  796.         luaq.util.errBadArgValue("orderBy", 1, "查询对象", t, "（不是%s）。")
  797.     end
  798.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("orderBy", 2, "function", func) end
  799.     if comp ~= nil and type(comp) ~= "function" then luaq.util.errBadArgType("orderBy", 3, "nil或function", comp) end
  800.     if desc == nil then desc = false
  801.     elseif type(desc) ~= "boolean" then luaq.util.errBadArgType("orderBy", 4, "nil或boolean", desc) end
  802.     if sort == nil then sort = getDefaultSort()
  803.     elseif not isSort(sort) then luaq.util.errBadArgValue("orderBy", 5, "排序器", t, "（不是%s）。")
  804.     end
  805.  
  806.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  807.     local sortcache = {} -- 缓存排序内容等信息。
  808.     sortcache.cachedone = false -- 缓存完毕标识符。
  809.     sortcache.cacheall = function(self)
  810.         if self.cachedone then return end -- 如果已缓存完毕则退出。
  811.  
  812.         if iqenum == nil then
  813.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  814.         end
  815.  
  816.         local next = nil
  817.         while true do
  818.             state, next = iqenum(iq, state)
  819.             if next == nil then break end -- 仅当数组下一个项是nil时循环终止。
  820.  
  821.             local pair = {} -- 排序键值对。
  822.             if func == nil then
  823.                 pair = { next } -- 不做排序键选择，即将自身作为排序键。
  824.             else
  825.                 pair = { { func(state, unpack(next)) }, next } -- 调用排序键选择函数。
  826.             end
  827.             -- 遍历缓存中所有已有项组，与下一项进行相等比较判断是否相等。
  828.             local isEven = false
  829.             for _, _group in ipairs(self) do
  830.                 local current = _group[1][1] -- 从项组中获取当前要比较的项。
  831.                 local evenTest -- 项相等检查
  832.                 if comp == nil then
  833.                     evenTest = luaq.util.equal(current, pair[1])
  834.                 else
  835.                     evenTest = comp(current, pair[1]) == 0
  836.                 end
  837.                 if evenTest then -- 找到已有的相同的项组，则将当前项归组至这个组。
  838.                     isEven = true
  839.                     table.insert(_group, pair)
  840.                     break
  841.                 end
  842.             end
  843.             if not isEven then -- 未找到已有的相同的项组，则创建新组以归组当前项。
  844.                 table.insert(self, { pair })
  845.             end
  846.         end
  847.  
  848.         self.cachedone = true -- 设置缓存完毕标识符
  849.     end
  850.     sortcache.length = function() return #sortcache end
  851.     sortcache.entryat = function(index)
  852.         if type(index) ~= "number" then luaq.util.errBadArgType("entryat", 1, "number", index) end
  853.         if index <= 0 then luaq.util.errBadArgValue("entryat", 1, "正整数", index) end
  854.  
  855.         local group = sortcache[index] -- 获取等值组。
  856.         if group == nil then return nil
  857.         else return group[1][1] -- 等值组的首项的选择键。
  858.         end
  859.     end
  860.     sortcache.compare = function(index1, index2)
  861.         if type(index1) ~= "number" then luaq.util.errBadArgType("compare", 1, "number", index1) end
  862.         if index1 <= 0 then luaq.util.errBadArgValue("compare", 1, "正整数", index1) end
  863.         if type(index2) ~= "number" then luaq.util.errBadArgType("compare", 2, "number", index2) end
  864.         if index2 <= 0 then luaq.util.errBadArgValue("compare", 2, "正整数", index2) end
  865.  
  866.         local temp1, temp2 = sortcache[index1], sortcache[index2]
  867.         if temp1 == nil and temp2 == nil then return 0 -- 两个索引均超出范围。
  868.         elseif temp1 == nil then return -1 -- 第一个索引均超出范围。
  869.         elseif temp2 == nil then return 1 -- 第二个索引均超出范围。
  870.         else
  871.             temp1, temp2 = temp1[1][1], temp2[1][1] -- 等值组的首项的选择键。
  872.             if comp == nil then
  873.                 return luaq.util.compare(temp1, temp2)
  874.             else
  875.                 return comp(temp1, temp2)
  876.             end
  877.         end
  878.     end
  879.     sortcache.swap = function(index1, index2)
  880.         if type(index1) ~= "number" then luaq.util.errBadArgType("swap", 1, "number", index1) end
  881.         if index1 <= 0 then luaq.util.errBadArgValue("swap", 1, "正整数", index1) end
  882.         if type(index2) ~= "number" then luaq.util.errBadArgType("swap", 2, "number", index2) end
  883.         if index2 <= 0 then luaq.util.errBadArgValue("swap", 2, "正整数", index2) end
  884.  
  885.         local temp1, temp2 = sortcache[index1], sortcache[index2]
  886.         if temp1 == nil or temp2 == nil then return false end -- 其中任何一项索引超出范围则返回不成功。
  887.         sortcache[index1], sortcache[index2] = temp2, temp1
  888.         return true -- 交换操作成功。
  889.     end
  890.     sortcache.setall = function(indexes)
  891.         if type(indexes) ~= "table" then luaq.util.errBadArgType("setall", 1, "table", indexes) end
  892.  
  893.         local length = #sortcache
  894.         for i = 1, length do indexes[i] = sortcache[indexes[i]] end
  895.         for i = 1, length do sortcache[i] = indexes[i] end
  896.     end
  897.     sortcache.sortdone = false -- 排序完毕标识符。
  898.     sortcache.sort = function(self)
  899.         if self.sortdone then return end
  900.  
  901.         self:cacheall() -- 缓存所有项。
  902.         assert(self.cachedone, "排序缓存未缓存完毕，无法进行排序。") -- 设置断言捕捉潜在的逻辑错误。排序操作必须在缓存完毕的基础上进行，否则将会产生无法预料的后果。
  903.  
  904.         sort:start(self, desc) -- 调用排序器。
  905.         self.sortdone = true
  906.     end
  907.     sortcache.reset = function(self)
  908.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  909.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  910.  
  911.         self.cachedone = false -- 重置缓存完毕标识符。
  912.         self.sortdone = false -- 重置排序完毕标识符。
  913.         local length = #self
  914.         for i = 1, length do self[i] = nil end -- 清空排序缓存。
  915.  
  916.         iqenum, iq, state = nil, nil, 0
  917.     end
  918.  
  919.     local mt = {
  920.         __cache = {},
  921.         __cachedone = false
  922.     }
  923.     mt.__index = __index
  924.     mt.__cachetill = function(self, index)
  925.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  926.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  927.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  928.  
  929.         local c = self.__cache -- 获取缓存数组。
  930.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  931.  
  932.         sortcache:sort() -- 排序所有项。
  933.         assert(sortcache.sortdone, "排序缓存未排序完毕，无法进行结果缓存。") -- 设置断言捕捉潜在的逻辑错误。结果缓存操作必须在排序完毕的基础上进行，否则将会产生无法预料的后果。
  934.  
  935.         -- 缓存所有结果。
  936.         for _, group in ipairs(sortcache) do
  937.             for _, entry in ipairs(group) do
  938.                 table.insert(c, entry[2] or entry[1])
  939.             end
  940.         end
  941.         self.__cachedone = true -- 设置缓存完毕标识符。
  942.     end
  943.     mt.__group = function(q, index)
  944.         sortcache:sort() -- 排序所有项。
  945.         assert(sortcache.sortdone, "排序缓存未排序完毕，无法进行排序组枚举。") -- 设置断言捕捉潜在的逻辑错误。排序组枚举操作必须在排序完毕的基础上进行，否则将会产生无法预料的后果。
  946.  
  947.         index = index + 1
  948.         local current = sortcache[index]
  949.         if current then
  950.             local group = {}
  951.             for _, current in ipairs(current) do
  952.                 table.insert(group, current[2] or current[1])
  953.             end
  954.             assert(#group > 0, "空的等值组。") -- 不应出现空的等值组。
  955.             return index, group
  956.         end
  957.     end
  958.     mt.__enum = __enum
  959.     mt.__reset = function(q)
  960.         sortcache:reset() -- 首先重置排序缓存。
  961.  
  962.         local self = getmetatable(q)
  963.         self.__cache = {}
  964.         self.__cachedone = false
  965.     end
  966.     mt.__ipairs = __ipairs
  967.     mt.__pairs = __pairs
  968.  
  969.     local qResult = {}
  970.     luaq.util.attachLuaq(qResult, mt)
  971.  
  972.     return qResult
  973. end
  974.  
  975. function luaq.thenBy(query, func, comp, desc, sort)
  976.     if not isOrderedQuery(query) then
  977.         luaq.util.errBadArgValue("thenBy", 1, "有序查询对象", t, "（不是%s）。")
  978.     end
  979.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("thenBy", 2, "function", func) end
  980.     if comp ~= nil and type(comp) ~= "function" then luaq.util.errBadArgType("thenBy", 3, "nil或function", comp) end
  981.     if desc == nil then desc = false
  982.     elseif type(desc) ~= "boolean" then luaq.util.errBadArgType("thenBy", 4, "nil或boolean", desc) end
  983.     if sort == nil then sort = getDefaultSort()
  984.     elseif not isSort(sort) then luaq.util.errBadArgValue("thenBy", 5, "排序器", t, "（不是%s）。")
  985.     end
  986.  
  987.     local iqgroup, iq, state -- 内部查询对象的排序组元函数、固定值以及迭代器的起始状态。
  988.     local totalState = 0 -- 整体状态。
  989.     local sortcache = {} -- 缓存排序内容等信息。
  990.     sortcache.cachedone = false
  991.     sortcache.cachenext = function(self)
  992.         if self.cachedone then return false end -- 如果已缓存完毕则退出。
  993.  
  994.         if iqgroup == nil then
  995.             iqgroup, iq, state = getmetatable(query).__group, query, 0 -- 获取内部查询对象的排序组元函数、固定值以及迭代器的起始状态。
  996.         end
  997.  
  998.         local nextStage = nil
  999.         state, nextStage = iqgroup(iq, state)
  1000.         if nextStage == nil then
  1001.             self.cachedone = true -- 仅当排序组下一个项是nil时设置缓存完毕标识符。
  1002.             return false
  1003.         end
  1004.  
  1005.         local stage = {} -- 新建高阶排序阶。
  1006.         for _, next in ipairs(nextStage) do
  1007.             local pair = {} -- 排序键值对。
  1008.             if func == nil then
  1009.                 pair = { next } -- 不做排序键选择，即将自身作为排序键。
  1010.             else
  1011.                 pair = { { func(totalState + state, unpack(next)) }, next } -- 调用排序键选择函数。
  1012.             end
  1013.             -- 遍历新排序阶中所有已有项组，与下一项进行相等比较判断是否相等。
  1014.             local isEven = false
  1015.             for _, _group in ipairs(stage) do
  1016.                 local current = _group[1][1] -- 从项组中获取当前要比较的项。
  1017.                 local evenTest -- 项相等检查
  1018.                 if comp == nil then
  1019.                     evenTest = luaq.util.equal(current, pair[1])
  1020.                 else
  1021.                     evenTest = comp(current, pair[1]) == 0
  1022.                 end
  1023.                 if evenTest then -- 找到已有的相同的项组，则将当前项归组至这个组。
  1024.                     isEven = true
  1025.                     table.insert(_group, pair)
  1026.                     break
  1027.                 end
  1028.             end
  1029.             if not isEven then -- 未找到已有的相同的项组，则创建新组以归组当前项。
  1030.                 table.insert(stage, { pair })
  1031.             end
  1032.         end
  1033.         table.insert(self, stage) -- 向排序缓存中添加新排序阶。
  1034.  
  1035.         return true
  1036.     end
  1037.     sortcache.length = function(stage)
  1038.         if type(stage) == "number" then
  1039.             local s = sortcache[stage]
  1040.             if s == nil then return nil -- 索引超出范围。
  1041.             else return #s -- 返回当前排序阶的长度。
  1042.             end
  1043.         else -- 返回总长度。
  1044.             local len = 0
  1045.             for _, s in sortcache do
  1046.                 len = len + #s
  1047.             end
  1048.             return len
  1049.         end
  1050.     end
  1051.     sortcache.entryat = function(index, stage)
  1052.         if type(index) ~= "number" then luaq.util.errBadArgType("entryat", 1, "number", index) end
  1053.         if index <= 0 then luaq.util.errBadArgValue("entryat", 1, "正整数", index) end
  1054.         if type(stage) ~= "number" then luaq.util.errBadArgType("entryat", 2, "number", stage) end
  1055.         if stage <= 0 then luaq.util.errBadArgValue("entryat", 2, "正整数", stage) end
  1056.  
  1057.         stage = sortcache[stage] -- 获取排序阶。
  1058.         if stage == nil then return nil end -- 索引超出范围。
  1059.         local group = stage[index] -- 获取等值组。
  1060.         if group == nil then return nil
  1061.         else return group[1][1] -- 等值组的首项的选择键。
  1062.         end
  1063.     end
  1064.     sortcache.compare = function(index1, index2, stage)
  1065.         if type(index1) ~= "number" then luaq.util.errBadArgType("compare", 1, "number", index1) end
  1066.         if index1 <= 0 then luaq.util.errBadArgValue("compare", 1, "正整数", index1) end
  1067.         if type(index2) ~= "number" then luaq.util.errBadArgType("compare", 2, "number", index2) end
  1068.         if index2 <= 0 then luaq.util.errBadArgValue("compare", 2, "正整数", index2) end
  1069.         if type(stage) ~= "number" then luaq.util.errBadArgType("compare", 3, "number", stage) end
  1070.         if stage <= 0 then luaq.util.errBadArgValue("compare", 3, "正整数", stage) end
  1071.  
  1072.         stage = sortcache[stage] -- 获取排序阶。
  1073.         if stage == nil then return 0 end -- 索引超出范围。
  1074.         local temp1, temp2 = stage[index1], stage[index2]
  1075.         if temp1 == nil and temp2 == nil then return 0 -- 两个索引均超出范围。
  1076.         elseif temp1 == nil then return -1 -- 第一个索引均超出范围。
  1077.         elseif temp2 == nil then return 1 -- 第二个索引均超出范围。
  1078.         else
  1079.             temp1, temp2 = temp1[1][1], temp2[1][1] -- 等值组的首项的选择键。
  1080.             if comp == nil then
  1081.                 return luaq.util.compare(temp1, temp2)
  1082.             else
  1083.                 return comp(temp1, temp2)
  1084.             end
  1085.         end
  1086.     end
  1087.     sortcache.swap = function(index1, index2, stage)
  1088.         if type(index1) ~= "number" then luaq.util.errBadArgType("swap", 1, "number", index1) end
  1089.         if index1 <= 0 then luaq.util.errBadArgValue("swap", 1, "正整数", index1) end
  1090.         if type(index2) ~= "number" then luaq.util.errBadArgType("swap", 2, "number", index2) end
  1091.         if index2 <= 0 then luaq.util.errBadArgValue("swap", 2, "正整数", index2) end
  1092.         if type(stage) ~= "number" then luaq.util.errBadArgType("swap", 3, "number", stage) end
  1093.         if stage <= 0 then luaq.util.errBadArgValue("swap", 3, "正整数", stage) end
  1094.  
  1095.         stage = sortcache[stage] -- 获取排序阶。
  1096.         if stage == nil then return false end -- 索引超出范围。
  1097.         local temp1, temp2 = stage[index1], stage[index2]
  1098.         if temp1 == nil or temp2 == nil then return false end -- 其中任何一项索引超出范围则返回不成功。
  1099.         stage[index1], stage[index2] = temp2, temp1
  1100.         return true -- 交换操作成功。
  1101.     end
  1102.     sortcache.setall = function(indexes, stage)
  1103.         if type(indexes) ~= "table" then luaq.util.errBadArgType("setall", 1, "table", indexes) end
  1104.  
  1105.         stage = sortcache[stage] -- 获取排序阶。
  1106.         if stage == nil then return end -- 索引超出范围。
  1107.         local length = #stage
  1108.         for i = 1, length do indexes[i] = stage[indexes[i]] end
  1109.         for i = 1, length do stage[i] = indexes[i] end
  1110.     end
  1111.     sortcache.sortdone = false
  1112.     sortcache.sortnext = function(self)
  1113.         if self.sortdone then return false end
  1114.  
  1115.         local hasNext = self:cachenext() -- 缓存下一阶。
  1116.         if not hasNext then
  1117.             self.sortdone = true
  1118.             return false
  1119.         end
  1120.  
  1121.         local stage = #self -- 获取下一阶的索引。
  1122.         sort:start(self, desc, stage)
  1123.  
  1124.         return true
  1125.     end
  1126.     sortcache.reset = function(self)
  1127.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  1128.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1129.  
  1130.         self.cachedone = false -- 重置缓存完毕标识符。
  1131.         self.sortdone = false -- 重置排序完毕标识符。
  1132.         local length = #self
  1133.         for i = 1, length do self[i] = nil end -- 清空映射缓存。
  1134.  
  1135.         iqgroup, iq, state = nil, nil, 0
  1136.     end
  1137.  
  1138.     local mt = {
  1139.         __cache = {},
  1140.         __cachedone = false
  1141.     }
  1142.     mt.__index = __index
  1143.     mt.__cachetill = function(self, index)
  1144.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1145.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1146.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1147.  
  1148.         local c = self.__cache -- 获取缓存数组。
  1149.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1150.  
  1151.         while index > #c and not sortcache.sortdone do
  1152.             if not sortcache:sortnext() then break end -- 排序下一阶。
  1153.             local stage = sortcache[#sortcache] -- 获取下一阶。
  1154.  
  1155.             -- 缓存下一阶的所有结果。
  1156.             for _, group in ipairs(stage) do
  1157.                 for _, entry in ipairs(group) do
  1158.                     table.insert(c, entry[2] or entry[1])
  1159.                 end
  1160.             end
  1161.         end
  1162.         if sortcache.sortdone then self.__cachedone = true end -- 仅当排序缓存的所有阶均排序完毕时设置缓存完毕标识符。
  1163.     end
  1164.     mt.__group = function(q, index)
  1165.         index = index + 1
  1166.         local current = nil
  1167.  
  1168.         local offset, stage = 0, 1
  1169.         while true do
  1170.             local s = sortcache[stage]
  1171.             if s == nil then
  1172.                 -- 排序下一阶。
  1173.                 if not sortcache:sortnext() then break end
  1174.                 s = sortcache[stage]
  1175.                 if s == nil then break end
  1176.             end
  1177.  
  1178.             if index <= offset + #s then
  1179.                 current = s[index - offset]
  1180.                 break
  1181.             end
  1182.  
  1183.             offset = offset + #s
  1184.             stage = stage + 1
  1185.         end
  1186.  
  1187.         if current then
  1188.             local group = {}
  1189.             for _, current in ipairs(current) do
  1190.                 table.insert(group, current[2] or current[1])
  1191.             end
  1192.             assert(#group > 0, "空的等值组。") -- 不应出现空的等值组。
  1193.             return index, group
  1194.         end
  1195.     end
  1196.     mt.__enum = __enum
  1197.     mt.__reset = function(q)
  1198.         sortcache:reset() -- 首先重置排序缓存。
  1199.  
  1200.         local self = getmetatable(q)
  1201.         self.__cache = {}
  1202.         self.__cachedone = false
  1203.     end
  1204.     mt.__ipairs = __ipairs
  1205.     mt.__pairs = __pairs
  1206.  
  1207.     local qResult = {}
  1208.     luaq.util.attachLuaq(qResult, mt)
  1209.  
  1210.     return qResult
  1211. end
  1212.  
  1213. function luaq.distinct(query, func)
  1214.     if type(query) == "table" then
  1215.         if not isQuery(query) then
  1216.             query = luaq.iasQuery(query)
  1217.         end
  1218.     else
  1219.         luaq.util.errBadArgValue("distinct", 1, "查询对象", query, "（不是%s）。")
  1220.     end
  1221.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("distinct", 2, "nil或function", func) end
  1222.  
  1223.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1224.     local mt = {
  1225.         __cache = {},
  1226.         __cachedone = false
  1227.     }
  1228.     mt.__index = __index
  1229.     mt.__cachetill = function(self, index)
  1230.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1231.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1232.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1233.  
  1234.         local c = self.__cache -- 获取缓存数组。
  1235.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1236.  
  1237.         if iqenum == nil then
  1238.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1239.         end
  1240.  
  1241.         local next = nil
  1242.         while index > #c do
  1243.             state, next = iqenum(iq, state)
  1244.             if next == nil then break end
  1245.  
  1246.             local isEven
  1247.             for _, current in ipairs(c) do
  1248.                 if func then
  1249.                     local evenTest = func(current, next) -- 调用筛选函数。
  1250.                     isEven = evenTest == true or evenTest == 0
  1251.                 else
  1252.                     isEven = luaq.util.equal(current, next)
  1253.                 end
  1254.                 if isEven then break end
  1255.             end
  1256.             if not isEven then
  1257.                 table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  1258.             end
  1259.         end
  1260.  
  1261.         if next == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  1262.     end
  1263.     mt.__enum = __enum
  1264.     mt.__reset = function(q)
  1265.         local __reset = getmetatable(query).__reset
  1266.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1267.  
  1268.         local self = getmetatable(q)
  1269.         self.__cache = {}
  1270.         self.__cachedone = false
  1271.  
  1272.         iqenum, iq, state = nil, nil, nil
  1273.     end
  1274.     mt.__ipairs =__ipairs
  1275.     mt.__pairs = __pairs
  1276.  
  1277.     local qResult = {}
  1278.     luaq.util.attachLuaq(qResult, mt)
  1279.  
  1280.     return qResult
  1281. end
  1282.  
  1283. function luaq.concat(query, other)
  1284.     if type(query) == "table" then
  1285.         if not isQuery(query) then
  1286.             query = luaq.iasQuery(query)
  1287.         end
  1288.     else
  1289.         luaq.util.errBadArgValue("concat", 1, "查询对象", query, "（不是%s）。")
  1290.     end
  1291.     if type(other) == "table" then
  1292.         if not isQuery(other) then
  1293.             other = luaq.iasQuery(other)
  1294.         end
  1295.     else
  1296.         luaq.util.errBadArgValue("concat", 2, "查询对象", other, "（不是%s）。")
  1297.     end
  1298.  
  1299.     local iqenum1, iqenum2 -- 两个查询对象的枚举元函数。
  1300.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1301.     local mt = {
  1302.         __cache = {},
  1303.         __cachedone = false
  1304.     }
  1305.     mt.__index = __index
  1306.     mt.__cachetill = function(self, index)
  1307.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1308.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1309.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1310.  
  1311.         local c = self.__cache -- 获取缓存数组。
  1312.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1313.  
  1314.         iqenum1 = iqenum1 or getmetatable(query).__enum
  1315.         iqenum2 = iqenum2 or getmetatable(other).__enum
  1316.         if iqenum == nil then
  1317.             iqenum, iq, state = iqenum1, query, 0 -- 获取第一个内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1318.         end
  1319.  
  1320.         local next
  1321.         while index > #c do
  1322.             state, next = iqenum(iq, state)
  1323.             local continue = false
  1324.             if next == nil then
  1325.                 if iqenum == iqenum2 then break
  1326.                 else
  1327.                     iqenum, iq, state = iqenum2, other, 0 -- 获取第二个内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1328.                     continue = true
  1329.                 end
  1330.             end
  1331.  
  1332.             if not continue then
  1333.                 table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  1334.             end
  1335.         end
  1336.  
  1337.         if next == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  1338.     end
  1339.     mt.__enum = __enum
  1340.     mt.__reset = function(q)
  1341.         local __reset = getmetatable(query).__reset -- 获取第一个内部查询对象的重置元函数。
  1342.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1343.         __reset = getmetatable(other).__reset -- 获取第二个内部查询对象的重置元函数。
  1344.         if __reset then __reset(other) end -- 首先重置内部查询对象。
  1345.  
  1346.         local self = getmetatable(q)
  1347.         self.__cache = {}
  1348.         self.__cachedone = false
  1349.  
  1350.         iqenum, iq, state = nil, nil, nil
  1351.     end
  1352.     mt.__ipairs = __ipairs
  1353.     mt.__pairs = __pairs
  1354.  
  1355.     local qResult = {}
  1356.     luaq.util.attachLuaq(qResult, mt)
  1357.  
  1358.     return qResult
  1359. end
  1360.  
  1361. function luaq.append(query, ...)
  1362.     if type(query) == "table" then
  1363.         if not isQuery(query) then
  1364.             query = luaq.iasQuery(query)
  1365.         end
  1366.     else
  1367.         luaq.util.errBadArgValue("append", 1, "查询对象", query, "（不是%s）。")
  1368.     end
  1369.     if type(func) ~= "function" then luaq.util.errBadArgType("append", 2, "function", func) end
  1370.  
  1371.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1372.     local extra = { ... } -- 要追加的项。
  1373.     local mt = {
  1374.         __cache = {},
  1375.         __cachedone = false
  1376.     }
  1377.     mt.__index = __index
  1378.     mt.__cachetill = function(self, index)
  1379.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1380.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1381.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1382.  
  1383.         local c = self.__cache -- 获取缓存数组。
  1384.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1385.  
  1386.         if iqenum == nil then
  1387.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1388.         end
  1389.  
  1390.         local next
  1391.         while index > #c do
  1392.             state, next = iqenum(iq, state)
  1393.             if next == nil then break end
  1394.  
  1395.             table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  1396.         end
  1397.  
  1398.         if next == nil then -- 当数组下一个项是nil时。
  1399.             table.insert(c, extra) -- 向缓存数组中插入追加项。
  1400.             self.__cachedone = true -- 设置缓存完毕标识符
  1401.         end
  1402.     end
  1403.     mt.__enum = __enum
  1404.     mt.__reset = function(q)
  1405.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  1406.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1407.  
  1408.         local self = getmetatable(q)
  1409.         self.__cache = {}
  1410.         self.__cachedone = false
  1411.  
  1412.         iqenum, iq, state = nil, nil, nil
  1413.     end
  1414.     mt.__ipairs = __ipairs
  1415.     mt.__pairs = __pairs
  1416.  
  1417.     local qResult = {}
  1418.     luaq.util.attachLuaq(qResult, mt)
  1419.  
  1420.     return qResult
  1421. end
  1422.  
  1423. function luaq.prepend(query, ...)
  1424.     if type(query) == "table" then
  1425.         if not isQuery(query) then
  1426.             query = luaq.iasQuery(query)
  1427.         end
  1428.     else
  1429.         luaq.util.errBadArgValue("prepend", 1, "查询对象", query, "（不是%s）。")
  1430.     end
  1431.     if type(func) ~= "function" then luaq.util.errBadArgType("prepend", 2, "function", func) end
  1432.  
  1433.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1434.     local extra = { ... } -- 要追加的项。
  1435.     local mt = {
  1436.         __cache = {},
  1437.         __cachedone = false
  1438.     }
  1439.     mt.__index = __index
  1440.     mt.__cachetill = function(self, index)
  1441.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1442.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1443.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1444.  
  1445.         local c = self.__cache -- 获取缓存数组。
  1446.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1447.  
  1448.         if iqenum == nil then
  1449.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1450.             table.insert(c, extra) -- 向缓存数组中插入追加项。
  1451.         end
  1452.  
  1453.         local next
  1454.         while index > #c do
  1455.             state, next = iqenum(iq, state)
  1456.             if next == nil then break end
  1457.  
  1458.             table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  1459.         end
  1460.  
  1461.         if next == nil then self.__cachedone = true end -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  1462.     end
  1463.     mt.__enum = __enum
  1464.     mt.__reset = function(q)
  1465.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  1466.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1467.  
  1468.         local self = getmetatable(q)
  1469.         self.__cache = {}
  1470.         self.__cachedone = false
  1471.  
  1472.         iqenum, iq, state = nil, nil, nil
  1473.     end
  1474.     mt.__ipairs = __ipairs
  1475.     mt.__pairs = __pairs
  1476.  
  1477.     local qResult = {}
  1478.     luaq.util.attachLuaq(qResult, mt)
  1479.  
  1480.     return qResult
  1481. end
  1482.  
  1483. function luaq.reverse(query)
  1484.     if type(query) == "table" then
  1485.         if not isQuery(query) then
  1486.             query = luaq.iasQuery(query)
  1487.         end
  1488.     else
  1489.         luaq.util.errBadArgValue("reverse", 1, "查询对象", query, "（不是%s）。")
  1490.     end
  1491.  
  1492.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1493.     local mt = {
  1494.         __cache = {},
  1495.         __cachedone = false
  1496.     }
  1497.     mt.__index = function(q, k)
  1498.         if type(k) == "number" and k > 0 then
  1499.             local self = getmetatable(q)
  1500.             self:__cacheall() -- 计算所有查询结果并缓存。
  1501.  
  1502.             return self.__cache[#self.__cache - k + 1]
  1503.         end
  1504.     end
  1505.     mt.__cacheall = function(self)
  1506.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1507.  
  1508.         if iqenum == nil then
  1509.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1510.         end
  1511.  
  1512.         local c = self.__cache -- 获取缓存数组。
  1513.  
  1514.         local next
  1515.         while true do
  1516.             state, next = iqenum(iq, state)
  1517.             if next == nil then break end
  1518.  
  1519.             table.insert(c, next) -- 向缓存数组中插入新项。
  1520.         end
  1521.  
  1522.         self.__cachedone = true -- 设置缓存完毕标识符。
  1523.     end
  1524.     mt.__enum = __enum
  1525.     mt.__reset = function(q)
  1526.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  1527.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1528.  
  1529.         local self = getmetatable(q)
  1530.         self.__cache = {}
  1531.         self.__cachedone = false
  1532.  
  1533.         iqenum, iq, state = nil, nil, nil
  1534.     end
  1535.     mt.__ipairs = __ipairs
  1536.     mt.__pairs = __pairs
  1537.  
  1538.     local qResult = {}
  1539.     luaq.util.attachLuaq(qResult, mt)
  1540.  
  1541.     return qResult
  1542. end
  1543.  
  1544. function luaq.aggregate(query, func, seed, ...)
  1545.     if type(query) == "table" then
  1546.         if not isQuery(query) then
  1547.             query = luaq.iasQuery(query)
  1548.         end
  1549.     else
  1550.         luaq.util.errBadArgValue("aggregate", 1, "查询对象", query, "（不是%s）。")
  1551.     end
  1552.     if type(func) ~= "function" then luaq.util.errBadArgType("aggregate", 2, "function", func) end
  1553.     if seed ~= nil or type(seed) ~= "table" then luaq.util.errBadArgValue("aggregate", 2, "合法的元组", query, "（不是%s）。") end
  1554.  
  1555.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1556.     local _, result = iqenum(iq, 0)
  1557.  
  1558.     local result, next = seed, nil
  1559.     while true do
  1560.         state, next = iqenum(iq, state)
  1561.         if next == nil then break end
  1562.         if result then
  1563.             result = { func(state - 1, result, state, next) }
  1564.         else result = next
  1565.         end
  1566.     end
  1567.  
  1568.     if result == nil then return ...
  1569.     else return unpack(result)
  1570.     end
  1571. end
  1572.  
  1573. function luaq.reserve(query, ...)
  1574.     if type(query) == "table" then
  1575.         if not isQuery(query) then
  1576.             query = luaq.iasQuery(query)
  1577.         end
  1578.     else
  1579.         luaq.util.errBadArgValue("reserve", 1, "查询对象", query, "（不是%s）。")
  1580.     end
  1581.  
  1582.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1583.     local default = { ... } -- 要预留的项。
  1584.     local mt = {
  1585.         __cache = {},
  1586.         __cachedone = false
  1587.     }
  1588.     mt.__index = __index
  1589.     mt.__cachetill = function(self, index)
  1590.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1591.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1592.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1593.  
  1594.         local c = self.__cache -- 获取缓存数组。
  1595.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1596.  
  1597.         if iqenum == nil then
  1598.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1599.         end
  1600.  
  1601.         local next
  1602.         while index > #c do
  1603.             state, next = iqenum(iq, state)
  1604.             if next == nil then break end
  1605.  
  1606.             table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  1607.         end
  1608.  
  1609.         if next == nil then -- 当数组下一个项是nil时。
  1610.             if #c == 0 then -- 内部查询对象为空（缓存为空）
  1611.                 table.insert(c, extra) -- 向缓存数组中插入预留项。
  1612.             end
  1613.             self.__cachedone = true -- 设置缓存完毕标识符
  1614.         end
  1615.     end
  1616.     mt.__enum = __enum
  1617.     mt.__reset = function(q)
  1618.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  1619.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1620.  
  1621.         local self = getmetatable(q)
  1622.         self.__cache = {}
  1623.         self.__cachedone = false
  1624.  
  1625.         iqenum, iq, state = nil, nil, nil
  1626.     end
  1627.     mt.__ipairs = __ipairs
  1628.     mt.__pairs = __pairs
  1629.  
  1630.     local qResult = {}
  1631.     luaq.util.attachLuaq(qResult, mt)
  1632.  
  1633.     return qResult
  1634. end
  1635.  
  1636. function luaq.first(query, ...)
  1637.     if type(query) == "table" then
  1638.         if not isQuery(query) then
  1639.             query = luaq.iasQuery(query)
  1640.         end
  1641.     else
  1642.         luaq.util.errBadArgValue("first", 1, "查询对象", query, "（不是%s）。")
  1643.     end
  1644.  
  1645.     local iqenum, iq = getmetatable(query).__enum, query -- 获取内部查询对象的枚举元函数以及固定值。
  1646.     local _, result = iqenum(iq, 0)
  1647.  
  1648.     if result == nil then return ...
  1649.     else return unpack(result)
  1650.     end
  1651. end
  1652.  
  1653. function luaq.last(query, ...)
  1654.     if type(query) == "table" then
  1655.         if not isQuery(query) then
  1656.             query = luaq.iasQuery(query)
  1657.         end
  1658.     else
  1659.         luaq.util.errBadArgValue("last", 1, "查询对象", query, "（不是%s）。")
  1660.     end
  1661.  
  1662.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1663.     local result, next
  1664.     while true do
  1665.         state, next = iqenum(iq, state)
  1666.         if next == nil then break
  1667.         else result = next
  1668.         end
  1669.     end
  1670.  
  1671.     if result == nil then return ...
  1672.     else return unpack(result)
  1673.     end
  1674. end
  1675.  
  1676. function luaq.only(query, ...)
  1677.     if type(query) == "table" then
  1678.         if not isQuery(query) then
  1679.             query = luaq.iasQuery(query)
  1680.         end
  1681.     else
  1682.         luaq.util.errBadArgValue("only", 1, "查询对象", query, "（不是%s）。")
  1683.     end
  1684.  
  1685.     local iqenum, iq = getmetatable(query).__enum, query -- 获取内部查询对象的枚举元函数以及固定值。
  1686.     local state, result = iqenum(iq, 0)
  1687.  
  1688.     if result == nil or iqenum(iq, state) ~= nil then return ... -- 仅当不存在第一项或存在第二项时返回默认值。
  1689.     else return unpack(result)
  1690.     end
  1691. end
  1692.  
  1693. function luaq.sum(query, addition, ...)
  1694.     if type(query) == "table" then
  1695.         if not isQuery(query) then
  1696.             query = luaq.iasQuery(query)
  1697.         end
  1698.     else
  1699.         luaq.util.errBadArgValue("sum", 1, "查询对象", query, "（不是%s）。")
  1700.     end
  1701.     if type(addition) ~= "nil" and type(addition) ~= "function" then luaq.util.errBadArgType("average", 2, "nil或function", addition)
  1702.     end
  1703.  
  1704.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1705.     local result, next
  1706.     while true do
  1707.         state, next = iqenum(iq, state)
  1708.         if next == nil then break end
  1709.  
  1710.         if result == nil then
  1711.             if addition == nil then
  1712.                 local temp = {}
  1713.                 local length = select("#", next)
  1714.                 for _index = 1, length do
  1715.                     temp[_index] = tonumber(next[_index])
  1716.                 end
  1717.                 result = temp
  1718.             else result = next
  1719.             end
  1720.         else
  1721.             if addition == nil then
  1722.                 local temp = {}
  1723.                 local length = math.max(select("#", result), select("#", next))
  1724.                 for _index = 1, length do
  1725.                     local v1, v2 = result[_index], tonumber(next[_index])
  1726.                     if v1 ~= nil and v2 ~= nil then
  1727.                         temp[_index] = v1 + v2
  1728.                     else
  1729.                         temp[_index] = v1 or v2
  1730.                     end
  1731.                 end
  1732.             else result = addition(result, next)
  1733.             end
  1734.         end
  1735.     end
  1736.  
  1737.     if result == nil then return ...
  1738.     else return unpack(result)
  1739.     end
  1740. end
  1741.  
  1742. function luaq.average(query, addition, division, ...)
  1743.     if type(query) == "table" then
  1744.         if not isQuery(query) then
  1745.             query = luaq.iasQuery(query)
  1746.         end
  1747.     else
  1748.         luaq.util.errBadArgValue("average", 1, "查询对象", query, "（不是%s）。")
  1749.     end
  1750.     if addition == nil then division = nil -- 未提供求和函数时，使用默认的求和函数及求商函数。
  1751.     elseif type(addition) ~= "function" then luaq.util.errBadArgType("average", 2, "nil或function", addition)
  1752.     end
  1753.     if division ~= nil and type(division) ~= "function" then luaq.util.errBadArgType("average", 3, "nil或function", division) end
  1754.  
  1755.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1756.     local result, count, next
  1757.     while true do
  1758.         state, next = iqenum(iq, state)
  1759.         if next == nil then break end
  1760.  
  1761.         if result == nil then
  1762.             if addition == nil then
  1763.                 local temp = {}
  1764.                 local length = select("#", next)
  1765.                 for _index = 1, length do
  1766.                     temp[_index] = tonumber(next[_index])
  1767.                 end
  1768.                 result = temp
  1769.             else result = next
  1770.             end
  1771.         else
  1772.             if addition == nil then
  1773.                 local temp = {}
  1774.                 local length = math.max(select("#", result), select("#", next))
  1775.                 for _index = 1, length do
  1776.                     local v1, v2 = result[_index], tonumber(next[_index])
  1777.                     if v1 ~= nil and v2 ~= nil then
  1778.                         temp[_index] = v1 + v2
  1779.                     else
  1780.                         temp[_index] = v1 or v2
  1781.                     end
  1782.                 end
  1783.             else result = addition(result, next)
  1784.             end
  1785.         end
  1786.  
  1787.         count = count + 1
  1788.     end
  1789.  
  1790.     if result == nil then return ... end
  1791.  
  1792.     if division == nil then
  1793.         local length = select("#", result)
  1794.         for _index = 1, length do
  1795.             if result[_index] then
  1796.                 result[_index] = result[_index] / count
  1797.             end
  1798.         end
  1799.     else result = division(unpack(result))
  1800.     end
  1801.  
  1802.     return unpack(result)
  1803. end
  1804.  
  1805. function luaq.max(query, comp, ...)
  1806.     if type(query) == "table" then
  1807.         if not isQuery(query) then
  1808.             query = luaq.iasQuery(query)
  1809.         end
  1810.     else
  1811.         luaq.util.errBadArgValue("max", 1, "查询对象", query, "（不是%s）。")
  1812.     end
  1813.     if comp ~= nil and type(comp) ~= "function" then luaq.util.errBadArgType("max", 2, "nil或function", comp) end
  1814.  
  1815.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1816.     local result, next
  1817.     while true do
  1818.         state, next = iqenum(iq, state)
  1819.         if next == nil then break end
  1820.  
  1821.         if result == nil then result = next
  1822.         else
  1823.             if comp == nil then
  1824.                 if luaq.util.compare(result, next) < 0 then
  1825.                     result = next
  1826.                 end
  1827.             else
  1828.                 local compTest = comp(result, next)
  1829.                 if compTest == true or compTest < 0 then
  1830.                     result = next
  1831.                 end
  1832.             end
  1833.         end
  1834.     end
  1835.  
  1836.     if result == nil then return ...
  1837.     else return unpack(result)
  1838.     end
  1839. end
  1840.  
  1841. function luaq.min(query, comp, ...)
  1842.     if type(query) == "table" then
  1843.         if not isQuery(query) then
  1844.             query = luaq.iasQuery(query)
  1845.         end
  1846.     else
  1847.         luaq.util.errBadArgValue("min", 1, "查询对象", query, "（不是%s）。")
  1848.     end
  1849.     if comp ~= nil and type(comp) ~= "function" then luaq.util.errBadArgType("min", 2, "nil或function", comp) end
  1850.  
  1851.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1852.     local result, next
  1853.     while true do
  1854.         state, next = iqenum(iq, state)
  1855.         if next == nil then break end
  1856.  
  1857.         if result == nil then result = next
  1858.         else
  1859.             if comp == nil then
  1860.                 if luaq.util.compare(result, next) > 0 then
  1861.                     result = next
  1862.                 end
  1863.             else
  1864.                 local compTest = comp(next, result)
  1865.                 if compTest == true or compTest > 0 then
  1866.                     result = next
  1867.                 end
  1868.             end
  1869.         end
  1870.     end
  1871.  
  1872.     if result == nil then return ...
  1873.     else return unpack(result)
  1874.     end
  1875. end
  1876.  
  1877. function luaq.sub(query, i, j)
  1878.     if type(query) == "table" then
  1879.         if not isQuery(query) then
  1880.             query = luaq.iasQuery(query)
  1881.         end
  1882.     else
  1883.         luaq.util.errBadArgValue("sub", 1, "查询对象", query, "（不是%s）。")
  1884.     end
  1885.     if type(i) ~= "number" then luaq.util.errBadArgType("sub", 2, "number", i)
  1886.     elseif i > 0 then i = math.ceil(i)
  1887.     elseif i < 0 then i = math.floor(i)
  1888.     else luaq.util.errBadArgValue("sub", 2, "非零的整数", i)
  1889.     end
  1890.     if j == nil then j = -1
  1891.     elseif type(j) ~= "number" then luaq.util.errBadArgType("sub", 3, "nil或number", j)
  1892.     elseif j > 0 then j = math.floor(j)
  1893.     elseif j < 0 then j = math.ceil(j)
  1894.     else luaq.util.errBadArgValue("sub", 3, "非零的整数", j)
  1895.     end
  1896.  
  1897.     local iqenum, iq, state -- 内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1898.     local buff = {}
  1899.     local mt = {
  1900.         __cache = {},
  1901.         __cachedone = false
  1902.     }
  1903.     mt.__index = __index
  1904.     mt.__cachetill = function(self, index)
  1905.         if self.__cachedone then return end -- 如果已缓存完毕则退出。
  1906.         if type(index) ~= "number" then luaq.util.errBadArgType("__cachetill", 2, "number", index) end
  1907.         if index <= 0 then luaq.util.errBadArgValue("__cachetill", 2, "正整数", index) end
  1908.  
  1909.         local c = self.__cache -- 获取缓存数组。
  1910.         if index <= #c then return end -- 如果指定索引小于已缓存项的数量，则直接退出。
  1911.  
  1912.         if iqenum == nil then
  1913.             iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  1914.         end
  1915.  
  1916.         if ((i < 0) == (j < 0)) and i > j then -- 两个索引符号相同且起始索引大于结束索引，截取子串为空串。
  1917.             self.__cachedone = true -- 设置缓存完毕标识符。
  1918.             return
  1919.         end
  1920.  
  1921.         if i < 0 then -- 当起始索引为反向定位时，必须获得内部查询对象的所有项的数量。
  1922.             -- 缓存所有项。
  1923.             local count = 0
  1924.             while true do
  1925.                 local next
  1926.                 state, next = iqenum(iq, state)
  1927.                 if next == nil then break -- 缓存结束分支。
  1928.                 elseif j > 0 and count + i >= j then -- 计算得到起始索引大于结束索引。
  1929.                     self.__cachedone = true -- 设置缓存完毕标识符。
  1930.                     return
  1931.                 end
  1932.  
  1933.                 table.insert(buff, next)
  1934.                 count = count + 1
  1935.             end
  1936.  
  1937.             local v1, v2 = i, j
  1938.             if i < 0 then v1 = count + i + 1 end -- 获得正向定位起始索引。
  1939.             if j < 0 then v2 = count + j + 1 end -- 获得正向定位结束索引。
  1940.             for _index = v1, v2 do
  1941.                 local e = buff[_index]
  1942.                 if e == nil then break end
  1943.  
  1944.                 table.insert(c, { unpack(e) }) -- 向缓存数组中插入新项。
  1945.             end
  1946.             self.__cachedone = true -- 设置缓存完毕标识符。
  1947.         else
  1948.             local v1, v2 = i, j
  1949.             while (j < 0 or state < j) and index > #c do
  1950.                 local next
  1951.                 if j < 0 then v2 = state + j + 2 end -- 获得正向定位结束索引。
  1952.                 state, next = iqenum(iq, state)
  1953.                 if next == nil then
  1954.                     self.__cachedone = true -- 仅当数组下一个项是nil时设置缓存完毕标识符。
  1955.                     if v1 > v2 then return -- 计算得到起始索引大于结束索引。
  1956.                     else break
  1957.                     end
  1958.                 elseif state >= v1 then
  1959.                     if j > 0 then
  1960.                         table.insert(c, { unpack(next) }) -- 向缓存数组中插入新项。
  1961.                     else
  1962.                         table.insert(buff, next)
  1963.                         if v2 >= v1 then
  1964.                             table.insert(c, { unpack(buff[v2 - v1 + 1]) }) -- 向缓存数组中插入新项。
  1965.                         end
  1966.                     end
  1967.                 end
  1968.             end
  1969.         end
  1970.     end
  1971.     mt.__enum = __enum
  1972.     mt.__reset = function(q)
  1973.         local __reset = getmetatable(query).__reset -- 获取重置元函数。
  1974.         if __reset then __reset(query) end -- 首先重置内部查询对象。
  1975.  
  1976.         local self = getmetatable(q)
  1977.         self.__cache = {}
  1978.         self.__cachedone = false
  1979.  
  1980.         iqenum, iq, state = nil, nil, nil
  1981.         buff = {}
  1982.     end
  1983.     mt.__ipairs = __ipairs
  1984.     mt.__pairs = __pairs
  1985.  
  1986.     local qResult = {}
  1987.     luaq.util.attachLuaq(qResult, mt)
  1988.  
  1989.     return qResult
  1990. end
  1991.  
  1992. function luaq.skip(query, count, func)
  1993.     if type(query) == "table" then
  1994.         if not isQuery(query) then
  1995.             query = luaq.iasQuery(query)
  1996.         end
  1997.     else
  1998.         luaq.util.errBadArgValue("skip", 1, "查询对象", query, "（不是%s）。")
  1999.     end
  2000.     if type(count) ~= "number" then luaq.util.errBadArgType("skip", 2, "number", count)
  2001.     elseif count < 0 then luaq.util.errBadArgValue("skip", 2, "不是自然数", count)
  2002.     end
  2003.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("skip", 3, "nil或function", func) end
  2004.  
  2005.     if func then
  2006.         query = query:where(func)
  2007.     end
  2008.  
  2009.     if count >= 0 then
  2010.         return query:sub(math.floor(count + 1))
  2011.     else
  2012.         return query:sub(1, math.ceil(count - 1))
  2013.     end
  2014. end
  2015.  
  2016. function luaq.take(query, count, func)
  2017.     if type(query) == "table" then
  2018.         if not isQuery(query) then
  2019.             query = luaq.iasQuery(query)
  2020.         end
  2021.     else
  2022.         luaq.util.errBadArgValue("take", 1, "查询对象", query, "（不是%s）。")
  2023.     end
  2024.     if type(count) ~= "number" then luaq.util.errBadArgType("take", 2, "number", count)
  2025.     elseif count < 0 then luaq.util.errBadArgValue("take", 2, "不是自然数", count)
  2026.     end
  2027.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("take", 3, "nil或function", func) end
  2028.  
  2029.     if func then
  2030.         query = query:where(func)
  2031.     end
  2032.  
  2033.     if count >= 0 then
  2034.         return query:sub(1, math.floor(count))
  2035.     else
  2036.         return query:sub(math.ceil(count))
  2037.     end
  2038. end
  2039.  
  2040. function luaq.ofType(query, typename)
  2041.     if type(query) == "table" then
  2042.         if not isQuery(query) then
  2043.             query = luaq.iasQuery(query)
  2044.         end
  2045.     else
  2046.         luaq.util.errBadArgValue("ofType", 1, "查询对象", query, "（不是%s）。")
  2047.     end
  2048.     if type(typename) ~= "string" then luaq.util.errBadArgType("ofType", 2, "string", typename) end
  2049.  
  2050.     return query:where(function(_, e) return type(e) == typename end)
  2051. end
  2052.  
  2053. function luaq.query(query)
  2054.     if type(query) == "table" then
  2055.         if not isQuery(query) then
  2056.             query = luaq.iasQuery(query)
  2057.         end
  2058.     else
  2059.         luaq.util.errBadArgValue("query", 1, "查询对象", query, "（不是%s）。")
  2060.     end
  2061.  
  2062.     local tResult = {}
  2063.     for _, entry in enum(query) do
  2064.         table.insert(tResult, entry)
  2065.     end
  2066.  
  2067.     return tResult
  2068. end
  2069.  
  2070. function luaq.each(query, func)
  2071.     if type(query) == "table" then
  2072.         if not isQuery(query) then
  2073.             query = luaq.iasQuery(query)
  2074.         end
  2075.     else
  2076.         luaq.util.errBadArgValue("foreach", 1, "查询对象", query, "（不是%s）。")
  2077.     end
  2078.     if type(func) ~= "function" then luaq.util.errBadArgType("foreach", 2, "function", func) end
  2079.  
  2080.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  2081.     local next
  2082.     while true do
  2083.         state, next = iqenum(iq, state)
  2084.         if next == nil then break end
  2085.  
  2086.         func(state, unpack(next)) -- 调用操作函数。
  2087.     end
  2088. end
  2089.  
  2090. function luaq.has(query, func, ...)
  2091.     if type(query) == "table" then
  2092.         if not isQuery(query) then
  2093.             query = luaq.iasQuery(query)
  2094.         end
  2095.     else
  2096.         luaq.util.errBadArgValue("has", 1, "查询对象", query, "（不是%s）。")
  2097.     end
  2098.     if func ~= nil and type(func) ~= "function" then luaq.util.errBadArgType("has", 2, "nil或function", func) end
  2099.  
  2100.     local iqenum, iq, state = getmetatable(query).__enum, query, 0 -- 获取内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  2101.     local entry = { ... }
  2102.     local next
  2103.     while true do
  2104.         state, next = iqenum(iq, state)
  2105.         if next == nil then break end
  2106.  
  2107.         if func then
  2108.             local evenTest = func(entry, next) -- 调用筛选函数。
  2109.             if evenTest == true or evenTest == 0 then return true end -- 找到相等项。
  2110.         else
  2111.             if luaq.util.equal(entry, next) then return true end -- 找到相等项。
  2112.         end
  2113.     end
  2114.  
  2115.     return false -- 未找到相等项。
  2116. end
  2117.  
  2118. function luaq.is(query, other, func, sequence)
  2119.     if type(query) == "table" then
  2120.         if not isQuery(query) then
  2121.             query = luaq.iasQuery(query)
  2122.         end
  2123.     else
  2124.         luaq.util.errBadArgValue("is", 1, "查询对象", query, "（不是%s）。")
  2125.     end
  2126.     if type(other) == "table" then
  2127.         if not isQuery(other) then
  2128.             other = luaq.iasQuery(other)
  2129.         end
  2130.     else
  2131.         luaq.util.errBadArgValue("is", 2, "查询对象", other, "（不是%s）。")
  2132.     end
  2133.     if sequence == nil then sequence = true
  2134.     elseif type(sequence) ~= "boolean" then
  2135.         luaq.util.errBadArgType("is", 4, "nil或boolean", sequence)
  2136.     end
  2137.  
  2138.     if sequence then
  2139.         local iqenum1, iq1, state1 = getmetatable(query).__enum, query, 0 -- 获取第一个内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  2140.         local iqenum2, iq2, state2 = getmetatable(other).__enum, other, 0 -- 获取另一个内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  2141.         local next1, next2
  2142.         while true do
  2143.             state1, next1 = iqenum1(iq1, state1)
  2144.             state2, next2 = iqenum2(iq2, state2)
  2145.  
  2146.             if next1 ~= nil and next2 ~= nil then
  2147.                 local isEven
  2148.                 if func then
  2149.                     local evenTest = func(next1, next2) -- 调用筛选函数。
  2150.                     isEven = evenTest == true or evenTest == 0
  2151.                 else
  2152.                     isEven = luaq.util.equal(next1, next2)
  2153.                 end
  2154.                 if not isEven then return false end
  2155.             elseif (next1 == nil) ~= (next2 == nil) then return false
  2156.             end
  2157.             if next1 == nil or next2 == nil then break end
  2158.         end
  2159.  
  2160.         return true
  2161.     else
  2162.         -- 获取两个结果表，若长度不一致则不相等。
  2163.         local result1 = query:distinct(func):query()
  2164.         local result2 = other:distinct(func):query()
  2165.         if #result1 ~= #result2 then return false end
  2166.  
  2167.         for index1, entry1 in ipairs(result1) do
  2168.             for index2, entry2 in ipairs(result2) do
  2169.                 if entry2 then -- 仅当entry2为table类型时才为真。（请不要轻易改动此表达式。）
  2170.                     local isEven
  2171.                     if func then
  2172.                         local evenTest = func(entry1, entry2) -- 调用筛选函数。
  2173.                         isEven = evenTest == true or evenTest == 0
  2174.                     else
  2175.                         isEven = luaq.util.equal(entry1, entry2)
  2176.                     end
  2177.                     if isEven then
  2178.                         result2[index2] = false -- 使得外层if条件永远为假。（请不要轻易改动此值。）
  2179.                         entry1 = nil -- 供外层for检测使用。（请不要轻易改动此值。）
  2180.                         break
  2181.                     end
  2182.                 end
  2183.             end
  2184.             if entry1 then return false end -- 在内层for中未被设置为nil。（请不要轻易改动此表达式。）
  2185.         end
  2186.  
  2187.         return true
  2188.     end
  2189. end
  2190.  
  2191. local function isSubRelationship(query, other, func, sequence)
  2192.     if sequence then
  2193.         local iqenum1, iq1, state1 = getmetatable(query).__enum, query, 0 -- 获取第一个内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  2194.         local iqenum2, iq2, state2 = getmetatable(other).__enum, other, 0 -- 获取另一个内部查询对象的枚举元函数、固定值以及迭代器的起始状态。
  2195.         local next1, next2
  2196.         state1, next1 = iqenum1(iq1, state1)
  2197.         state2, next2 = iqenum2(iq2, state2)
  2198.         local fstart = false -- 序列匹配开始标识符。
  2199.         while true do
  2200.             if next1 == nil then return true -- 子序列匹配到结尾。
  2201.             elseif next2 == nil then return false -- 子序列未匹配到结尾时，被检测序列到达结尾。
  2202.             else
  2203.                 local isEven
  2204.                 if func then
  2205.                     local evenTest = func(next1, next2) -- 调用筛选函数。
  2206.                     isEven = evenTest == true or evenTest == 0
  2207.                 else
  2208.                     isEven = luaq.util.equal(next1, next2)
  2209.                 end
  2210.                 if isEven then
  2211.                     if not fstart then fstart = true end -- 匹配开始。
  2212.                     state1, next1 = iqenum1(iq1, state1) -- 子序列匹配指针向后移动一项。
  2213.                 else
  2214.                     if fstart then -- 复位子序列匹配指针以及状态。
  2215.                         fstart = false
  2216.                         state1, next1 = iqenum1(iq1, 0)
  2217.                     end
  2218.                 end
  2219.                 state2, next2 = iqenum2(iq2, state2) -- 被检测序列指针向后移动一项。
  2220.             end
  2221.         end
  2222.     else
  2223.         -- 获取两个结果表。
  2224.         local result1 = query:distinct(func):query()
  2225.         local result2 = other:query()
  2226.  
  2227.         for index1, entry1 in ipairs(result1) do
  2228.             for index2, entry2 in ipairs(result2) do
  2229.                 if entry2 then -- 仅当entry2为table类型时才为真。（请不要轻易改动此表达式。）
  2230.                     local isEven
  2231.                     if func then
  2232.                         local evenTest = func(entry1, entry2) -- 调用筛选函数。
  2233.                         isEven = evenTest == true or evenTest == 0
  2234.                     else
  2235.                         isEven = luaq.util.equal(entry1, entry2)
  2236.                     end
  2237.                     if isEven then
  2238.                         result2[index2] = false -- 使得外层if条件永远为假。（请不要轻易改动此值。）
  2239.                         entry1 = nil -- 供外层for检测使用。（请不要轻易改动此值。）
  2240.                         break
  2241.                     end
  2242.                 end
  2243.             end
  2244.             if entry1 then return false end -- 在内层for中未被设置为nil。（请不要轻易改动此表达式。）
  2245.         end
  2246.  
  2247.         return true
  2248.     end
  2249. end
  2250. function luaq.subOf(query, other, func, sequence)
  2251.     if type(query) == "table" then
  2252.         if not isQuery(query) then
  2253.             query = luaq.iasQuery(query)
  2254.         end
  2255.     else
  2256.         luaq.util.errBadArgValue("subOf", 1, "查询对象", query, "（不是%s）。")
  2257.     end
  2258.     if type(other) == "table" then
  2259.         if not isQuery(other) then
  2260.             other = luaq.iasQuery(other)
  2261.         end
  2262.     else
  2263.         luaq.util.errBadArgValue("subOf", 2, "查询对象", other, "（不是%s）。")
  2264.     end
  2265.     if sequence == nil then sequence = true
  2266.     elseif type(sequence) ~= "boolean" then
  2267.         luaq.util.errBadArgType("subOf", 4, "nil或boolean", sequence)
  2268.     end
  2269.  
  2270.     local rel = isSubRelationship(query, other, func, sequence)
  2271.     return rel
  2272. end
  2273.  
  2274. function luaq.superOf(query, other, func, sequence)
  2275.     if type(query) == "table" then
  2276.         if not isQuery(query) then
  2277.             query = luaq.iasQuery(query)
  2278.         end
  2279.     else
  2280.         luaq.util.errBadArgValue("superOf", 1, "查询对象", query, "（不是%s）。")
  2281.     end
  2282.     if type(other) == "table" then
  2283.         if not isQuery(other) then
  2284.             other = luaq.iasQuery(other)
  2285.         end
  2286.     else
  2287.         luaq.util.errBadArgValue("superOf", 2, "查询对象", other, "（不是%s）。")
  2288.     end
  2289.     if sequence == nil then sequence = true
  2290.     elseif type(sequence) ~= "boolean" then
  2291.         luaq.util.errBadArgType("superOf", 4, "nil或boolean", sequence)
  2292.     end
  2293.  
  2294.     local rel = isSubRelationship(other, query, func, sequence)
  2295.     return rel
  2296. end
  2297.  
  2298. function luaq.properSubOf(query, other, func, sequence)
  2299.     if type(query) == "table" then
  2300.         if not isQuery(query) then
  2301.             query = luaq.iasQuery(query)
  2302.         end
  2303.     else
  2304.         luaq.util.errBadArgValue("properSubOf", 1, "查询对象", query, "（不是%s）。")
  2305.     end
  2306.     if type(other) == "table" then
  2307.         if not isQuery(other) then
  2308.             other = luaq.iasQuery(other)
  2309.         end
  2310.     else
  2311.         luaq.util.errBadArgValue("properSubOf", 2, "查询对象", other, "（不是%s）。")
  2312.     end
  2313.     if sequence == nil then sequence = true
  2314.     elseif type(sequence) ~= "boolean" then
  2315.         luaq.util.errBadArgType("properSubOf", 4, "nil或boolean", sequence)
  2316.     end
  2317.  
  2318.     local rel, proper = isSubRelationship(query, other, func, sequence)
  2319.     return rel and proper
  2320. end
  2321.  
  2322. function luaq.properSuperOf(query, other, func, sequence)
  2323.     if type(query) == "table" then
  2324.         if not isQuery(query) then
  2325.             query = luaq.iasQuery(query)
  2326.         end
  2327.     else
  2328.         luaq.util.errBadArgValue("properSuperOf", 1, "查询对象", query, "（不是%s）。")
  2329.     end
  2330.     if type(other) == "table" then
  2331.         if not isQuery(other) then
  2332.             other = luaq.iasQuery(other)
  2333.         end
  2334.     else
  2335.         luaq.util.errBadArgValue("properSuperOf", 2, "查询对象", other, "（不是%s）。")
  2336.     end
  2337.     if sequence == nil then sequence = true
  2338.     elseif type(sequence) ~= "boolean" then
  2339.         luaq.util.errBadArgType("properSuperOf", 4, "nil或boolean", sequence)
  2340.     end
  2341.  
  2342.     local rel, proper = isSubRelationship(other, query, func, sequence)
  2343.     return rel and proper
  2344. end
  2345.  
  2346. function luaq.overlap(query, other, func, sequence)
  2347.     if type(query) == "table" then
  2348.         if not isQuery(query) then
  2349.             query = luaq.iasQuery(query)
  2350.         end
  2351.     else
  2352.         luaq.util.errBadArgValue("overlap", 1, "查询对象", query, "（不是%s）。")
  2353.     end
  2354.     if type(other) == "table" then
  2355.         if not isQuery(other) then
  2356.             other = luaq.iasQuery(other)
  2357.         end
  2358.     else
  2359.         luaq.util.errBadArgValue("overlap", 2, "查询对象", other, "（不是%s）。")
  2360.     end
  2361.     if sequence == nil then sequence = true
  2362.     elseif type(sequence) ~= "boolean" then
  2363.         luaq.util.errBadArgType("overlap", 4, "nil或boolean", sequence)
  2364.     end
  2365.  
  2366.     -- 获取两个结果表。
  2367.     local result1 = query:distinct(func):query()
  2368.     local result2 = other:distinct(func):query()
  2369.     if #result1 == 0 or #result2 == 0 then return false end -- 任何一个为空集时两者不相交。
  2370.  
  2371.     if sequence then
  2372.         for i = 1, 5 do
  2373.             local entry, seq
  2374.             if i == 1 then entry, seq = result1[1], result2
  2375.             elseif i == 2 then entry, seq = result1[#result1], result2
  2376.             elseif i == 3 then entry, seq = result2[1], result1
  2377.             elseif i == 4 then etnry, seq = result2[#result2], result1
  2378.             else return false -- 四种情况均未发现相等项，则两者不相交。
  2379.             end
  2380.  
  2381.             for _, seqEntry in ipairs(seq) do
  2382.                 local isEven
  2383.                 if func then
  2384.                     local evenTest = func(entry, seqEntry) -- 调用筛选函数。
  2385.                     isEven = evenTest == true or evenTest == 0
  2386.                 else
  2387.                     isEven = luaq.util.equal(entry, seqEntry)
  2388.                 end
  2389.                 if isEven then return true end -- 发现相等项，两者相交。
  2390.             end
  2391.         end
  2392.     else
  2393.         for index1, entry1 in ipairs(result1) do
  2394.             for index2, entry2 in ipairs(result2) do
  2395.                 local isEven
  2396.                 if func then
  2397.                     local evenTest = func(entry1, entry2) -- 调用筛选函数。
  2398.                     isEven = evenTest == true or evenTest == 0
  2399.                 else
  2400.                     isEven = luaq.util.equal(entry1, entry2)
  2401.                 end
  2402.                 if isEven then return true end -- 发现相等项，两者相交。
  2403.             end
  2404.         end
  2405.  
  2406.         return false
  2407.     end
  2408. end
  2409.  
  2410. -- 查询对象的默认链接元函数。（必须提供concat、append、prepend函数的实现。）
  2411. local function __concat(l, r)
  2412.     local v1, v2 = isQuery(l), isQuery(r)
  2413.  
  2414.     if v1 and v2 then return l:concat(r)
  2415.     elseif v1 and not v2 then return l:append(r)
  2416.     elseif not v1 and v2 then return l:prepend(r)
  2417.     else
  2418.         luaq.util.errBadArgValue("__concat", 1, "查询对象", l, "（不是%s）。")
  2419.     end
  2420. end
  2421.  
  2422. -- 查询对象的默认乘运算元函数。（必须提供join、duplicate函数的实现。）
  2423. local function __mul(l, r)
  2424.     local v1, v2 = isQuery(l), isQuery(r)
  2425.  
  2426.     if v1 and v2 then return l:join(r)
  2427.     elseif v1 and type(v2) == "number" then return l:duplicate(r)
  2428.     elseif v2 and type(v1) == "number" then return r:duplicate(l)
  2429.     elseif v1 then
  2430.         luaq.util.errBadArgValue("__mul", 1, "查询对象", l, "（不是%s）。")
  2431.     else
  2432.         luaq.util.errBadArgType("__mul", 1, "number", l)
  2433.     end
  2434. end
  2435.  
  2436. -- 查询对象的默认商运算元函数。（必须提供groupBy函数的实现。）
  2437. local function __div(query, key)
  2438.     if type(query) == "table" then
  2439.         if not isQuery(query) then
  2440.             query = luaq.iasQuery(query)
  2441.         end
  2442.     else
  2443.         luaq.util.errBadArgValue("__div", 1, "查询对象", query, "（不是%s）。")
  2444.     end
  2445.     if key == nil then luaq.util.errBadArgType("__div", 2, "非nil", key) end
  2446.  
  2447.     local func
  2448.     if type(key) == "function" then
  2449.         func = key
  2450.     else
  2451.         func = function(_, item)
  2452.             if type(item) == "table" then return item[key]
  2453.             else return nil
  2454.             end
  2455.         end
  2456.     end
  2457.  
  2458.     query:groupBy(func)
  2459. end
  2460.  
  2461. -- 查询对象的默认字符串元函数。
  2462. local function __tostring(query)
  2463.     if type(query) == "table" then
  2464.         if not isQuery(query) then
  2465.             query = luaq.iasQuery(query)
  2466.         end
  2467.     else
  2468.         luaq.util.errBadArgValue("__tostring", 1, "查询对象", query, "（不是%s）。")
  2469.     end
  2470.  
  2471.     return mw.dumpObject(query:query())
  2472. end
  2473.  
  2474. function luaq.util.attachLuaq(q, mt)
  2475.     q.asQuery = luaq.asQuery
  2476.     q.select = luaq.select
  2477.     q.selectMany = luaq.selectMany
  2478.     q.selectYield = luaq.selectYield
  2479.     q.where = luaq.where
  2480.     q.count = luaq.count
  2481.     q.any = luaq.any
  2482.     q.all = luaq.all
  2483.     q.groupBy = luaq.groupBy
  2484.     q.orderBy = luaq.orderBy
  2485.     q.thenBy = luaq.thenBy
  2486.     q.distinct = luaq.distinct
  2487.     q.reverse = luaq.reverse
  2488.     q.concat = luaq.concat
  2489.     q.append = luaq.append
  2490.     q.prepend = luaq.prepend
  2491.     q.aggregate = luaq.aggregate
  2492.     q.reserve = luaq.reserve
  2493.     q.duplicate = luaq.duplicate
  2494.     --q.join = luaq.join
  2495.     --q.groupJoin = luaq.groupJoin
  2496.     q.first = luaq.first
  2497.     q.last = luaq.last
  2498.     q.only = luaq.only
  2499.     q.sum = luaq.sum
  2500.     q.average = luaq.average
  2501.     q.max = luaq.max
  2502.     q.min = luaq.min
  2503.     q.sub = luaq.sub
  2504.     q.skip = luaq.skip
  2505.     q.take = luaq.take
  2506.     q.ofType = luaq.ofType
  2507.     q.query = luaq.query
  2508.     q.each = luaq.each
  2509.     q.has = luaq.has
  2510.     --q.union = luaq.union
  2511.     --q.except = luaq.except
  2512.     --q.symmetricExcept = luaq.symmetricExcept
  2513.     --q.intersect = luaq.intersect
  2514.     --q.complement = luaq.complement
  2515.     q.is = luaq.is
  2516.     q.subOf = luaq.subOf
  2517.     q.superOf = luaq.superOf
  2518.     q.properSubOf = luaq.properSubOf
  2519.     q.properSuperOf = luaq.properSuperOf
  2520.     q.overlap = luaq.overlap
  2521.  
  2522.     mt.__add = luaq.union
  2523.     mt.__sub = luaq.except
  2524.     mt.__mul = __mul
  2525.     mt.__div = __div
  2526.     mt.__unm = luaq.reverse
  2527.     mt.__mod = luaq.ofType
  2528.     mt.__power = luaq.join
  2529.     mt.__concat = __concat
  2530.     mt.__eq = luaq.is
  2531.     mt.lt = luaq.properSubOf
  2532.     mt.le = luaq.subOf
  2533.     mt.tostring = __tostring
  2534.  
  2535.     setmetatable(q, mt)
  2536. end
  2537.  
  2538. return luaq
取自“https://moegirl.uk/index.php?title=Module:Luaq&oldid=56109”