ObservableValue.map special-cases the null value

[John Hendrikx]

Hi Michael,

As you're only trying to map to true/false, it is a bit ugly to do this 
I suppose:

       nullableValue.map(x -> true).orElse(false);

I've encountered situations like these before, where you only want to 
know about the presence of a value, and don't care what the value is.  
If there are sufficient use cases, we could consider adding a method for 
this.  Instead of `mapNullable` though I was thinking more along the 
lines of `isPresent` and `isEmpty`:

       ObservableValue<Boolean> isPresent();  // true if not null

       ObservableValue<Boolean> isEmpty();  // true if null

So far I didn't think it would be warranted to add such methods, but 
they're trivial to add.

On 17/05/2023 00:25, Michael Strauß wrote:
> I'm trying to map an ObservableValue such that `null` is mapped to
> `false` and any other value is mapped to `true`. The following line of
> code should do the trick:
> ObservableValue<Boolean> mappedValue = nullableValue.map(x -> x != null);
>
> It turns out that this doesn't work, since `map` doesn't pass `null`
> to the mapping function. Instead of calling the mapping function, it
> always returns `null`. This is not technically a bug, as `map` is
> specified to have this behavior. It is a bit unfortunate, though;
> `null` is a perfectly valid value in many cases and its special
> treatment comes off as a bit of a surprise.

The alternative is worse I think, as JavaFX properties can easily be 
`null`, you'd have to add null checks to your map/flatMaps. Especially a 
construct like this:

       node.sceneProperty()
           .flatMap(Scene::windowProperty)
           .flatMap(Window::showingProperty)
           .orElse(false);

... would be really annoying to write if you had to deal with the 
nulls.  The functionality is closely related to what Optional offers, 
and that one doesn't pass `null` to its map/flatMap methods either, nor 
will it ever add a `mapNullable` :-)

> I'm wondering whether we need a `mapNullable` operator that does what
> I intuitively expecting `map` to do, which is just unconditionally
> passing the value to the mapping function.

Maybe, I think however that you'd only need this for the very special 
case where you are intending to ignore the actual value being passed to 
a map/flatMap, and only want to check it for null.  `isPresent` / 
`isEmpty` would be nicer for this.  For all other cases, where you are 
actually doing some kind of mapping, I think a map/orElse combo works great.

--John