A Lua newbie here. Can I store function references as keys in a Lua Table? Something similar to this:
local fn = function() print('hello') end
local my_table = {}
my_table[fn] = 123
This does seem to work fine but I don't know if I can rely on the uniqueness of the function references. Can Lua reuse function references once they are out of scope? Can this create any issues or is it considered a bad practice due to some reason?
Yeah. One of the best things I've encountered in lua is the anything as references property.
There's nothing wrong with the way you are using your keys in the table.
Tables in Lua are neither values nor variables; they are objects.You may think of a table as a dynamically allocated object; your program only manipulates references (or pointers) to them. There are no hidden copies or creation of new tables behind the scenes.
In your example, you haven't passed any argument to the function, so basically, it'll be useless in your case to have functions as reference in the program. On the other hand, something like this:
fn1 = function(x) print(x) end
fn2 = function(x) print("bar") end
t[fn1] = "foo"
t[fn2] = "foo"
for i, v in pairs(t) do i(v) end
does have its uses.
Can Lua reuse function references once they are out of scope?
As long as your parent table is in scope, yes. Since tables are created and manipulated but not copied, so there isn't a chance that your function reference can be deprecated from the table index memory. I'll edit this answer later after trying it out actually too.
Can this create any issues or is it considered a bad practice due to some reason?
It's just considered a bad practise because users familiar with other languages, like C, python etc. tend to have array in mind when reading tables. In lua you have no such worries, and the program will work perfect.
I don't know if I can rely on the uniqueness of the function references.
Why?
The uniqueness of the function references depends on Lua version.
Lua 5.2 manual says:
a function definition may not create a new value; it may reuse some previous value if there is no observable difference to the new function
Example:
-- 10 different function references on Lua 5.1
-- The same function reference for Lua 5.2
local j
for i = 1, 10 do
print(function() print(j) end)
end
-- 10 different function references for any Lua version
for i = 1, 10 do
print(function() print(i) end)
end
So, the rule is: create different closures to get different references.
You can do that, function will remain in the same place of memory until it is destroyed (by garbage collector).
You can try in interactive lua:
> fn = function() print('hello') end
> print(fn)
function: 0x9d058d0
> fn2 = function() print('hello') end
> print(fn2)
function: 0x9d05ee8
> fn2=fn
> print(fn2)
function: 0x9d058d0
> print(function() print('hello') end)
function: 0x9d068a8
> print(function() print('hello') end)
function: 0x9d06bf8
Remember that if fn is local it'll be garbage collected when goes out of scope. In your case it shouldn't be a problem as my_table is local in the same block. See Lua documentation on local variables.
This does seem to work fine but I don't know if I can rely on the uniqueness of the function references.
Every function() end statement creates a new closure. The actually code of a function will be reused if it comes from the same constructor:
for i=1,100 do
t[function() print(i) end] = i -- this function body will be reused
end
But each closure will be unique, and that's what matters for your reference.
Can Lua reuse function references once they are out of scope?
Lua's not going to collect fn as long as it's used as a key in my_table. If my_table goes out of scope, too, such that both table and function get collected, then Lua reusing the reference wouldn't affect you. So either way, you're good.
