<?php
declare(strict_types=1);
class Number {
    private int|float $number;
    public function setNumber(int|float $number): void {
        $this->number = $number;
    }
    public function getNumber(): int|float {
        return $this->number;
    }
}
/**
* We can pass both floats or integer values
* to the number object. Try passing a string.
*/
$number = new Number();
$number->setNumber(5);
dump($number->getNumber());
$number->setNumber(11.54);
dump($number->getNumber());
exit;

<?php
declare(strict_types=1);
class FooBar {
    public WeakMap $cache;
    public function __construct() {
      $this->cache = new WeakMap();
    }
    public function getSomethingWithCaching(object $obj) {
        return $this->cache[$obj] ??= $this->computeSomethingExpensive($obj);
    }
    public function computeSomethingExpensive(object $obj) {
    dump("I got called");
    return rand(1, 100);
    }
}
$cacheObject = new stdClass;
$obj = new FooBar;
// "I got called" only will be printed once
$obj->getSomethingWithCaching($cacheObject);
$obj->getSomethingWithCaching($cacheObject);
dump(count($obj->cache));
// When unsetting our object, the WeakMap frees up memory
unset($cacheObject);
dump(count($obj->cache));
exit;

<?php
declare(strict_types=1);
/**
* We pass an array to array_rand,
* which is of the correct type. But
* array_rand expects non-empty arrays.
*
* This throws a ValueError exception.
*/
array_rand([], 0);
/**
* The depth argument for json_decode is a
* valid integer, but it must be greater than 0
*/
json_decode('{}', true, -1);

<?php
declare(strict_types=1);
class A {
    public function method(int $many, string $parameters, $here) {
    }
}
class B extends A {
    public function method(...$everything) {
        dd($everything);
    }
}
$b = new B();
$b->method('i can be overwritten!');
exit;

<?php
declare(strict_types=1);
class Test {
    public function doWhatever(): static {
        // Do whatever.
        return $this;
    }
}
exit;

<?php
declare(strict_types=1);
auth()->loginUsingId(1);
dump(auth()->user()::class);
// Or with a temporary variable
$user = auth()->user();
dump($user::class);
exit;

<?php
declare(strict_types=1);
class Foo {}
class Bar {}
$class = new (collect(['Foo', 'Bar'])->random());
dd($class);
exit;

<?php
declare(strict_types=1);
class Foo {
    public function __toString() {
        return 'I am a class';
    }
}
$obj = new Foo;
dump($obj instanceof Stringable);
exit;

<?php
declare(strict_types=1);
trait MyTrait {
    abstract private function neededByTheTrait(): string;
    public function doSomething() {
        return strlen($this->neededByTheTrait());
    }
}
class TraitUser {
    use MyTrait;
    // This is allowed:
    private function neededByTheTrait(): string { }
    // This is forbidden (incorrect return type)
    // private function neededByTheTrait(): stdClass { }
    // This is forbidden (non-static changed to static)
    // private static function neededByTheTrait(): string { }
}
exit;

<?php
declare(strict_types=1);
$callable = fn() => throw new Exception();
$nullableValue = null;
// $value is non-nullable.
$value = $nullableValue ?? throw new \InvalidArgumentException();
exit;

<?php
declare(strict_types=1);
function method_with_many_arguments(
    $a,
    $b,
    $c,
    $d,
) {
    dump("this is valid syntax");
}
method_with_many_arguments(
    1,
    2,
    3,
    4,
);
exit;

<?php
declare(strict_types=1);
$nullableValue = null;
try {
    $value = $nullableValue ?? throw new \InvalidArgumentException();
} catch (\InvalidArgumentException) {
    dump("Something went wrong");
}
exit;

<?php
declare(strict_types=1);
function debug_function(mixed ...$data) {
    dump($data);
}
debug_function(1, 'string', []);
exit;

<?php
declare(strict_types=1);
// First, we need to define the attribute. An Attribute itself is just a plain PHP class, that is annotated as an Attribute itself.
#[Attribute]
class ApplyMiddleware
{
    public array $middleware = [];
    public function __construct(...$middleware) {
        $this->middleware = $middleware;
    }
}
// This adds the attribute to the MyController class, with the "auth" middleware as an argument.
#[ApplyMiddleware('auth')]
class MyController
{
    public function index() {}
}
// We can then retrieve all ApplyMiddleware attributes on our class using reflection
// And read the given middleware arguments.
$reflectionClass = new ReflectionClass(MyController::class);
$attributes = $reflectionClass->getAttributes(ApplyMiddleware::class);
foreach ($attributes as $attribute) {
    $middlewareAttribute = $attribute->newInstance();
    dump($middlewareAttribute->middleware);
}
exit;

<?php
declare(strict_types=1);
class User {
    public function __construct(
        public int $id,
        public string $name,
    ) {}
}
$user = new User(1, 'Marcel');
dump($user->id);
dump($user->name);
exit;

<?php
declare(strict_types=1);
echo match (1) {
    0 => 'Foo',
    1 => 'Bar',
    2 => 'Baz',
};
exit;

<?php
declare(strict_types=1);
class User {
    public function getAddress() {}
}
$user = new User();
$country = $user?->getAddress()?->country?->iso_code;
dump($country);
exit;

<?php
declare(strict_types=1);
array_fill(start_index: 0, num: 100, value: 50);
exit;