Re: Subverting 'Access for Sub-programs

[Brian Rogoff <bpr@shell5.ba.best.com>]

On Fri, 6 Aug 1999, Robert A Duff wrote:
> Robert Dewar <robert_dewar@my-deja.com> writes:
> 
> > Well this has been dealt with in length in previous threads,
> > so it is not appropriate to repeat it, but briefly, an extension
> > of a tagged type with new overriding primitives clearly
> > generates the possibility of dispatching to these new
> > primitives. If you allow extension in a smaller scope, you
> > can obviously generate dangling pointers for these methods,
> > using class variables whose value is the inner derived type.
> > It would thus be unsafe to allow this extension.
> 
> Tucker and I discussed a design for allowing nested type extensions for
> *limited* types, which would have prevented the dangling pointer issues.
> I don't remember if we ever formally proposed this idea in public, or if
> we killed it ourselves before it was seen by any reviewers.  I think it
> involved a lot of implementation burden, and I have vague recollections
> of worrying about the mob of generic-body-sharing compiler writers we
> would have had to flee from...

Where have people found the inability to do nested type extensions
annoying, besides cases where you're using tagged types to simulate 
downward funargs? I have wanted them when trying to work around the lack
of downward funargs, but otherwise their omission hasn't been a big burden 
to me. Are there some compelling examples that I just haven't run across? 

I suspect that a downward funarg solution would handle most cases where a 
nested type extension was desired, provided the original tagged type 
provided for this possibility by having some primitive subprograms with
access to subprogram args.

> Another idea, which was never seriously considered, would be to allow
> nested type extensions, and then check at run time upon leaving a scope
> that there are no objects with that 'Tag still in existence.  That
> design could be made to work, but there are plenty of problems with it.

So, only allow this for descendants of (possibly limited) Controlled
types, or some similar special type?

-- Brian