map is able to create Just(null)

[asimontsev]

It looks like that Maybe.map is not working as it should - if a function you pass to map returns null, it creates Just(null) instead of Nothing!

import { nullable } from 'pratica';

const data = { foo: null };
const maybe = nullable(data).map(({foo})=>foo);
console.log(maybe.inspect());

Expected output: Nothing
Actual output: Just(null)

I have taken a look through the source code and here is a problem

pratica/src/maybe.ts

Line 21 in 50379a4

map: <B>(cb: (a: A) => B): Maybe<B> => Just(cb(arg)),

Every time when the map is called for a Maybe which contains a value, it always assumes that the result should be wrapped to Just as well. However, in the situations when it returns null, you would get Just(null) which is completely wrong.

To fix it, you should use nullable instead of Just:

  map: <B>(cb: (a: A) => B): Maybe<B> => nullable(cb(arg)),

Also, I would suggest considering adding a constructor to Just and Nothing which would throw an exception when an incorrect value is passed there.

[rametta]

That is the intended behaviour of map.

It is up to the consumer to decide when a field should be checked for nullabilitly.
That is why the get and chain functions exist.
Checking for null on every map call would be wasteful and have poor performance.

Regarding your example, here is how it should be done:

import { nullable, get } from 'pratica';

const data = { foo: null };
const maybe = nullable(data).chain(get('foo'));

[CrossEye]

@asimontsev:

You might want to investigate parametric polymorphism to learn why this behavior is important.

[asimontsev]

Ok, thanks for the answers! They made me understand FP a little bit better. :-)

When I was posting this, I was pretty sure that it is a bug, but now I can see a lot of similar posts in the discussion of other libraries. Looks like that the main battle was over 5 years ago. :-)

fantasyland/fantasy-land#85

Perhaps my main misconception about Maybe is that it is a single type and Maybe.of(null) is always Nothing. This kind of behavior is a selling point of the articles popularizing Monads for JS developers (since we are always sure that the code inside lambdas we pass to map/flatMap are always null-free). However, as I can see from this discussion, Just(null) is legitimate value.

In practice, it means that if we want a null-free behavior, we should never use map. In general, we have to write something like

const maybe = nullable(data).chain(({foo})=>nullable(foo));

Fortunately, your nice get function returns a property wrapped into Maybe, which makes the code look elegant. It looks like in other cases you still have to clutter the lambda code by nullables (say, if you call Array.find), but I think I can live with that.

If you ever consider extending your documentation with some "best practices"/code examples, I believe it should have a section discussing this issue.

[rametta]

Some best practice docs would be good, I agree.
For your Array.find example, we also have the tryFind function, which returns a Maybe.

[CrossEye]

@asimontsev:

Looks like that the main battle was over 5 years ago. :-)

fantasyland/fantasy-land#85

Ah, the thread that beat this into my brain! It's been a while since I reread that.