LÖVE

Code: Select all

makeObjects[1] =  coroutine.create( function()
  local prev, last, counter, temp.table = get(first), get(last), 0, { }
  while not finished do
    (add objects to temp.table from database if kind=1 and location are okay)
    if item is last of its kind then
      finished = true 
    else update counter
      if counter = 100 then coroutine.yield() end
    end
  end
  if finished then
    populate live.table with temp.table
    destroy temp.table in case it will be shorter next time
    set next coroutine_sequence to 2 — another type of object from maybe another database
end end)

Code: Select all

function MakeObjectsFactory(inital_inputs)
  local function makeObjects()
    local that = {}
    that.some_inputs = initial_inputs
    function that:next()
      process(that.some_inputs)
    end
    return that
  end
  return makeObjects
end

Code: Select all

local coroutineThatDies = coroutine.create(function ()
    local finished = false
    while not finished do
        local result = doStuff()
        if result == something then
            finished = true
        else
            coroutine.yield(result)
        end
    end
    finishDoingStuff()
    -- I'm dying!
end)

Code: Select all

local coroutineThatLives = coroutine.create(function ()
    while true do
        local finished = false
        while not finished do
            local result = doStuff()
            if result == something then
                finished = true
            else
                coroutine.yield(result)
            end
        end
        finishDoingStuff()
        -- I'm not dying!
    end
end)

Code: Select all

local coroutineThatLives[coNum] = coroutine.create( function ( )
	local count, start, prev, last = 0, 1, 1, dbase_last

	while true do
		local finished = false
		while not finished do

			local v = { get_data(prev) }
			prev = prev + 1				-- set for next resume
			cnt = cnt + 1				  -- yield counter
			if not v or prev > last then	
				finished = 2			   -- no more data or beyond last (a known ref)
			else
				if v[n] validates then
					table.insert ( temp, { v } )
				end
			end
            
			if cnt == 150 then			-- time to yield
				finished = true
			end
            
			if finished then				  -- time to yield or exit
				if finished == 2 then		-- should release data and die
					live = { }			     -- forget old data
					populate live table with temp table values in a loop of paranoia
					temp = { }			     -- ready to rebuild from scratch
					prev = start		      -- we start from here again
					coNum = coNum + 1	    -- next coroutine to call by controller
				end
				count = 0				      -- zero for next resume
				finished = false			  -- IS THIS THE MAGIC ??
				coroutine.yield()		    -- thread resumes after this
			end
		end
	end
end)

Code: Select all

local coroutineThatLives[coNum] = coroutine.create( function ( ) -- just an offhand question, but why do you need multiple coroutines? can't you load the data in with one?
	local count = 0
	local start = 1
	local prev = 1
	local last = dbase_last -- is this a global? why? just pass it in as a parameter.

	while true do -- coroutines "die" two ways, either they finish executing by return-ing, or error-ing. This would ensure than, with you yielding at least once inside, without return statements or errors (unless caught with pcall or xpcall), it will never end.
		local finished = false --the local declaration for this could be moved out of the infinite loop, less constant allocation, though it might not be that big of an issue.
		while not finished do -- This is what actually grinds your data; after this is done, since you wanted the coro to live, it will still run, it just won't do anything.

			local v = get_data(prev)
			prev = prev + 1				-- set for next resume <- what's exactly the purpose of this?
			cnt = cnt + 1				  -- yield counter <- this i can understand
			if not v or prev > last then	
				finished = 2			   -- no more data or beyond last (a known ref) <- why not true?
			else
				if v validates then
					table.insert ( temp, { v } ) -- why are you using a temp table?
				end
			end
            
			if cnt == 150 then			-- time to yield
				finished = true                   -- why not just call coroutine.yield() here (too) ?
			end
            
			if finished then				  -- time to yield or exit
				if finished == 2 then		-- should release data and die <- why not true?
					live = { }			     -- forget old data
					populate live table with temp table values in a loop of paranoia -- wat. why. :|
					temp = { }			     -- ready to rebuild from scratch
					prev = start		      -- we start from here again
					coNum = coNum + 1	    -- next coroutine to call by controller <- again, why more than one coro?
				end
				count = 0				      -- zero for next resume
				finished = false			  -- IS THIS THE MAGIC ?? <- you're already setting finished to false at the start of the infinite loop, that's kinda the point.
				coroutine.yield()		    -- thread resumes after this
			end
		end
	end
end)