Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:62148
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: error (pb1.pair.com: domain ralphschindler.com from 209.85.216.170 cause and error)
Message-ID: <502A81AD.1070303@ralphschindler.com>
Date: Tue, 14 Aug 2012 11:49:49 -0500
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.7; rv:14.0) Gecko/20120713 Thunderbird/14.0
MIME-Version: 1.0
To: internals@lists.php.net
References: <CAAyV7nEZdNbWht+8Fy4ZpS=AjkzYq4Yk7XhJWV3sSV_NpgVS2g@mail.gmail.com>
In-Reply-To: <CAAyV7nEZdNbWht+8Fy4ZpS=AjkzYq4Yk7XhJWV3sSV_NpgVS2g@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
Subject: Re: [PHP-DEV] Decorators Revisited
From: ralph@ralphschindler.com (Ralph Schindler)

In general, I think it would be nice to have something that does this 
for you, but I am not necessarily a fan of changing the meaning of 
instanceof.

> That's a lot of boilerplate for each possible iteration. This is one reason
> people like traits so much, as it's easier to just do automated copy/paste
> than use the proper patterns.

Couldn't a dynamic trait be a better?  It would work like this:

trait SplDynamicProxyTrait {

   protected $proxyObject;

   // enumerate all public method with the following:
   public function $name($signature) {
     return $this->proxyObject::$name($signature);
   }

}

usage would then be the following:

class MyDecorator implements FooInterface {
   use SplDynamicProxyTrait; // compile time "code generation"
   public function __construct(Foo $foo) {
      $this->proxyObject = $foo;
   }
   // override trait
   public function method2($a) {
     if (!$this->hasCache('method2', $a)) {
       $ret = $this->proxyObject->method2($a);
       $this->setCache('method2', $a, $ret);
     }
     return $this->getCache('method2', $a);
   }
}


> So, example code like:
>
> class Foo {}
> class Bar extends SplDecorator {}
> $b = new Bar(new Foo);
> var_dump($b instanceof Foo); // true
>
> It also works with type hints:
> function test(Foo $f) {}
> test($b);

These would all still work, instanceof would actually be an instanceof 
though.

> Now, there's a lot more to do (property cascading, interface validation,
> etc), but the initial proof-of-concept is there.

> What do you think? Is this a route that I should continue down? Or is there
> something fundamental that I'm missing here? I know that Reflection,
> get_interfaces(), etc would need to be updated to account for this.
>
> Thoughts?

In the above scenario, we've reused traits and we haven't broken 
instanceof or the liskov principle (which basically your implementation 
does since SplDectorator bypasses all method signature checking until 
runtime).

Thoughts? :)

-ralph