🚀 go-pugleaf

In article <70904@microsoft.UUCP> jimad@microsoft.UUCP (Jim ADCOCK) writes:
>Does anyone know what happened to consideration of overloadable operator dot?

We can only hope that people realized that it was a horrible idea, and
that it then died a quiet and lonely death.

-- 

// Ron Guilmette  -  C++ Entomologist
// Internet: rfg@ncd.com      uucp: ...uunet!lupine!rfg
// New motto:  If it ain't broke, try using a bigger hammer.

In article <4327@lupine.NCD.COM>, rfg@NCD.COM (Ron Guilmette) writes:
|> In article <70904@microsoft.UUCP> jimad@microsoft.UUCP (Jim ADCOCK) writes:
|> >Does anyone know what happened to consideration of overloadable operator dot?
|> 
|> We can only hope that people realized that it was a horrible idea, and
|> that it then died a quiet and lonely death.

Well, Ron, educate me.  Why is it a horrible idea?  I claim that, for
many problems, a "smart reference" object is superior to a "smart pointer"
object.

--
Joe Buck
jbuck@galileo.berkeley.edu	 {uunet,ucbvax}!galileo.berkeley.edu!jbuck	

In article <12036@pasteur.Berkeley.EDU> jbuck@galileo.berkeley.edu (Joe Buck) writes:
+In article <4327@lupine.NCD.COM>, rfg@NCD.COM (Ron Guilmette) writes:
+|> In article <70904@microsoft.UUCP> jimad@microsoft.UUCP (Jim ADCOCK) writes:
+|> >Does anyone know what happened to consideration of overloadable operator dot?
+|> 
+|> We can only hope that people realized that it was a horrible idea, and
+|> that it then died a quiet and lonely death.
+
+Well, Ron, educate me.  Why is it a horrible idea?  I claim that, for
+many problems, a "smart reference" object is superior to a "smart pointer"
+object.

First off, the idea of overloading "." is horrible because "." is not
an operator.

Even if it were an operator (which it obviously isn't) there is no
evidence (that I have seen) that "smart references" add significantly
to the expressive power of the language.  I can imagine that they
might allow you to avoid having to type in the occasional `*' (to
dereference a "smart pointer") but that seems like an awfully small
gain when measured against the added complexity in the language.

Remember that each additional increment of complexity has to be paid for
many times over, both when people who are new to the language are
attempting to learn it, and when people who are implementing the
language are doing what they do.
-- 

// Ron ("Shoot From The Hip") Guilmette
// Internet: rfg@ncd.com      uucp: ...uunet!lupine!rfg
// New motto:  If it ain't broke, try using a bigger hammer.

In article <4627@lupine.NCD.COM> rfg@NCD.COM (Ron Guilmette) writes:
|First off, the idea of overloading "." is horrible because "." is not
|an operator.
|
|Even if it were an operator (which it obviously isn't)  ....

ARM page 330:

"The following operators cannot be overloaded:
	. 	.*	::	?: "


Ron is attempting to use naming convention to argue his case.  He 
insists that . cannot be called an "operator" [even though that is how 
ARM and the working papers refer to it] and then uses his refusal to
accept the name "operator" as justification for not allowing it to
be overloaded.  I disagree that such attempts to argue via 
naming conventions have anything to do with whether or not operator
dot should be overloaded.