# PHP needs an "unknown" type

If you are familiar with Typescript, you may know their any type. With any you can do anything. It signals that you don’t know about the actual type, and that anything goes. The following code is completely valid in Typescript.

const doTheThing = (input: any) => {
input + input;
input.toString();

Object.keys(input).map((key) => {
return input.foo[key];
});

const [one, two] = input;
input();
}


In Typescript 3.0 the unknown type was introduced. unknown is both like any, and completely different. unknown also means that it can be any value, but the logic about it is inverted. With any, anything is allowed, because we don’t know what it is. With unknown, nothing is allowed, because we don’t know what it is.

const doTheThing = (input: unknown) => {
input + input; // error
input.toString(); // error

Object.keys(input).map((key) => { // error
return input.foo[key]; // error
});

const [one, two] = input; // error
input(); // error
}


In PHP we have don’t have any or unknown, instead we have mixed. Which is an official type since PHP 8.0. And when using static analysis tools the results are mixed.

If we take the following piece of code, and check it with PHPStan, we get no errors. With Psalm we don’t get any errors on level 2, but on level 1 we do.

function doTheThing(mixed $input): void {$input->toString();
$keys = array_keys($input);
[$one,$two] = $input;$input();
}


If PHP would have an unknown type, then it could have the same behavior with both tools. Making changes to mixed would be a big BC break, especially for legacy projects where there is a lot of that. Unknown wouldn’t be a type that should be in PHP itself, but it could live as an annotation.

If we have unknown, we can allow users to use the feature on lower strictness levels. It would also prevent them from having to add potentially thousands of ignores to a baseline file.

##### Gert de Pagter
###### Software Engineer

My interests include software development, math and magic.