Sware: Created page with "local parameters_track_module = "Module:parameters/track" local dump = mw.dumpObject local error = error local format = string.format local pairs = pairs local tostring = tostring local type = type local function track(...) track = require(parameters_track_module) return track(...) end local type_err = 'expected set members to be of type "string" or "number", but saw %s' --[==[ -- Takes `t`, a list or key map which defines a set, and returns a key map for the set (..."

2025-07-10T11:29:56Z

Created page with "local parameters_track_module = "Module:parameters/track" local dump = mw.dumpObject local error = error local format = string.format local pairs = pairs local tostring = tostring local type = type local function track(...) track = require(parameters_track_module) return track(...) end local type_err = 'expected set members to be of type "string" or "number", but saw %s' --[==[ -- Takes `t`, a list or key map which defines a set, and returns a key map for the set (..."

New page

local parameters_track_module = "Module:parameters/track"

local dump = mw.dumpObject
local error = error
local format = string.format
local pairs = pairs
local tostring = tostring
local type = type

local function track(...)
track = require(parameters_track_module)
return track(...)
end

local type_err = 'expected set members to be of type "string" or "number", but saw %s'

--[==[
-- Takes `t`, a list or key map which defines a set, and returns a key map for the set (which might be the original input value).

In addition to distinguishing lists from key maps, this function performs various validation checks:
* Sets may only contain strings and number.
* List inputs must be contiguous arrays, with no keys in use (even if they are non-numbers).
* Key maps are treated as having two different kinds of key:
** If a key's value is boolean {true}, it is a standard key.
** If a key's value is anything else, it is an alias of the specified key (which must not be an alias itself). For instance, if the key {"foo"} is set to {"bar"}, then {"foo"} is an alias of the key {"bar"}, which must be a non-alias key that is also in the key map.]==]
return function(t, name)
-- Iterates over `t` using pairs(), doing separate key map and list parses simultaneously. If the key map parse succeeds, `t` will simply be returned, but if the list parse succeeds, a key map of the values in the list will be returned instead.
-- Lists and key maps are mutually exclusive, as they can be distinguished by the presence of boolean `true` as a value:
-- (1) If `t` is a list, then `true` is an invalid value, because sets may only contain strings and numbers.
-- (2) If `t` is a key map, then it must contain at least one `true` as a value, because any keys which do not have `true` as their value are (by definition) aliases, and aliases must be pointed to a non-alias key (i.e. a key which has the value `true`), which is only possible if one or more keys are set to `true`.
-- (Formally, an empty table could be either, but it's more efficient to treat it as a key map.)
local i, new_map, list_err, map_err, duplicate_in_list = 0
-- The two parses are separated into blocks, which can be skipped on any
-- further iterations if that parse fails.
for k, v in pairs(t) do
local k_type, v_type = type(k)
-- The while-blocks make it possible to use `break` as a substitute for
-- `goto`, and both unconditionally terminate after one iteration.
while not list_err do
-- Catch holes using the same method as [[Module:table/isArray]],
-- but also check for non-number keys.
i = i + 1
if k_type ~= "number" or t[i] == nil then
list_err = "input list is not contiguous"
break
end
-- If `t` is a list then `v` is a set member, so it must be a string
-- or number.
v_type = type(v)
if not (v_type == "string" or v_type == "number") then
list_err = format(
type_err,
v_type == "boolean" and tostring(v) or v_type
)
-- Populate `new_map` with valid keys.
elseif not new_map then
new_map = {[v] = true}
-- If new_map[v] is already set, then `t` has duplicates. This
-- should be tracked, but only if `t` does turn out to be a list, so
-- flag it with `duplicate_in_list` for now.
elseif new_map[v] then
duplicate_in_list = true
else
new_map[v] = true
end
break
end
while not map_err do
-- If `t` is a list then `k` is a set member, so it must be a string
-- or number.
if not (k_type == "string" or k_type == "number") then
map_err = format(
type_err,
k_type == "boolean" and tostring(k) or k_type
)
break
-- If `v` is true, `k` is a non-alias key.
elseif v == true then
break
-- Filter out invalid self-aliases.
elseif k == v then
map_err = format(
"set member %s cannot be an alias of itself",
dump(k)
)
break
elseif not v_type then
v_type = type(v)
end
-- Only possible to be an alias of another key, which must be a
-- string or number.
if not (v_type == "string" or v_type == "number") then
map_err = format(
'expected set key %s have the value true or a value of type "string" or "number", but saw %s',
dump(k), v_type == "boolean" and tostring(v) or v_type
)
break
end
-- Must be an alias of a non-alias, so the value for the key `v`
-- must be `true`.
local main = t[v]
if main ~= true then
map_err = format(
"set member %s is specified as an alias of %s, %s",
dump(k), dump(v), main == nil and "which is not in the set" or "which is also an alias"
)
end
break
end
-- If both parses have failed, throw an error with the two messages.
if list_err and map_err then
error(format(
"Internal error: the `set` spec%s cannot be parsed as either a list or a key map:\nlist parse: %s\nmap parse: %s",
name and format(" for parameter %s", dump(name)) or "", map_err, list_err
))
end
end
-- If `t` can be parsed as a key map, just return it.
if not map_err then
return t
-- Otherwise, `t` is a list, so track duplicate entries if it has been
-- flagged.
elseif duplicate_in_list then
track("duplicate entry in set list")
end
-- Return the new key map.
return new_map
end

Module:parameters/finalizeSet - Revision history