🚀 go-pugleaf

Bill Wolfe writes:

> OK, first let me clarify my position.  The primary use for pointers
> is simply to implement abstract data types -- lists, trees, graphs, etc.;
> by shielding the user from the details of implementation, we can keep
> the user from having to worry about manipulating pointers.

Frankly, I can't see how this is possible.  Suppose I have an ADT 'A'
that has a generator operation NEW and a destructor function DISPOSE.
Suppose I want a generic ADT LIST[t: type] that can be used in the
following way.

a: A
aa: A

  while true do
    a := A$NEW(...)
    aa := A$NEW(...)
    
    l: LIST[A] := LIST[A]$MAKE_EMPTY()
  
    LIST[A]$INSERT(l, a)
    LIST[A]$INSERT(l, A$NEW(...))
    LIST[A]$INSERT(l, a)
    
    aa := LIST[A]$REMOVE_HEAD(l)
    
    etc
    
  end while
  
  
The generation of instances of A must be under the control of the 
application and assignment of A must be handled.  I must be able to
put an A instance into a list any number of times.

How do I implement the LIST ADT so that it invokes the A$DISPOSE
operation at the right time?  When is the right time?  What happens
if I want to put an instance of A into 2 LIST's at the same time?