🚀 go-pugleaf

There are restrictions on the allowed return type of operator->().  Where
should they be enforced?  I think they should be enforced at the call site,
not the declaration, at least when templates are involved.
   Chapter and verse: the ARM, section 13.4.6, "Class Member Access" says
"it follows that operator->() must return either a pointer to a class or an
object of or a reference to a class for which operator->() is defined."
So the following is illegal:

    struct s {
	int operator->();	// cfront 2.1 complains about this line.
	};
    void f() {
	s an_s;
	s->m;			// g++ 1.37.1 complains about this line.
	}

I think the g++ behaviour is "more standard", because s. 13.4.6 is about
"->" expressions, not declarations.  In other words, the sentence means "it
follows that the result of a -> expression must be either..."  (There is
also the statement near the top of p. 331: "Note that--except for operator
new() and operator delete()--there are no restrictions on the return types
of overloaded operators."  But that statement is in an annotation, so it
doesn't really count.)

The g++ "illegal when called" approach makes it easier to write template
classes that define operator->().  Consider a template for a Set class that
contains copies of values as opposed to pointers to objects.  Set comes
with a companion Generator class.  Generators act like constant objects of
a set's element type.  They take on each of the values in a set in turn,
and are used as loop indices.

    template<class Elt> class Set;
    template<class Elt> class Generator { ...
      public:
	           operator Elt();	// Copy the current value.
	const Elt  operator->();	// Member access through current value.
	void       in(Set<Elt>&);	// Begin generating values.
	friend int more(Generator);	// Are there more values?
	friend void next(Generator&);	// Go get the next value.
	};
    Set<int>       si;
    Generator<int> gi;
    int            sum_sq = 0;
    for (gi.in(si); more(gi); next(gi)) // for every element in si ...
        sum_sq += gi*gi;                // Conversion via operator Elt().

Generator has an operator->() in case Elt is a pointer to a class. 

    class Employee { ... };
    Set<Employee*>	 se;
    Generator<Employee*> ge;
    for (ge.in(se); more(ge); next(ge)) // for every element in se ...
	cout << ge->name << ge->department;

However, a compile-time error message should be generated if operator->()
is applied to a Generator<int>.  If the rules about result types are
enforced when operator->() is used, then an error will be reported if
_and_only_if_ "->" is applied to a Generator<int>.  If the rules are
enforced when operator->() is declared, then either the template or the
instantiation Generator<int> will produce an error, and this Generator
approach must be abandoned.

    Glen Ditchfield  gjditchfield@violet.uwaterloo.ca  Office: DC 2517
Dept. of Computer Science, U of Waterloo, Waterloo, Ontario, Canada, N2L 3G1
	      These opinions have not been tested on animals.