A rule for removing (converting) generalized iteration #203

Activity

1. jeparlefrancais

   added

   rule

   on Jun 21, 2024
2. phoriah commented on Nov 28, 2025

   

   phoriah

   on Nov 28, 2025

   Last edited by phoriah

   More actions

   Wouldn't next, be a more elegant solution? Though I guess there would be an issue with string.gmatch for example, as it returns an iterator.
3. jeparlefrancais commented on May 19, 2026

   

   jeparlefrancais

   on May 19, 2026

   Contributor

   More actions

   I think I would go with something that injects this function and then wraps the generic for values. Something like this:

   for k, v in obj do --[[]] end
   -- would become the line below:
   for k, v in iterLuau(obj) do --[[]] end

   And the implementation I would inject would be something like the following snippet, which basically is a lua implementation of the Luau next function. I think the rule could have some kind of strategy field that would be used to tweak the generated iter function. For example it could drop the __iter if someone is sure that the metamethod check is not necessary.

   local function iterLuauTable(...)
   	local totalArgs = select("#", ...)
   
   	if totalArgs ~= 1 then
   		return ...
   	end
   
   	local first = ...
   	local firstType = type(first)
   
   	if firstType == "function" then
   		return ...
   	end
   
   	if firstType == "table" then
   		local function pack(...)
   			return { n = select("#", ...), ... }
   		end
   
   		local getIterSuccess, iterMetamethodResult = pcall(function()
   			return pack(getmetatable(first).__iter(first))
   		end)
   
   		if getIterSuccess and iterMetamethodResult.n > 0 and iterMetamethodResult[1] ~= nil then
   			return unpack(iterMetamethodResult, 1, iterMetamethodResult.n)
   		end
   	end
   
   	local arrayDone = false
   	local previousKey = nil
   	local endRange = 0
   
   	local function customNext(target, index)
   		if arrayDone then
   			if previousKey == nil then
   				return nil
   			else
   				local nextKey, nextValue = next(target, previousKey)
   
   				while type(nextKey) == "number" and nextKey < 1 and nextKey > endRange and nextKey % 1 ~= 0 do
   					nextKey, nextValue = next(target, previousKey)
   				end
   				previousKey = nextKey
   
   				if nextKey == nil then
   					return nil
   				else
   					return nextKey, nextValue
   				end
   			end
   		else
   			local nextIndex = 1 + (index or 0)
   
   			if target[nextIndex] == nil then
   				arrayDone = true
   				local firstNonIndexKey = nil
   				for key, value in next, target do
   					if type(key) ~= "number" or key < 1 or key > endRange or key % 1 ~= 0 then
   						firstNonIndexKey = key
   						break
   					end
   				end
   
   				if firstNonIndexKey == nil then
   					return nil
   				else
   					previousKey = firstNonIndexKey
   					return firstNonIndexKey, target[firstNonIndexKey]
   				end
   			else
   				endRange = nextIndex
   				return nextIndex, target[nextIndex]
   			end
   		end
   	end
   
   	return customNext, first, nil
   end

   👍React with 👍1Reacted by sircfenner
4. sircfenner commented on May 19, 2026

   

   sircfenner

   on May 19, 2026

   Author

   More actions

   I like this! A note on the iterLuauTable implementation - the totalArgs ~= 1 check is too permissive:

   for _ in t, ... do

   is perfectly valid as generalized iteration over table t - the extra values ... are simply not used.
5. jeparlefrancais commented on May 21, 2026

   

   jeparlefrancais

   on May 21, 2026

   Contributor

   More actions

   That is true, I'll make sure to remove that. Now the remaining thing to figure out is where to dump a unique file to hold this function instead of duplicating it at the top of each file that uses a for loop.
6. phoriah commented on May 22, 2026

   

   phoriah

   on May 22, 2026

   More actions

   That is true, I'll make sure to remove that. Now the remaining thing to figure out is where to dump a unique file to hold this function instead of duplicating it at the top of each file that uses a for loop.

   I'd personally prefer it having on top of each file rather than having to commit an extra file that serves one specific purpose. Separation of concerns
7. phoriah commented on Jul 29, 2026

   

   phoriah

   on Jul 29, 2026

   More actions

   Also k == math.floor(k) might be faster than the modulo check