Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:97226
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: error (pb1.pair.com: domain kelunik.com from 81.169.146.219 cause and error)
MIME-Version: 1.0
In-Reply-To: <CADqTB_jvbVjmcuU9Y8s-XbrPsdaT-friNzCxair-PahvEPHm7w@mail.gmail.com>
References: <CANUQDCg+g5toVyi5VKCSkgvot0tM2Vr-UmZ=uYLYOqLPd+9+vg@mail.gmail.com>
 <CADqTB_jvbVjmcuU9Y8s-XbrPsdaT-friNzCxair-PahvEPHm7w@mail.gmail.com>
Date: Tue, 29 Nov 2016 18:13:59 +0100
Message-ID: <CANUQDCiAkJZuuw9dC8Oi6czrMkigLrPBeD+g+JGexTgd0KanDg@mail.gmail.com>
To: Rasmus Schultz <rasmus@mindplay.dk>
Cc: PHP Internals <internals@lists.php.net>
Content-Type: multipart/alternative; boundary=047d7b3a8c3ad48e4b054273b6ed
Subject: Re: [PHP-DEV] [RFC] Parameter No Type Variance
From: me@kelunik.com (Niklas Keller)

--047d7b3a8c3ad48e4b054273b6ed
Content-Type: text/plain; charset=UTF-8

>
> But this leads to code that can't pass static inspections?
>

No.


> interface Joiner {
>     public function join(array $array): string;
> }
>
> class WideJoiner implements Joiner {
>     public function join($iterable): string {
>         $array = is_array($iterable) ? $array :
> iterable_to_array($iterable);
>
>         return implode(", ", $array);
>     }
> }
>
> function joinWith(Joiner $joiner, $iterable) {
>     return $joiner->join($iterable); // <-- invalid argument ?
> }
>

Yes, a static analysis engine should report invalid argument. If you depend
on another thing being accepted, you shouldn't declare just Joiner but
instead an extending interface or an implementation directly.


> According to the Joiner abstraction, only array is accepted, and that's
> all a static analysis tool can know about the $joiner argument in the
> joinWith() function.
>

Correct, that's why the static analysis engine should throw a warning on
that code.


> Being unable to pass static inspections is one thing, but this also makes
> the code generally difficult to explain
>

How so?


> there's a contract, Joiner, which states that an array is required - to a
> person reading the joinWith() function, that's all they can know about a
> Joiner instance
>

Correct.


> it isn't safe for anybody to depend on a specific implementation of Joiner
> with a widened argument-type
>

It is safe as long as you depend on the specific implementation or an
extended interface with the widened argument type.


> unless they read through the entire codebase and happen to know about the
> WideJoiner implementation, but even then, someone using the joinWith()
> function would also need to know which implementation of Joiner is being
> passed
>

You'd just declare that you depend on a Joiner that accepts also iterables.


> which seems to defeats the purpose of even having an abstraction in the
> first place?
>

So your argument is basically that contra-variance is never needed?

Regards, Niklas

--047d7b3a8c3ad48e4b054273b6ed--