1# Modern PHP 8.3+ Features
2 
3## Strict Types & Type Declarations
4 
5```php
6<?php
7 
8declare(strict_types=1);
9 
10namespace App\Domain\User;
11 
12final readonly class User
13{
14    public function __construct(
15        public int $id,
16        public string $email,
17        public UserStatus $status,
18        public \DateTimeImmutable $createdAt,
19    ) {}
20}
21 
22function calculateTotal(int $price, float $taxRate): float
23{
24    return $price * (1 + $taxRate);
25}
26 
27// Union types
28function processId(int|string $id): string
29{
30    return is_int($id) ? (string)$id : $id;
31}
32 
33// Intersection types
34interface Timestamped {}
35interface Authenticatable {}
36 
37function handleUser(Timestamped&Authenticatable $user): void {}
38```
39 
40## Enums with Methods
41 
42```php
43<?php
44 
45declare(strict_types=1);
46 
47enum UserStatus: string
48{
49    case ACTIVE = 'active';
50    case SUSPENDED = 'suspended';
51    case DELETED = 'deleted';
52 
53    public function label(): string
54    {
55        return match($this) {
56            self::ACTIVE => 'Active User',
57            self::SUSPENDED => 'Suspended',
58            self::DELETED => 'Deleted User',
59        };
60    }
61 
62    public function canLogin(): bool
63    {
64        return $this === self::ACTIVE;
65    }
66 
67    public static function fromString(string $value): self
68    {
69        return self::from(strtolower($value));
70    }
71}
72 
73enum HttpStatus: int
74{
75    case OK = 200;
76    case CREATED = 201;
77    case BAD_REQUEST = 400;
78    case UNAUTHORIZED = 401;
79    case NOT_FOUND = 404;
80    case SERVER_ERROR = 500;
81 
82    public function isSuccess(): bool
83    {
84        return $this->value >= 200 && $this->value < 300;
85    }
86}
87```
88 
89## Readonly Properties & Classes
90 
91```php
92<?php
93 
94declare(strict_types=1);
95 
96// Readonly class (PHP 8.2+)
97final readonly class Money
98{
99    public function __construct(
100        public int $amount,
101        public string $currency,
102    ) {
103        if ($amount < 0) {
104            throw new \InvalidArgumentException('Amount cannot be negative');
105        }
106    }
107 
108    public function add(Money $other): self
109    {
110        if ($this->currency !== $other->currency) {
111            throw new \InvalidArgumentException('Currency mismatch');
112        }
113        return new self($this->amount + $other->amount, $this->currency);
114    }
115}
116 
117// Individual readonly properties
118class Configuration
119{
120    public function __construct(
121        public readonly string $apiKey,
122        public readonly string $apiSecret,
123        private string $cache = '',
124    ) {}
125}
126```
127 
128## Attributes (Metadata)
129 
130```php
131<?php
132 
133declare(strict_types=1);
134 
135#[\Attribute(\Attribute::TARGET_CLASS)]
136final readonly class Route
137{
138    public function __construct(
139        public string $path,
140        public string $method = 'GET',
141        public array $middleware = [],
142    ) {}
143}
144 
145#[\Attribute(\Attribute::TARGET_PROPERTY)]
146final readonly class Validate
147{
148    public function __construct(
149        public ?string $rule = null,
150        public ?int $min = null,
151        public ?int $max = null,
152    ) {}
153}
154 
155// Using attributes
156#[Route('/api/users', method: 'POST', middleware: ['auth'])]
157final class CreateUserController
158{
159    public function __invoke(CreateUserRequest $request): JsonResponse
160    {
161        // ...
162    }
163}
164 
165class UserDto
166{
167    #[Validate(rule: 'email')]
168    public string $email;
169 
170    #[Validate(min: 8, max: 100)]
171    public string $password;
172}
173```
174 
175## First-Class Callables
176 
177```php
178<?php
179 
180declare(strict_types=1);
181 
182class UserService
183{
184    public function findById(int $id): ?User {}
185    public function create(array $data): User {}
186}
187 
188$service = new UserService();
189 
190// PHP 8.1+ first-class callable syntax
191$finder = $service->findById(...);
192$user = $finder(42);
193 
194// Array operations
195$numbers = [1, 2, 3, 4, 5];
196$doubled = array_map(fn($n) => $n * 2, $numbers);
197 
198// Named arguments with callable
199$result = array_filter(
200    array: $numbers,
201    callback: fn($n) => $n % 2 === 0,
202);
203```
204 
205## Match Expressions
206 
207```php
208<?php
209 
210declare(strict_types=1);
211 
212function getStatusColor(UserStatus $status): string
213{
214    return match ($status) {
215        UserStatus::ACTIVE => 'green',
216        UserStatus::SUSPENDED => 'yellow',
217        UserStatus::DELETED => 'red',
218    };
219}
220 
221function calculateShipping(int $weight, string $zone): float
222{
223    return match (true) {
224        $weight < 1000 => 5.00,
225        $weight < 5000 && $zone === 'local' => 10.00,
226        $weight < 5000 => 15.00,
227        default => 25.00,
228    };
229}
230 
231// Match with multiple conditions
232function getHttpMessage(int $code): string
233{
234    return match ($code) {
235        200, 201, 204 => 'Success',
236        400, 422 => 'Client Error',
237        401, 403 => 'Unauthorized',
238        500, 502, 503 => 'Server Error',
239        default => 'Unknown',
240    };
241}
242```
243 
244## Fibers (PHP 8.1+)
245 
246```php
247<?php
248 
249declare(strict_types=1);
250 
251// Basic fiber example
252$fiber = new \Fiber(function (): void {
253    $value = \Fiber::suspend('fiber started');
254    echo "Received: {$value}\n";
255    \Fiber::suspend('second suspend');
256    echo "Fiber completed\n";
257});
258 
259$result1 = $fiber->start();
260echo "First result: {$result1}\n";
261 
262$result2 = $fiber->resume('data from main');
263echo "Second result: {$result2}\n";
264 
265$fiber->resume('final data');
266 
267// Async-style with fibers
268function async(callable $callback): \Fiber
269{
270    return new \Fiber($callback);
271}
272 
273function await(\Fiber $fiber): mixed
274{
275    if (!$fiber->isStarted()) {
276        return $fiber->start();
277    }
278    return $fiber->resume();
279}
280```
281 
282## Never Type
283 
284```php
285<?php
286 
287declare(strict_types=1);
288 
289function redirect(string $url): never
290{
291    header("Location: {$url}");
292    exit;
293}
294 
295function abort(int $code, string $message): never
296{
297    http_response_code($code);
298    echo json_encode(['error' => $message]);
299    exit;
300}
301 
302class NotFoundException extends \Exception
303{
304    public static function throw(string $resource): never
305    {
306        throw new self("Resource not found: {$resource}");
307    }
308}
309```
310 
311## Quick Reference
312 
313| Feature | PHP Version | Usage |
314|---------|-------------|-------|
315| Readonly properties | 8.1+ | `public readonly string $name` |
316| Readonly classes | 8.2+ | `readonly class User {}` |
317| Enums | 8.1+ | `enum Status: string {}` |
318| First-class callables | 8.1+ | `$fn = $obj->method(...)` |
319| Never type | 8.1+ | `function exit(): never` |
320| Fibers | 8.1+ | `new \Fiber(fn() => ...)` |
321| Pure intersection types | 8.1+ | `A&B $param` |
322| DNF types | 8.2+ | `(A&B)\|C $param` |
323| Constants in traits | 8.2+ | `trait T { const X = 1; }` |
324