On 05.10.2006 01:18, Gavin Kistner wrote:
> Because I just had to solve this problem in both JavaScript and Lua, and
> because I love Ruby more than either, I thought I'd ask people here how
> they'd solve it in Ruby.
> 
> The general question is: how would do you associate a few object
> instances with methods on a per-method basis?
>  
> The Situation/Requirements
> --------------------------
> A class has 2 different methods.
> Each method needs a couple 'scratch' objects to perform its
> calculations.
> The methods call each other; they must not use the same scratch objects.
> It is expensive to instantiate a scratch object.
> It's not expensive to initialize an existing scratch object with data.
> We like OOP coding, and want to call these as methods of a receiver.
> 
> Wasteful Example:
> class Foo
>   def c1
>     tmp1 = ExpensiveObject.new
>     tmp2 = ExpensiveObject.new
>     # stuff involving tmp1/tmp2
>     result = tmp1 + tmp2 + c2
>   end
>   def c2
>     tmp1 = ExpensiveObject.new
>     tmp2 = ExpensiveObject.new
>     # stuff involving tmp1/tmp2
>     result = tmp1 + tmp2
>   end
> end

I can think of several solutions.

1. Use command pattern, i.e., distribute method c1 and c2 to different 
classes (i.e. a class per method), make your local variables instance 
variables and reuse instances of these command classes.  If you have 
common behavior or state you can even use a common base class or a Module.

2. Use factory with a pool to create and release objects whose creation 
is expensive.  The factory can reside at class level.  Gotcha: if you do 
multithreading you have to make sure the factory deals properly with that.

Note, both approaches work with pretty much every OO language and do not 
need any kind of fancy environment changes or closures.

Kind regards

	robert