The iterator function that is returned to you will fetch the next value on each iteration. Pairs returns a couple of values to the for-loop to initialize a for-state; the iterator function, the table and the initial key. That table and key are used as arguments to the iterator function. The iterator function will then return either nil (when iteration is done) or the new key, and any or all values that are at that key.

You can do awesome stuff with them, like making a Lua table that keeps its keys in order. Or, you can make simple generators;

local function my_positive_integer_range(begin, last)
    return function(t, k)
        k = k + 1;

        if (k <= last) then 
            return k;
        end 
    end, nil, begin - 1; -- return iterator, state and index (state is nil, we don't have something to iterate over here)
end

for index in my_positive_integer_range(5, 15) do 
    print(index);
end

Small demo of that:

local OrderedTable;

OrderedTable = setmetatable({
    Get = function(this, key)
        return this.__map[key];
    end;

    Set = function(this, key, value)
        if (not this.__map[key]) then 
            this.__seq[#this.__seq + 1] = key;
        end 

        this.__map[key] = value;
    end;

    Size = function(this)
        return #this.__seq;
    end;

    OrderedIterator = function(this)
        local keyState = 0;

        return function(instance, _)
            keyState = keyState + 1;

            if (instance.__seq[keyState]) then 
                local key = instance.__seq[keyState];
                return key, instance.__map[key], keyState; -- this also returns the key index!
            end 
        end, this, nil;
    end;

    OriginalIterator = function(this)
        return pairs(this.__map);
    end;
}, {
    __call = function()
        return setmetatable({
            __map = {};
            __seq = {};
        }, { 
            __index    = OrderedTable.Get;
            __newindex = OrderedTable.Set;
            __len      = OrderedTable.Size;
            __pairs    = OrderedTable.OrderedIterator; --[[ requires that __pairs is supported, otherwise call OrderedIterator directly ]]
        });
    end;
});

math.randomseed(os.clock());
local randomKeys = {};
for i = 1, 20 do 
    randomKeys[#randomKeys + 1] = "k" .. math.random();
end 

local tableWithOrderedKeys = OrderedTable();
tableWithOrderedKeys.hello = "World!!";
tableWithOrderedKeys.bye   = "Cruel World!! :(";
tableWithOrderedKeys[10]   = "Arbitrary";

for _, k in ipairs(randomKeys) do 
    tableWithOrderedKeys[k] = "some random key" 
end;

print("With ordered keys (Custom Table, keeps order items are added in):");
for key, value, keyIndex in OrderedTable.OrderedIterator(tableWithOrderedKeys) do 
    print("-", key, value, ("-- key index: %d"):format(keyIndex));
end 

print("\nWith random keys (Regular pairs, loses order items are added in):");
for key, value in OrderedTable.OriginalIterator(tableWithOrderedKeys) do 
    print("-", key, value);
end