Maybe class "map" function doesn't compose

[ChuckJonas]

In chapter 8, Maybe is defined as follows:

class Maybe {
  static of(x) {
    return new Maybe(x);
  }

  get isNothing() {
    return this.$value === null || this.$value === undefined;
  }

  constructor(x) {
    this.$value = x;
  }

  map(fn) {
    return this.isNothing ? this : Maybe.of(fn(this.$value));
  }

  inspect() {
    return this.isNothing ? 'Nothing' : `Just(${inspect(this.$value)})`;
  }
}

Then an example is provided using a . style:

Maybe.of({ name: 'Boris' }).map(prop('age')).map(add(10));
// Nothing

However, it's been brought to my attention that this is not a "lawful" use of a functor because it doesn't compose?

const f = (v) => v.name;
const g = JSON.stringify;
const fandTheng = (a) => g(f(a));
const user = { name: null };
console.log(
  Maybe.of(user).map(f).map(g).inspect(),  // Nothing 
  Maybe.of(user).map(fandTheng).inspect()  // Just(null) 
); // not equal, breaks the law of composition!

I haven't finished the book so sorry if this is address further on.

PS: I think the inspect method has a bug in the recursion as this example will break it.

[hugh-lx]

I'd be remiss if I didn't mention that the "real" implementation will split Maybe into two types: one for something and the other for nothing. This allows us to obey parametricity in map so values like null and undefined can still be mapped over and the universal qualification of the value in a functor will be respected. You'll often see types like Some(x) / None or Just(x) / Nothing instead of a Maybe that does a null check on its value.

Because of the simplified implementation, there are no Just(null) and Just(undefined).
There is no recursion in Maybe.prototype.inspect. And inspect is weird in Firefox.

[sevillaarvin]

I'd be remiss if I didn't mention that the "real" implementation will split Maybe into two types: one for something and the other for nothing. This allows us to obey parametricity in map so values like null and undefined can still be mapped over and the universal qualification of the value in a functor will be respected. You'll often see types like Some(x) / None or Just(x) / Nothing instead of a Maybe that does a null check on its value.

Because of the simplified implementation, there are no Just(null) and Just(undefined). There is no recursion in Maybe.prototype.inspect. And inspect is weird in Firefox.

I couldn't understand that paragraph. Thank you for explaining it clearly.

[LannyRipple]

Java's Optional has the same issue because using .map on something that results in null will turn your Optional into an Optional.empty. It breaks referential transparency and makes things harder to reason about during refactoring but it (and Appendix B's Maybe) is still very useful even with a gotcha to be aware of instead of something that just works.