Functions in a Table - Lua

Question

I have a table that has multiple functions in it. I'm trying to write a single function that will go through and use all the functions by passing random information into it.

Methods = {}

insert functions into Methods Table

function Methods:Multi() if #self > 0 then .........................

I'm guessing i need a loop that goes through the entire table but I can't do #self because i need it to do each function multiple times. Not sure how to pass in random info to the function either. Any help would be appreciated

Answer 1

Your problem doesn't seem to be all that specific - you're likely going to need to define exactly what you want to happen in more detail in order to be able to implement a program for it. (Sort of like if you told me "I need a program that calculates a number" - I'd probably respond "okay, what number do you want it to calculate?"

Things to consider:

1. Exactly how many times do you want to call each function? Will this be the same for each function? Will it vary?
2. If the number of calls varies, what should determine this?
3. How exactly do you want to determine what parameters are passed? Their types/count? Their values?

A very basic starting framework might look like this:

Methods = {}

-- Insert functions into Methods table

for _,func in ipairs(Methods) do
    for i=1,5 do
        func()
    end
end

which would call each function 5 times, albeit w/o arguments.

Answer 2

I modified the above suggestion to

function CallFuncs(times, funcs, ...)
    while (times > 0) do
        for _, func in pairs(funcs) do
            func(...)
        end
        times = times - 1
    end
end

Example usage:

t = {
    function( n ) print( n ) end,
    function( n ) print( #n ) end,
}

CallFuncs( 2, t, 'foo' )

yields

foo
3
foo
3

Answer 3

Try this:

function CallFuncs(times, funcs, ...)
    for i=1,times do
        for _, func in pairs(funcs) do
            if type(...) == "table" then func(unpack(...)) else func(...) end
        end
    end
end

Usage:

local t = {
    function(n) print(n) end,
    function(n) print(n+1) end,
    function(n) print(n+2) end
}

CallFuncs(3, t, 2)

This assumes all the functions in the table have more or less the same arguments.

Info: The ... you see is lua's syntax for variable arguments (these are packed into a table and used as the last argument to the function), and the unpack function takes a table and multi-returns a series of values.

Answer 4

If you are asking for something to call a list of functions, I just typed this very small module for you (if you can even call it that).

-- No guarantees whether this will work.
function ExecFunc (fnctn,nTimes,Threaded,...)
    local to_call = function ()
        fnctn(...)
    end
    for x = 1,nTimes do
        if Threaded then
            coroutine.resume(coroutine.create(to_call))
        else
            to_call()
        end
    end
end
function ExecFuncs (Async,...)
    -- All parts of ... should be tables {function f, number t[, table args]}
    local funcInfo = {...}
    for _,funcThing in pairs(funcInfo) do
        local a = funcThing.args
        if a then
            ExecFunc(funcThing.f,funcThing.t,Async,unpack(a))
        else
            ExecFunc(funcThing.f,funcThing.t,Async)
        end
    end
end
-- These don't check for argument validity,
-- so you should either be careful with the arguments
-- or call these in protected mode (with pcall).

If I wasted my time with that, it was fun anyway, but after typing it I reread your question... You want something to iterate through a list of functions and pass a random number to each one.

function ExecuteWithRandomValues (func_list,async)
    assert(type(func_list) == "table","Expected table.")
    local passbacks = {}
    local threads
    if async then
        threads = {}
    end
    for _,func in pairs(func_list) do
        assert(type(func) == "function","Value [" .. _ .. "] is not a function.")
        local toCall = function ()
            local rnd = math.random(-math.huge,math.huge)
            local out = func(rnd)
            passbacks[_] = {input = rnd, output = out}
        end
        if async then
            table.insert(threads,coroutine.create(toCall))
        else
            toCall()
        end
    end
    if async then
        for _,thread in pairs(threads) do
            coroutine.resume(thread)
        end
        for _,thread in pairs(threads) do
            while coroutine.status(thread) ~= "dead" do
            end
        end
    end
    return passbacks
end
-- Again, no guarantees this thing is free of errors.
-- There are better ways to run and check the statuses
-- of asynchronous threads, but this is fairly convenient.