RFC: Proposal: Deterministic Object Destruction
Rick Johnson
rantingrickjohnson at gmail.com
Thu Mar 1 18:58:48 EST 2018
On Wednesday, February 28, 2018 at 10:26:26 PM UTC-6, Steven D'Aprano wrote:
> On Wed, 28 Feb 2018 18:46:05 -0800, Rick Johnson wrote:
>
> > On Wednesday, February 28, 2018 at 5:02:17 PM UTC-6, Chris Angelico
> > wrote:
> >
> >> Here's one example: reference cycles. When do they get detected? Taking
> >> a really simple situation:
> >>
> >> class Foo:
> >> def __init__(self):
> >> self.self = self
> >
> > *shudders*
> >
> > Can you provide a real world example in which you need an object which
> > circularly references _itself_? This looks like a highly contrived
> > example used to (1) merely win the argument, and (2) Bump fib() up one
> > position from it's current position as "the worst introductory example
> > of how to write a function in the history of programming tutorials"
>
>
> Of course it is a contrived example: it is close to the
> simplest possible example of a reference cycle. Its not
> intended as an example of useful code.
I support your appeal to simplicity, but surely you will
admit that circular references (CR) of this type are
extremely rare. The most common usage of CR is the node
tree.
> (Useful or not, your interpreter better not crash when
> faced with a cycle like this.)
Well, if you want your language to have CR as a feature,
then yes. Some folks believe that CRs are evil. But i'm not
one of those people. I believe CRs are useful in some
specific cases. But a programmer must use them wisely.
> But of course there are uses for objects to hold a
> reference to themselves. If you're writing a general
> purpose collection (say, a list or dict) then you better be
> able to cope with the case that somebody puts your list in
> itself:
>
> L = []
> L.append(L)
>
> either directly, as above, or indirectly.
A good example. And one that is easy to overlook.
> And that's the point really: cycles don't just occur when
> an object holds a reference to itself. They occur when one
> object holds a reference to another object, which holds a
> reference to a third, which holds a reference to a fourth
> (and so on...), which eventually holds a reference to the
> original again.
>
> Cycles are useful. For example, you might think of a window
> which holds a reference to a control, which in turn needs a
> reference to its owning window. Or a network which contains
> loops, say a network of streets, or networks of disease
> transmission [...]
Agreed.
I don't buy into the religion that _all_ CRs are evil. Those
who make such claims are dealing in absolutes. And as Obi-
wan warned Anakin, only a Sith deals in absolutes. ;-)
More information about the Python-list
mailing list