Re: Function at line ### has more than 60 upvalues

["Mark Meijer" <meijer78@...>]

Ack, I take it back: Eric's solution is a bit different because it
doesn't use local functions (don't know why). Sorry for the noise.

2008/8/21 Mark Meijer <meijer78@gmail.com>:
> Btw. this is equivalent to Eric Tetz's solution, I believe. Except
> without the shallow copying (why was that in there?)
>
> 2008/8/21 Mark Meijer <meijer78@gmail.com>:
>> You could simply move the table construction outside of the factory
>> function, to the same scope as the local functions:
>>
>> local factory
>> do
>>  local method1 = function(self)
>>   print("method1", tostring(self))
>>  end
>>
>>  local method2 = function(self)
>>   print("method2", tostring(self))
>>  end
>>
>>  local methodN = function(self)
>>   print("methodN", tostring(self))
>>  end
>>
>>  local interface = {
>>   method1 = method1;
>>   method2 = method2;
>>   --...
>>   methodN = methodN;
>>  }
>>  factory = function()
>>   return interface;
>>  end
>> end
>>
>> This way the functions are not upvalues to the scope where you create
>> the interface table. They're just locals. The added advantage is that,
>> if any of those functions calls any of the other functions, the called
>> function IS an upvalue to the calling function, and therefore the call
>> will be more efficient (because it does not require a table lookup).
>> Furthermore, this is only a small change to your existing code, a nice
>> workaround until you have time to refactor ;-)
>>
>> Hope this helps (and hope I'm right, from the top of my head...)
>>
>> Cheers,
>> Mark
>>
>>
>> 2008/8/21 Javier Guerra <javier@guerrag.com>:
>>> On Thu, Aug 21, 2008 at 1:25 PM, Alexander Gladysh <agladysh@gmail.com> wrote:
>>>> One of my most ugly objects now have more than 60 methods (yes, I
>>>> know, I should refactor this abomination out immediately, but I just
>>>> do not have time for it yet).
>>>
>>> put all methods in a separate file, prepend them with a module().
>>> when you require() that file, you'll get a table with all non-local
>>> functions.
>>>
>>> what module() does is mainly creating a new table, and setting it as
>>> the environment.  after that, all non-local functions will populate
>>> that table instead of the original _G.
>>>
>>> i've done this when i want a table with functions and don't want to
>>> write something like:
>>>
>>> t = {
>>>  f1=function(...) ... end,
>>>  f2=function(..)  ... end,
>>> .....
>>> }
>>>
>>> with module() it's just
>>>
>>> module()
>>>
>>> function f1 (...)
>>>  .....
>>> end
>>>
>>> function f2 (...)
>>>  .....
>>> end
>>>
>>>
>>> i really want to like the first option, since i know it's the most
>>> 'functional', but the second one is a lot nicer to the eye, and using
>>> module(), any non-local value gets stuffed into my table, so it works
>>> great.
>>>
>>> --
>>> Javier
>>>
>>
>