Idea: Lazy upcasting

Davidl Davidl at 126.com
Tue Mar 27 04:49:07 PDT 2007


class baseclass
{
}
class inheritedclass:baseclass
{
     int j(){}
}
let's see what upcast would happen:

auto baseinst = new baseclass;
inheritedclass inheritedinst= cast(inheritedclass)cast(void*) baseinst;
inheritedinst.j();        <--- oops , AV here

implicitly upcasting could cause tons of bugs

and how do u know when u don't want implicit casting but it casts?



> Hello!
>
> Recently I have tried to achieve chaining a few calls to setters. I mean
> something like below:
>
> //-------------------------------------------
>
> abstract class Storage {
>      Storage param1(int p1) {
>          this.p1 = p1;
>          return this;
>      }
> private:
>      int p1;
> }
>
> class SpecificStorage : Storage {
> public:
>      SpecificStorage param2(bool p2) {
>         this.p2=p2;
>         return this;
>      }
> private:
>      bool p2;
> }
>
> void main() {
> //                             ...ok...      ...ok...        ...ups!
> SpecificStorage1 s1 = (new SpecificStorage).param2(true).param1(5);
> }
>
> //-------------------------------------------
>
> Because returned type from param1 is Storage above example doesn't  
> work...
>
> Unfortunately currently it is necessary to add overridden implementation  
> of
> param1() in SpecificStorage:
>
>      SpecificStorage param1(int p1) {
>          this.p1 = p1;
>          return this;
>      }
>
>
> But my intuition about that would be that "this" pointer from method  
> param1
> will point to "SpecificStorage" when it is used in SpecificStorage. But  
> it
> is upcasted to Storage during return from param1.
>
> Such a behavior seems a nonsense when there is covariance return type
> feature in programming language. To get covariance I have to reimplement
> same code in every inherited class just to trigger proper behaviour.
>
> Here I would like to propose a change:
>
> ****
> There should be no upcast during return. When function returns  
> descendant of
> declared type it should not be converted to base class (declared) but
> function should return descendant type. I think about this as a lazy
> upcasting :-)
> ****
>
> It should not break anything when instead of making upcasting during  
> return
> compiler just return concreate type and probably later make upcast when
> e.g. assigning to Storage variable. When I want to assure that Storage
> class will be returned I just can add cast in base class like below:
>
> Storage param1(int p1) {
>         this.p1 = p1;
>         return cast(Storage)this;
> }
>
> But usually there is a need to get opposite behaviour and get descendant
> class not ancestor...
>
> -----
>
> I would say that recently, when new dmd 1.010 appeard, such a change  
> should
> additionally improve language. There is a new method in Object:
>
> static Object factory(char[]);
>
> It will be usually used to create specific classes, not Object class so
> usage will be like below:
> SpecificStorage s = cast(SpecificStorage)  
> Object.factory("SpecificStorage");
>
> With proposed change you will just get:
> SpecificStorage s = Object.factory("SpecificStorage");
>
> Advantages:
> - downcasts are no more necessary (there are no casts at all, although it
> could look like there are implicit downcasts)
> - no need for reimplementation of same method returning this in derived
> classes just to get covariance work
> - coherent with covariance feature
>
> I don't know disadvantages, so I would like to hear your opinion. Maybe  
> it
> is just technically difficult, but I don't know dmd compiler good enough  
> to
> say that...
>
> Anyway please comment on that...
>




More information about the Digitalmars-d mailing list