Re: "Subtract C, add Ada"

[ncohen@watson.ibm.com (Norman H. Cohen)]

|> Real iterations in real problems come in many forms.  You need a
|> user-progammable construction that goes straight to the problem.
|> C++ types 'iterators' are a good first step, but I don't feel
|> super comfortable with them.  What I think is even better is
|> Sather's "iters".  Instead of arguing over silly little details
|> of various Pascal or C control structures or whatever their trivial
|> variations, we should desire something much better and powerful among
|> all the inventions that have been occured over the last 20 years.

I think CLU, circa 1979, still holds the prize for the best iteration
abstraction.  When defining a CLU abstract data type that represents some
sort of collection, you can define one or more iterators among its
operations.  An iterator is like a procedure declared to take a value of
the collection type as a parameter and to "yield" values of some element
type.  The iterator is executed as a coroutine during the execution of
the loop.  Values that are yielded by the iterator become the values of
the loop parameter on successive iterations of the loop.

My CLU syntax is rusty, but if you have the equivalent of a private type
for doubly linked lists, you could define the following iterators for it: 

   elements =
      iter(l: list_type) yields (element_type)
         next: cell_type = l;
         while next.forward_link ~= l do
            yield(next.item)
         end
      end

   reverse_elements =
      iter(l: list_type) yields (element_type)
         next: cell_type = l;
         while next.backward_link ~= l do
            yield(next.item)
         end
      end

Then you could iterate over the private type as follows: 

   for item in elements(my_list) do
      ...
   end

   for item in reverse_elements(my_list) do
      ...
   end

Iterators could even be recursive: 

   preorder_traversal =
      iter(t: tree_type) yields node_info_type
         yield(t.node_info);
         for ni in preorder_traversal(t.left_subtree) do
            yield(ni)
         end
         for ni in preorder_traversal(t.right_subtree) do
            yield(ni)
         end
      end

(Breaking out of a loop terminates the iterator.  Since CLU supported
exceptions, I think it would have been better for the next yield
statement to have raised an exception inside the iterator, thus giving
the iterator the opportunity to perform cleanup actions.)

--
Norman H. Cohen    ncohen@watson.ibm.com