On Feb 21, 2015, at 12:42 AM, Chris Angelico <ros...@gmail.com> wrote:

> On Sat, Feb 21, 2015 at 1:44 PM, Cem Karan <cfkar...@gmail.com> wrote:
>> In order to inform users that certain bits of state have changed, I require 
>> them to register a callback with my code.  The problem is that when I store 
>> these callbacks, it naturally creates a strong reference to the objects, 
>> which means that if they are deleted without unregistering themselves first, 
>> my code will keep the callbacks alive.  Since this could lead to really 
>> weird and nasty situations, I would like to store all the callbacks in a 
>> WeakSet (https://docs.python.org/3/library/weakref.html#weakref.WeakSet).  
>> That way, my code isn't the reason why the objects are kept alive, and if 
>> they are no longer alive, they are automatically removed from the WeakSet, 
>> preventing me from accidentally calling them when they are dead.  My 
>> question is simple; is this a good design?  If not, why not?  Are there any 
>> potential 'gotchas' I should be worried about?
>> 
> 
> No, it's not. I would advise using strong references - if the callback
> is a closure, for instance, you need to hang onto it, because there
> are unlikely to be any other references to it. If I register a
> callback with you, I expect it to be called; I expect, in fact, that
> that *will* keep my object alive.

OK, so it would violate the principle of least surprise for you.  Interesting.  
Is this a general pattern in python?  That is, callbacks are owned by what they 
are registered with?

In the end, I want to make a library that offers as few surprises to the user 
as possible, and no matter how I think about callbacks, they are surprising to 
me.  If callbacks are strongly-held, then calling 'del foo' on a callable 
object may not make it go away, which can lead to weird and nasty situations.  
Weakly-held callbacks mean that I (as the programmer), know that objects will 
go away after the next garbage collection (see Frank's earlier message), so I 
don't get 'dead' callbacks coming back from the grave to haunt me.

So, what's the consensus on the list, strongly-held callbacks, or weakly-held 
ones?

Thanks,
Cem Karan
-- 
https://mail.python.org/mailman/listinfo/python-list

Reply via email to