Re: Passing indefinite types

[sbelmont700@gmail.com]

I had pretty much resigned myself to using the heap anyhow, this was mostly just out of curiosity as to whether it could be done or not.  It seems a shame that it cannot, since there are already mechanisms to safely pass local access values to longer-lived subprograms, so long as their are by themselves or within records.  An array seems like the logical next step.

But in the interests of proving it can actually be done, here is my best take on it: a (completly unreadable) linked list of access-discriminanted records, where the callee would presumably iterate through them as needed.  This would work for limited types, too, whereas (most of?) the normal containers would not.


package k is

   type String_Holder (s : not null access string) is null record;
   
   type Node;
   type Node_Holder (n : not null access Node) is null record;

   type Node (string_data : not null access String_Holder;
              next_node   : access Node_Holder) is null record;
              
   function find (pattern : string;
                  sources : Node) return boolean;
                   
end k;

procedure p is

  s1   : aliased string := "One thing";
  s2   : aliased string := "another thing";
  s3   : aliased string := "third thing";
  
  s1_h : aliased k.string_holder := (s => s1'access);
  s2_h : aliased k.string_holder := (s => s2'access);
  s3_h : aliased k.string_holder := (s => s3'access);

  n3   : aliased k.node := (s3_h'access, null);
  n3_h : aliased k.node_holder := (n => n3'access);
  
  n2   : aliased k.node := (s2_h'access, n3_h'access);
  n2_h : aliased k.node_holder := (n => n2'access);
  
  n1   : k.node := (s1_h'access, n2_h'access);
  
  x : boolean := k.find ("look ma, no heap!", n1);

begin
  null;
end;

Thanks again to everyone for their suggestions.

-sb