"Optional" properties

[Plastonick]

Has there been a discussion around intentional "optional" properties before?

I'm meaning, being able to distinguish between a property that does exist and potentially has a nullable value, and one that does not exist in the source.

Consider:

class Foo
{
    public function __construct(
        ?int $foo
    ) {}
}

currently we can't really distinguish between the case of mapping from source {} and source {"foo":null} which might be important especially in the case of patch endpoints that distinguish between setting a value to null, and not modifying a value.

Have we ever considering allowing wrapping our arguments in something like rust's optional type which can be either None or Some(value) to allow for that distinction? Or is there an existing way we can distinguish those cases?

I'd happily put something together for this if it wouldn't be an immediate rejection.

[eigan]

#374 (comment)

[Plastonick]

thank you! I think there probably is merit to at least sketch up the idea of some sort of Optional wrapper for properties. I'll see what I can do.

[eigan]

I don't think you can create a "generic constructor". Or at least you could not in 2023.
I created a PR which sort of worked, ut never got any feedback on it so I abonened it all together. #354

My issue was #149, where I tried to create a generic constructor.

[romm]

Hi, thanks for opening the discussion.

Sorry @eigan I did not properly review your submission at the time, it's sometimes hard to get an occasion to work on OSS.

I totally get your points and why you'd need this, but AFAIK adding support for generic constructors would not solve the "undefined" issue. This is actually a limitation of the library's internal, at least for now. I'll have to think about solutions to this.

In the meantime, you could use this:

use CuyZ\Valinor\MapperBuilder;

final class Undefined {}

final class SomeClass
{
    public function __construct(
        public string $foo,
        public Undefined|null|string $bar = new Undefined(),
    ) {}
}

(new MapperBuilder())
    ->mapper()
    ->map(SomeClass::class, [
        'foo' => 'foo',
    ]);

But this is not perfect, as the following is also allowed:

(new MapperBuilder())
    ->mapper()
    ->map(SomeClass::class, [
        'foo' => 'foo',
        'bar' => [],
    ]);

But maybe that would be enough for your case?