PHP 8 Features: Enums, Match, Readonly Properties and Constructor Promotion

<?php

class Money
{
    private int $amount;
    private string $currency;

    public function __construct(int $amount, string $currency)
    {
        $this->amount = $amount;
        $this->currency = $currency;
    }
}

<?php

final class Money
{
    public function __construct(
        public readonly int $amount,
        public readonly string $currency = 'INR',
    ) {
        if ($amount < 0) {
            throw new InvalidArgumentException('Amount cannot be negative.');
        }
    }

    public function add(Money $other): self
    {
        if ($other->currency !== $this->currency) {
            throw new InvalidArgumentException('Currency mismatch.');
        }
        // Immutable: return a new instance rather than mutating
        return new self($this->amount + $other->amount, $this->currency);
    }
}

$total = (new Money(1000))->add(new Money(250));
echo $total->amount;   // 1250

<?php

// PHP 8.2: readonly on the class marks every property readonly
final readonly class Coordinates
{
    public function __construct(
        public float $latitude,
        public float $longitude,
    ) {}

    // Named constructors pair well with immutability
    public static function fromString(string $pair): self
    {
        [$lat, $lng] = array_map('floatval', explode(',', $pair));
        return new self($lat, $lng);
    }

    public function withLatitude(float $latitude): self
    {
        return new self($latitude, $this->longitude);
    }
}

$point = Coordinates::fromString('12.97,77.59');

// Error: Cannot modify readonly property Coordinates::$latitude
// $point->latitude = 0.0;

$moved = $point->withLatitude(13.0);   // a new instance

<?php

interface HasLabel
{
    public function label(): string;
}

enum OrderStatus: string implements HasLabel
{
    case Pending   = 'pending';
    case Paid      = 'paid';
    case Shipped   = 'shipped';
    case Cancelled = 'cancelled';

    public function label(): string
    {
        return match ($this) {
            self::Pending   => 'Awaiting payment',
            self::Paid      => 'Payment received',
            self::Shipped   => 'On its way',
            self::Cancelled => 'Cancelled',
        };
    }

    public function isFinal(): bool
    {
        return in_array($this, [self::Shipped, self::Cancelled], true);
    }
}

// The parameter can now only receive a valid status
function notify(OrderStatus $status): string
{
    return $status->label();
}

// from() throws on an unknown value; tryFrom() returns null
$status = OrderStatus::from('paid');
$maybe  = OrderStatus::tryFrom($_GET['status'] ?? '') ?? OrderStatus::Pending;

// cases() lists every member — handy for building a <select>
foreach (OrderStatus::cases() as $case) {
    echo "{$case->value}: {$case->label()}\n";
}

<?php

// switch: loose ==, needs break, silently does nothing if unmatched
switch ($httpCode) {
    case 200:
    case 201:
        $result = 'success';
        break;
    case 404:
        $result = 'not found';
        break;
    default:
        $result = 'unknown';
}

// match: strict ===, an expression, exhaustive
$result = match ($httpCode) {
    200, 201 => 'success',
    404      => 'not found',
    default  => 'unknown',
};

// Without a default, an unhandled value throws
// UnhandledMatchError — which is usually what you want
$label = match ($status) {
    OrderStatus::Paid    => 'Paid',
    OrderStatus::Shipped => 'Shipped',
};

// match(true) replaces long if/elseif chains
$tier = match (true) {
    $total >= 100_000 => 'platinum',
    $total >= 50_000  => 'gold',
    $total >= 10_000  => 'silver',
    default           => 'bronze',
};

<?php

// Named arguments: skip optional parameters and document the call site
function createUser(
    string $email,
    string $name = '',
    bool $isAdmin = false,
    bool $sendWelcome = true,
): User {
    // ...
}

// Previously: createUser('a@b.c', '', false, false) — what do these mean?
createUser(email: 'a@b.c', sendWelcome: false);

// Nullsafe operator: short-circuits the whole chain on null
$city = $order?->customer?->address?->city;

// Equivalent to this, but without the nesting:
// $city = null;
// if ($order !== null && $order->customer !== null) { ... }

// First-class callable syntax (8.1) — type-safe references
$fn   = strlen(...);
$self = $this->handle(...);
$stat = OrderStatus::tryFrom(...);

$lengths = array_map(strlen(...), ['one', 'three']);

// Readable numeric literals (7.4) and 8.1 octal notation
$budget = 1_500_000;
$perms  = 0o755;