Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:71232
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain gmail.com designates 209.85.219.49 as permitted sender)
MIME-Version: 1.0
Sender: julienpauli@gmail.com
In-Reply-To: <002001cf12da$2bfbda90$83f38fb0$@tutteli.ch>
References: <CABDNdAGCH5i9-=4Ys1CXeNaGWGmX=mkTiq0b7BbUKtBPdQ9XVg@mail.gmail.com>
 <001301cf1227$6d082ab0$47188010$@tutteli.ch> <CABDNdAHZTcE09kS-r_XTGOE9Q5EjTsEQyvzd29q0_nUqnPRrfQ@mail.gmail.com>
 <CAF9U7z-qR-JnXmbuS-ok2NnB_QzecM1Z4MGhek77rktdSYmcmQ@mail.gmail.com>
 <CADyq6s+KqD4Sp00NcJKDAAxX+xWT4x1C3_D1zMVqZ1PRKf__9w@mail.gmail.com>
 <002d01cf1234$01e6dc60$05b49520$@tutteli.ch> <CABDNdAEAQyyLQXFw3tw8S9Rb=+9Z-k1K_geX6HG7x1reCoJ5Rw@mail.gmail.com>
 <004c01cf123d$35730870$a0591950$@tutteli.ch> <52D71748.1090402@googlemail.com>
 <52D71FAE.8030002@ajf.me> <005001cf124f$3a40df00$aec29d00$@tutteli.ch>
 <CAEp07h_KDafvOMzxVmgQq1XMeO_N3CWdFCN0vVgdxXtEn6imKg@mail.gmail.com>
 <20140116110127.202079vzjsj76n7b@webmail.tutteli.ch> <0B.B1.24763.139B7D25@pb1.pair.com>
 <002001cf12da$2bfbda90$83f38fb0$@tutteli.ch>
Date: Sat, 18 Jan 2014 04:51:49 +0100
Message-ID: <CAMUwpuRLfwru8XT64=j5LsNyG_DkwU_i0oHPHqfmn2HuLt+28A@mail.gmail.com>
To: Robert Stoll <php@tutteli.ch>
Cc: Matthieu Napoli <matthieu@mnapoli.fr>, PHP Internals <internals@lists.php.net>
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Subject: Re: [PHP-DEV] Introducing "Array Of" RFC
From: jpauli@php.net (Julien Pauli)

On Thu, Jan 16, 2014 at 5:44 PM, Robert Stoll <php@tutteli.ch> wrote:
>> How is type checking a bad design?
>>
>> Between:
>>
>> function (array $foos) {
>>      foreach ($foos as $foo) {
>>          if (! $foo instanceof Foo) {
>>              throw new InvalidArgumentException("...");
>>          }
>>          $foo->bar();
>>      }
>> }
>>
>> and:
>>
>> function (array $foos) {
>>      foreach ($foos as $foo) {
>>          $foo->bar(); // BOOM, fatal error if not correct object given
>>      }
>> }
>>
>> which one is worse?
>
> You got me wrong, I don't think that type checking as such is bad but typ=
e checking in the way the RFC promotes it is bad design IMO. If I expect an=
 array with members of a certain type (regardless if including null or not)=
 then I would not write any of the above code because this is exactly the b=
ad design I was writing about.
> Wouldn't you agree with me that it would be better to type check the entr=
ies when they are added rather than during each function call?
> Imagine function foo(Foo[] $foos){} which calls bar and baz which in turn=
 call several other functions which all have the same type hint Foo[].
> The result would be that you have increased your runtime complexity by th=
e factor of function calls. That's really ugly and I don't think that the l=
anguage itself should promote such bad design. If you go further and suppor=
t multi-dimensional arrays the same way then you would add a complexity of =
n*m for each function call with such a type hint.

I'm absolutely +1 with such a statement.

>
> However, I like the basic idea of the RFC, namely typed arrays. I think a=
 better implementation would be to introduce that an array holds (visible o=
nly internally - could be exposed to userland later) the defined type and p=
erforms the necessary checks during addition and therefore the runtime comp=
lexity for the type hint checks would no longer be linear but constant. Yet=
, it is probably better to introduce another internal data structure for th=
is purpose in order that the type hint "array" does not suffer from the add=
itional checks.
> An alternative approach, without changing the language, would be to provi=
de an additional SPL data structure instead which performs the type check d=
uring the addition of an entry.

Yes, yes and yes again. +1

This RFC shows that we lack "array of" as a whole structure in PHP,
like Java has Vectors. We already talked about this in the past.
I'm in favor of designing a new "typed array" structure , instead of
adding a new syntax that checks things at runtime of every function
call, mainly by iterating over the array at runtime.
I dont think we can accept such a penalty, particulary in the case of
nested function calls with the same signature, all requiring the
engine to iterate for type checking.


Julien.P