Add an option() type to Psl\Type to coerce to a Psl\Option\Option

[devnix]

I'll leave here an example given by @azjezz:

use Psl\Str;
use Psl\Type;
use Psl\Option;

/**
 * @var Type\TypeInterface<Option\OptionInterface<string>>
 */
$type = Type\option(Type\string());

$str = 'abc';
$arr = [];

// = 3
$a = $type->coerce($str)->map(Str\length(...))->unwrapOr(0);
// = 0
$b = $type->coerce($arr)->map(Str\length(...))->unwrapOr(0);

$val = Option\none();
$type->matches($val); // true? `matches` has `@psalm-assert-if-true T $value` so now psalm will think it's `Option<string>`, not an issue

$val = Option\some(123);
$type->matches($val); // false? this would require us to unwrap it if it's a some and check the value

I think I could work on this one

[devnix]

I'll be sure to leave here an idea. As we probably want to have fine control of what is some and what is none and each view will likely differ, why not require a callable to decide it?

$myType = Type\option(
    Type\string(),
    static fn (string $value) => '' !== $value
);

$myType->coerce('Hello world')->isSome(); // true
$myType->coerce('')->isSome(); // false

WDYT @azjezz @veewee? I will have a couple of spare weeks so I can start working on this idea if you like it

[veewee]

Hello @devnix,

I was thinking : wouldn't is make more sense to let the underlying type determine wether it is some or none?
For example:

$type = option(string());
$type->coerce('some'); // Some('some');
$type->coerce(''); // Some('');

// But

$type = option(non_empty_string());
$type->coerce('some'); // Some('some');
$type->coerce(''); // None();

The logic would be as followed:

• coerce($data)
  • If inner type coerces, then it is some($data)
  • If inner type throws exception, then it is none()
• assert($data)
  • Validates if $data is of type Option
  • In case of some, validates if inner type asserts on unwrapped option value
• matches($data)
  • Validates if $data is of type Option
  • In case of some, validates if inner type matches on unwrapped option value

I have not validated every possible type to make sure this logic is 100%, but think it should do the job just fine.

This way, you could use the base types to determine it is a some|none, and a converted() type (instead of a predicate) for very specific scenarios.

WDYT?

[devnix]

Hi @veewee, sorry for the late response!

It is true that converted() would be a better candidate for the case I presented.

However, the coerce() behavior looks too forgiving for me. I was surprised by the first time I used shape() when I saw it failed even when the shape was correct, and then I saw that the given shape I was coercing had more keys than my documented shape, and then I learned about the allow_unknown_fields parameter.

I think that it's easier to offer stricter behaviors by default with opt-ins for a more lenient logic. For example:

$type = option(string());
$type->coerce('some'); // Some('some');
$type->coerce(''); // Some('');

$type = option(non_empty_string());
$type->coerce('some'); // Some('some');
$type->coerce(null); // None();
$type->coerce(''); // CoercionException

$type = option(
    non_empty_string(),
    none_if_not_coercible: true
);
$type->coerce('some'); // Some('some');
$type->coerce(''); // None();

However, I also doubt about performing a logic like from_nullable() with code like this:

$type = option(nullable(string()));
$type->coerce('some'); // Some('some');
$type->coerce(null); // Some(null) or None()?