today at 11:20 AM
For anyone not familiar with PHP, static analysis is pretty much required because the official PHP type system is minimal. The detailed types are added through phpdoc comments, and they also help IDEs to provide a sane completion. For instance, the plain "array" should be detailed with phpdoc:
/**
* @param array<string, MyRecord> $input
* @return list<int>
*/
function foo(array $input): array
{
foreach ($input as $string => $record) {
// IDE knows $record is an instance of MyRecord
There are two major static analysis tools for PHP, Psalm and PHPstan, both written in PHP. The latter used to be much slower, but last time I tried it there was little difference (about 20 s for 100k lines + dependencies).
My guess is that a new contender, Mago, written in Rust, will probably soon replace those other tools. Its commands (analyze, lint) are already almost as complete as psalm/phpstan. Though the migration won't be easy because it does not have a notion of levels.
today at 11:25 AM
PHP type system is lacking but I wouldn't call it minimal.
PHP even has union types, just like TypeScript.
The major issue is the lack of array types and it's 90% of the reason I see projects using extra linting tools.
[1] https://php.watch/versions/8.0/union-types
today at 3:33 PM
Maybe "minimal" was not the right word. I hope the context made clear that I meant the type system was lacking even for basic uses. Here are 3 common cases.
Some PHP functions (e.g. opening a file) return a `resource` type, but PHP has no official way to declare it. So the right way is to declare `mixed` as an official type (which means `any`) and fix that declaration with a phpdoc comment.
Phpdoc provides generics (named "templates", à la C++), e.g. `iterable<Something>` where `iterable` is an official PHP type (which is awfully imprecise without phpdoc).
Phpdoc has tuples and (associative) array shapes, e.g. `@return list{int, \Error}`.
In past PHP versions, the type system was worse because the internal types were ambiguous: types were implicitly nullable, i.e. `string` meant `null|string`. When PHP gradually added sum types, they fixed that ambiguity.
today at 3:43 PM
> Phpdoc has tuples and (associative) array shapes, e.g. `@return list{int, \Error}`.
`list<Error>` a `list<T>` is `array<int<0, max>, T>` (some differences in phpstan vs psalm vs mago)
today at 3:32 PM
it has union and intersection types, but it is nothing like typescript.
today at 12:53 PM
> PHP type system is lacking but I wouldn't call it minimal.
PHP still doesn't have generics, right? IMO any type system without higher-order types is definitely on the minimal side.
today at 1:38 PM
Natively: no. Via tools like phpstan and psalm: yes, per OP. Link to relevant docs: https://psalm.dev/docs/annotating_code/templated_annotations... or https://phpstan.org/blog/generics-by-examples
One can declare:
final class Door {}
/**
* @template T
*/
final class Box
{
/** @param T $value */
public function __construct(private mixed $value) {}
/** @return T */
public function get(): mixed
{
return $this->value;
}
}
final class DoorInspector
{
/** @param Box<Door> $box */
public function __construct(private Box $box) {}
public function inspect(): void
{
$this->box->get()->open(); // analyser knows this is a Door
}
}
new DoorInspector(new Box(new Door())); // OK
new DoorInspector(new Box('not a door')); // error: Box<string> given
final class Door {}
/**
* @template T
*/
class Box
{
/** @param T $value */
public function __construct(private mixed $value) {}
/** @return T */
public function get(): mixed
{
return $this->value;
}
}
/** @extends Box<Door> */
final class DoorBox extends Box {}
/**
* @template T
* @template F of Box<T>
*/
final class Shelf
{
/** @param F $box */
public function __construct(private Box $box) {}
/** @return F */
public function box(): Box
{
return $this->box;
}
/** @return T */
public function item(): mixed
{
return $this->box->get();
}
}
$shelf = new Shelf(new DoorBox(new Door()));
$shelf->box(); // DoorBox
$shelf->item(); // Doortoday at 3:50 PM
yeah, it is a real pain in the ass. imagine if php 8 accepted the RFC for generics
today at 11:29 AM
That's exactly it but PHP Core refuses to address the typed array issue in wait for a consensus on Generics even though those two things serve different audiences.
I haven't actually run into a single issue with PHP's type system in the last few years. Literally the only thing that remains is typed arrays but that seems to be ways off due to fragmentation in how the core devs want it handled.
today at 11:55 AM
With how good PHPDoc and Phan are these days I don't really think about it anymore. You can sort of have typed array by implementing Iterator, Countable, ArrayAccess, and optionally Indexing but I assume you mean defining types of array values.
today at 3:59 PM
If I could take a tangent and talk about the infuriating implicit-casting behavior of arrays in PHP?
declare(strict_types=1);
/\* @var array<string, int> \*/
function foo(string $key) {
echo $key;
}
$foo = [
'a' => 10,
'1' => 15,
];
foreach ($foo as $key => $_) {
foo($key);
}
today at 3:53 PM
pretty naive take, no run time guarantees, basically swinging on hope to keep your shit together. phpstan drops types on static analysis for deeply nested arrays/objects for example. or even those with many members.
today at 9:45 AM
Thou shall use the Rust rewrite of PHP.
today at 1:35 PM
Why not skip the php and write rust directly?
today at 10:42 AM
”Rewrite in Rust” fanboys are more annoying than crypto bros. How is such a feat even possible?
today at 12:51 PM
I dunno,unlike the crypto/NFT era, Rust rewrites have demonstrated measured performance and memory savings gains. Some grimace when they see "written in Rust" as a tagline but my immediate thought tends to land more on the "thank God this isn't an electron app" side of things
today at 2:00 PM
Operative word is “fanboys”, I have mostly no qualms of actual rewrites to that language. It’s the fanboys who insist upon injecting themselves and their opinions everywhere with net negative impact.
today at 1:34 PM
Google funding, I suspect. One day they will turn off the tap and the mantra will be silenced.
"Strange; seems like all I hear about these days are projects funded by the world's largest advertising corporation."
today at 11:30 AM
inb4 "Rewrite bitcoin in Rust" comments stars pouring in
today at 9:18 AM
Ah boy o boy, PHP was the first lanuage I teached myself but man it still needs PHPDoc comment on return types?
Come on PHP has so many shitty things, but even something basic like this is still not in the lanuage itself?
today at 1:39 PM
PHP does have return type annotations. The reason the PHPDoc comments are needed here is that it lacks generics. Unfortunately, adding generics has proven problematic, but I still hope that we'll see them in the next few years.
today at 9:20 AM
It's had return type declarations since 7. There's even intersection and literal types now. You could have typed this into google and it would have told you
today at 10:43 AM
I did and it told me that it doesn't support typed arrays.
today at 10:33 AM
Type declarations are still quite limited, though. For example, you can declare that a function returns an array or a string, but not an array of strings.
today at 10:59 AM
Use a class if you need them.
today at 11:18 AM
How does that solve the problem? You can't declare an array of strings inside a class, either.
today at 2:27 PM
You can annotate the method as `@return array<array-key,string>` or even `@return list<string>` (array of strings = indexed via anything that can be used as a key in PHP vs list of strings = indexed via incrementing integers, starting from 0). I guess the OP suggestion was to use Arrayable / Iterable interfaces, which would work as well, but would require more effort (= yes, declare a class)
today at 12:04 PM
Do some research :D.
today at 12:37 PM
Just to be clear, you suggest to wrap a typed array into its own class? is that the suggestion you think of?
Because if yes, thats just ugly and a hack/workaround.
today at 9:28 AM
TFA even shows examples of native return types. How could you not see that?
today at 10:45 AM
The page itself shows plenty of examples were this is not true.
Including generic type arrays which is not supported.
today at 10:29 AM
"Taught", not "teached".
today at 10:09 AM
"Cool! A PHP article on HN, let's rehash some of my comments that got lots of upvotes 11 years ago!"
today at 10:46 AM
Yepp, especially because not much changed and other languages did quite a lot. Strong contrast don't you think?
today at 11:32 AM
Hmmm not much changed you say... Lets take a look at https://wiki.php.net/rfc
ooh wait, you couldn't be more wrong. Pikachuface.png
today at 11:47 AM
Core issues have not been fixed.
You remember when HHVM / hack came out from Facebook? Besides the fact that it was quite a dick move from Facebook to bring it out and then stop supporting it, it pushed PHP to take performance temporarily serious and there was so much air in it.
But the standard library is still inconsistent as hell, type system is still garbage especially mixxing strict and non strict.
The concurrency implementation? Has to be fixed again by frameworks.
And yeah i mean the critisism of my original comment stands as well and thats just an eye sore.