local function or object:Function, what to pick?

[zork]

Is there any major benefit of using one over the other?

I asked this in another thread lately and Phanx posted the prototype trick which is kind of neat.

local function variant

local function ResetAllModels() 
    for i, model in pairs(self.models) do
      ModelReset(model)
    end
  end    
    
  local function ModelReset(...)
    print("ModelReset",...)
  end
  
  local function ModelOnMouseDown(...)
    print("ModelOnMouseDown",...)
  end
  
  local function ModelOnMouseUp(...)
    print("ModelOnMouseUp",...)
  end
  
  local function CreateModel(parent,id)
    local m = CreateFrame("PlayerModel", nil, parent)
    m.id = id
    m.name = "model"..id
    m:SetScript("OnMouseDown", ModelOnMouseDown)
    m:SetScript("OnMouseUp", ModelOnMouseUp)
  end
  
  
  local frame = CreateFrame("Frame")
 
  frame.models = {}
  
  for i=1, 50 do
    frame.models[i] = CreateModel(frame,i)
  end

object:Function variant

local frame = CreateFrame("Frame")
    
  function frame:ResetAllModels 
    for i, model in pairs(self.models) do
      model:Reset()
    end
  end    
    
  frame.models = {}
  
  --prototype
  frame.modelPrototype = {}
 
  function modelPrototype:Reset(...)
    print("Reset",...)
  end
  
  function modelPrototype:OnMouseDown(...)
    print("OnMouseDown",...)
  end
  
  function modelPrototype:OnMouseUp(...)
    print("OnMouseUp",...)
  end
  
  function frame:CreateModel(id)
    local m = CreateFrame("PlayerModel", nil, self)
    m.id = id
    m.name = "model"..id
    for k, v in pairs(self.modelPrototype) do
      m[k] = v
    end
    m:SetScript("OnMouseDown", m.OnMouseDown)
    m:SetScript("OnMouseUp", m.OnMouseUp)
  end  
  
  for i=1, 50 do
    frame.models[i] = frame:CreateModel(i)
  end

What I'm asking for is the following. If I add a function to an object...does it produce multiple copies of that function or is it by reference?

Using a local function set has the benefit that the function is only defined once but most of the time you need to add self as an argument which you do not need on object functions.

Well...event handler functions will still use self as an argument.

What do you pick and why?

[p3lim]

frame.models[i] = frame:CreateModel(i)

That right there is a reference.

I pick whatever suits the project, sometimes I use a frame with methods, mostly I do local functions.
It really depends if I want it for the sake of wanting it, or when I want them accessible outside of the local scope (as by reference to the global name of the frame(s))

[Vlad]

local function requires that you have it defined before you use it - and it might be a bit difficult if you call functions regardless of order of definition. The bonus when using an object is the order doesn't mater, hurray! Though there are other down sides, I find this upside good enough for most addons.

[Sharparam]

You can get around the "not defined" issue by forward-declaring functions:

local b
 
local function a() b() end
 
function b() print 'foo' end

[SDPhantom]

When you get right down to it, performance-wise, defining a function as a local will reference it immediately upon calling. Calling a function as a method (table:func()) causes an indexing operation on table to find func() in order to call it. As such, declaring a function as a method takes slightly longer to call than a function declared as a local.

[zork]

Will the following return the same result/performance?
How does it differ?

Prototype

--prototype
  local modelPrototype = {}
 
  function modelPrototype:Reset(...)
    print("Reset",...)
  end
 
  local function CreateModel(id)
    local m = CreateFrame("PlayerModel")
    for k, v in pairs(modelPrototype) do
      m[k] = v
    end
  end  
 
  for i=1, 50 do
    CreateModel(i)
  end

Adding the :Reset() function onto each object.

local function CreateModel(id)
    local m = CreateFrame("PlayerModel")
    function m:Reset(...)
      print("Reset",...)
    end
  end  
 
  for i=1, 50 do
    CreateModel(i)
  end

I assume that the later adds individual functions on each object while the prototype example reuses the function. Is that correct? That would make the latter bad if you need to generate alot of objects with alot of functions. Right?

[SDPhantom]

In order to do that efficiently and if you need the function as a method, I would suggest the following trick I usually do when I need an upvalue to exist only to a select group of functions. Technicly, this is the prototype method using scope as an isolator.

local CreateModel;--    Function Prototype
do--    New scope for function-specific upvalues
    local function Reset(self,...)
        print("Reset",...);
    end
 
    function CreateModel(id)--  This writes to the local defined outside our do scope
        local m=CreateFrame("PlayerModel");
        m.Reset=Reset;
    end
end
 
for i=1, 50 do
    CreateModel(i);
end

This is tricky, but works. Reset() is defined so that it's only visible to CreateModel() because both are defined in the do...end scope. Because CreateModel() is an upvalue from the do...end scope, that function remains visible to the rest of the code. Since Reset() is only referenced and no longer dynamically created, all models created by CreateModel() will reference the same singular function.



To answer your question directly, with the way both code is generated, they're both assigning the function as methods and the only real difference this time is how you're assigning them to the model's table. The first one is iterating through a table and creating references to your functions, the second one is wasting memory by dynamically creating functions for each model created. This is all about the performance of the model factory and not really the performance of calling a function or calling a method.

[Phanx]

The reason I suggested using a "prototype" (which is just a convention, Lua doesn't actually care what you call the table, and doesn't treat it specially at all) instead of a bunch of local functions was because it's easier to do this:

for k, v in pairs(prototype) do
    obj[k] = v
end

than this:

obj.DoSomething = DoSomething
obj.DoSomethingElse = DoSomethingElse
obj.Cats = Cats
obj.CatsEverywhere = CatsEverywhere
obj.UpdateAllTheThings = UpdateAllTheThings
obj.Over9000Cats = Over9000Cats
obj.Yawn = Yawn
obj.OMGWhereDoesItEnd = OMGWhereDoesItEnd
obj.SoMuchTyping = SoMuchTyping
obj.DoNotWant = DoNotWant

It's easier to write, easier to read, easier to understand at a glance, and easier to maintain -- if you want to add, remove, or rename methods in the future, you just change the methods; you don't have to also change the list of function assignments.

But you seem to actually be asking why I suggested this:

local function DoSomething(self)
    print("I'm doing something!")
end

local function MakeAThing()
    local thing = CreateFrame("Frame")
    thing.DoSomething = DoSomething
    return thing

over this:

local function MakeAThing()
    local thing = CreateFrame("Frame")
    function thing:DoSomething()
        print("I'm doing something"!)
    end
    return thing
end

... and the reason is that the second way is a total waste of memory. There's absolutely no reason to create more than one copy of the same function. You can attach it to as many objects as you want, call it from as many different places as you want, as many times as you want, etc. but only one copy of it needs to exist.

[zork]

Thanks you two. That was exactly what I wanted to know.