finalclassUpdateUser {
    privatefunction__construct(
        public readonly int$id,
        public readonly string|null$email,
        public readonly string|null$description,
        public readonly PaymentType|null$paymentType
    ) {}

    publicstaticfunctionfromPost(array$post): self
    {
        Assert::keyExists($post, 'id');
        Assert::positiveInteger($post['id']);
        
        $email = null;
        $description = null;
        $paymentType = null;
        
        if (array_key_exists('email', $post)) {
            $email = $post['email'];
            
            Assert::stringOrNull($email);
        }
        
        if (array_key_exists('description', $post)) {
            $description = $post['description'];
            
            Assert::stringOrNull($description);
        }

        if (array_key_exists('paymentType', $post)) {
            Assert::string($post['paymentType']);

            $paymentType = PaymentType::fromString($post['paymentType']);
        }
        
        returnnew self($post['id'], $email, $description, $paymentType);
    }
}

finalclassHandleUpdateUser
{
    publicfunction__construct(private readonly Users$users) {}
    publicfunction__invoke(UpdateUser$command): void {
        $user = $this->users->get($command->id);
        
        if ($command->email !== null) {
            // note: we only update the email when provided in input$user->updateEmail($command->email);
        }
        
        // We always update the description, but what if it was just forgotten from the payload?// Who is responsible for deciding "optional field" vs "remove description when not provided": the command,// or the command handler?// Is this a bug, or correct behavior?$user->setDescription($command->description);
        
        // Do we really want to reset the payment type to `PaymentType::default()`, when none is given?$user->payWith($command->paymentType ?? PaymentType::default());
        
        $this->users->save($user);
    }
}

/** @template Contents */finalclassOptionalField
{
    /** @param Contents $value */privatefunction__construct(
        private readonly bool$hasValue,
        private readonly mixed$value
    ) {}

    /**     * @template T     * @param T $value     * @return self<T>     */publicstaticfunctionforValue(mixed$value): self {
        returnnew self(true, $value);
    }

    /**     * @template T     * @param \Psl\Type\TypeInterface<T> $type     * @return self<T>     */publicstaticfunctionforPossiblyMissingArrayKey(array$input, string$key, \Psl\Type\TypeInterface$type): self {
        if (! array_key_exists($key, $input)) {
            returnnew self(false, null);
        }
        
        returnnew self(true, $type->coerce($input[$key]));
    }

    /**     * @template T     * @param pure-callable(Contents): T $map     * @return self<T>     */publicfunctionmap(callable$map): self
    {
        if (! $this->hasValue) {
            returnnew self(false, null);
        }
        
        returnnew self(true, $map($this->value));
    }

    /** @param callable(Contents): void $apply */publicfunctionapply(callable$apply): void
    {
        if (! $this->hasValue) {
            return;
        }

        $apply($this->value);
    }
}

OptionalField::forValue(123) /** OptionalField<int> */
    ->map(fn (int$value): string => (string) ($value * 2)) /** OptionalField<string> */
    ->apply(function (int$value): void { var_dump($value);}); // echoes

OptionalField::forPossiblyMissingArrayKey(
    ['foo' => 'bar'],
    'baz',
    \Psl\Type\positive_int()
) /** OptionalField<positive-int> - note that there's no `baz` key, so this will produce an empty instance */
    ->map(fn (int$value): string => $value . ' - example') /** OptionalField<string> - never actually called */
    ->apply(function (int$value): void { var_dump($value);}); // never called

OptionalField::forPossiblyMissingArrayKey(
    ['foo' => 'bar'],
    'foo',
    \Psl\Type\positive_int()
); // crashes: `foo` does not contain a `positive-int`!

classUpdateUser {
    /**     * @param OptionalField<non-empty-string> $email     * @param OptionalField<string>           $description     * @param OptionalField<PaymentType>      $paymentType     */privatefunction__construct(
        public readonly int$id,
        public readonly OptionalField$email,
        public readonly OptionalField$description,
        public readonly OptionalField$paymentType,
    ) {}

    publicstaticfunction fromPost(array$post): selfAssert::keyExists($post, 'id');
        Assert::positiveInteger($post['id']);

        returnnew self(
            $id,
            OptionalField::forPossiblyMissingArrayKey($post, 'email', Type\non_empty_string()),
            OptionalField::forPossiblyMissingArrayKey($post, 'description', Type\nullable(Type\string())),
            OptionalField::forPossiblyMissingArrayKey($post, 'paymentType', Type\string())
                ->map([PaymentType::class, 'fromString'])
        );
    }
}

finalclassHandleUpdateUser
{
    publicfunction__construct(private readonly Users$users) {}
    publicfunction__invoke(UpdateUser$command): void {
        $user = $this->users->get($command->id);
        
        // these are only called if a field has a provided value:$command->email->apply([$user, 'updateEmail']);
        $command->description->apply([$user, 'setDescription']);
        $command->paymentType->apply([$user, 'payWith']);

        $this->users->save($user);
    }
}