On 9/13/2016 11:38 PM, Mathieu Rochette wrote:
> I agree that blocking clone seems unnecessary. I also don't see why it
> is useful to have "clone" methods. Why not let "clone $this" produce a
> copy that is open to modification within the scope it's cloned in ? or,
> why would you limit yourself to one clone per method call ? maybe there
> is something I'm missing but I don't get why introducing a new method
> annotation is useful. it looks like an implementation details (using
> clone instead of new) of the method is leaking
> 
> class Natural {
>  private $n;
>  public function __construct(int $n) {assert($n >= 0); $this->n = $n;}
>  public function nextTen() {
>   for ($i = 0, $c = $this; $i < 10; $i++, $c = clone $c;) {
>    $c->n++;
>    yield $c;
>   }
>  }
> }

Why would you want to clone here?

    final immutable class NaturalNumber {

      private $n;

      public function __construct(int $n) {
        assert($n >= 0);
        $this->n = $n;
      }

      public function nextTen($n) {
        for ($i = $this->n; $i < 10; ++$i) {
          yield new static($i);
        }
      }

    }

That being said, the whole example is kind of weird. What kind of
functionality is that? Why is a value object creating multiple instances
for itself? Single responsibility seems to be broken because some kind
of collection should take care of that anyways.

    final immutable class NaturalNumber {

      private $n;

      public function __construct(int $n) {/*...*/}

      public clone function add(int $n) {
        $this->n += $n;

        return $this;
      }

    }

    final class NaturalNumberCollection {

      public function nextTen(NaturalNumber $start) {
        // This cast does not work (yet) ...
        for ($i = (int) $start; $i < 10; ++$i) {
          yield $start->add($i);
        }
      }

    }

Same result but we just separated things nicely. I think the clone
modifier would help to create better code and keep it easy to understand.

On 9/13/2016 11:38 PM, Mathieu Rochette wrote:
> again, why mark method as clone method in an interface, if the interface
> is already marked as immutable isn't it enough to specify the return
> type "static" ?

Because it is unclear if you want to mutate in this context or return a
new instance altogether.

-- 
Richard "Fleshgrinder" Fussenegger

Attachment: signature.asc
Description: OpenPGP digital signature

Reply via email to