Newsgroups: php.internals
Path: news.php.net
Xref: news.php.net php.internals:71189
Mailing-List: contact internals-help@lists.php.net; run by ezmlm
Received-SPF: pass (pb1.pair.com: domain tutteli.ch designates 80.74.154.78 as permitted sender)
To: "'Matthieu Napoli'" <matthieu@mnapoli.fr>,
	<internals@lists.php.net>
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>
In-Reply-To: <0B.B1.24763.139B7D25@pb1.pair.com>
Date: Thu, 16 Jan 2014 17:44:06 +0100
Message-ID: <002001cf12da$2bfbda90$83f38fb0$@tutteli.ch>
MIME-Version: 1.0
Content-Type: text/plain;
	charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Thread-Index: AQGahXeLh/KZbd8XAeJ9KP0Xitay+AEcU2WhAaqmqGABFinRgAGUH60GAsS5wSoDHy62oAKq0EPNApG0KWABZZ/6VwJfgrHWAcL4bIgCA1yDhgETP0JZmicYYfA=
Content-Language: de-ch
Subject: RE: [PHP-DEV] Introducing "Array Of" RFC
From: php@tutteli.ch ("Robert Stoll")

> How is type checking a bad design?
>=20
> Between:
>=20
> function (array $foos) {
>      foreach ($foos as $foo) {
>          if (! $foo instanceof Foo) {
>              throw new InvalidArgumentException("...");
>          }
>          $foo->bar();
>      }
> }
>=20
> and:
>=20
> function (array $foos) {
>      foreach ($foos as $foo) {
>          $foo->bar(); // BOOM, fatal error if not correct object given
>      }
> }
>=20
> which one is worse?

You got me wrong, I don't think that type checking as such is bad but =
type 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 bad design I was writing about.
Wouldn't you agree with me that it would be better to type check the =
entries 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 =
the factor of function calls. That's really ugly and I don't think that =
the language itself should promote such bad design. If you go further =
and support multi-dimensional arrays the same way then you would add a =
complexity of n*m for each function call with such a type hint.=20

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 only internally - could be exposed to userland later) the =
defined type and performs the necessary checks during addition and =
therefore the runtime complexity for the type hint checks would no =
longer be linear but constant. Yet, it is probably better to introduce =
another internal data structure for this purpose in order that the type =
hint "array" does not suffer from the additional checks.
An alternative approach, without changing the language, would be to =
provide an additional SPL data structure instead which performs the type =
check during the addition of an entry.=20

Nevertheless, the implementation of the RFC as such is not useless. We =
could introduce a function is_arrayOf(array $arr, $type, =
$nullable=3Dfalse) which could perform the check as implemented in the =
pull request (including the nullable option). And I suppose you can come =
up with valid uses cases where such a check makes actually sense and =
worth the new function.