• Ender KaShae (1/1) Jul 20 2007 there should be some way to define implicit casts either to or from user...
• BCS (25/31) Jul 20 2007 this would also simplify some things like what is described here:
• janderson (5/6) Jul 21 2007 C++ has the copy constructor. Perhaps it should be something along
• James Dennett (6/16) Jul 21 2007 C++ _copy_ constructors are used for copying, not converting.

Ender KaShae <astrothayne gmail.com> writes:

there should be some way to define implicit casts either to or from user
defined types.  this would greatly reduce the amount of code since functions
would no longer have to be overloaded for as many times. ex: a fraction class
does not need to overload opAdd since integers can be implictly converted to
fractions.

BCS <ao pathlink.com> writes:

Reply to Ender,

 there should be some way to define implicit casts either to or from
 user defined types.  this would greatly reduce the amount of code
 since functions would no longer have to be overloaded for as many
 times. ex: a fraction class does not need to overload opAdd since
 integers can be implictly converted to fractions.
 

this would also simplify some things like what is described here:

http://andersnoras.com/blogs/anoras/archive/2007/07/09/behind-the-scenes-of-the-planning-dsl.aspx

things like this would be really slick

|class EventComponent
|{
|  class Attend
|  {
|    Attend AreRequired(){ ... return this; }
|    Attend AreOptional(){ ... return this; }
|
|    EventComponent opImplicitCast(){return super;}  // this
|  }
|
|  static EventComponent opImplicitCast(Attendants f){return f.super;} // 
or this
|
|  Attendants{char[][] names...)
|  {
|    return new Attend(names);
|  }
|}
|
|EventComponent e = new EventComponent();
|e.Attendants("joe", "jane").AreRequired.Attendants("bob", "bill").AreOptional;

janderson <askme me.com> writes:

Ender KaShae wrote:
 there should be some way to define implicit casts either to or from user
defined types.  this would greatly reduce the amount of code since functions
would no longer have to be overloaded for as many times. ex: a fraction class
does not need to overload opAdd since integers can be implictly converted to
fractions.

C++ has the copy constructor.  Perhaps it should be something along 
those lines.  Although the C++ copy constructor is fraught with problems 
because you never know when a conversion may occur.

-Joel

James Dennett <jdennett acm.org> writes:

janderson wrote:
 Ender KaShae wrote:
 there should be some way to define implicit casts either to or from
 user defined types.  this would greatly reduce the amount of code
 since functions would no longer have to be overloaded for as many
 times. ex: a fraction class does not need to overload opAdd since
 integers can be implictly converted to fractions.

 
 C++ has the copy constructor.  Perhaps it should be something along
 those lines.  Although the C++ copy constructor is fraught with problems
 because you never know when a conversion may occur.

C++ _copy_ constructors are used for copying, not converting.
Other constructors in C++ are declared "explicit" to disallow
the compiler from using them for implicit conversions, i.e.,
they'll only be used if explicitly requested by code.

-- James